Hi, I have a struct like testUser as below.

type testUser struct {
	name string
	domain string
}

func newTestUser(name string, domain string) *testUser {
	u := testUser{}
	u.name = name
	u.domain = domain
	return &u
}

func (u *testUser) getAttribute(attributeName string) string {
	ru := reflect.ValueOf(u)
	f := reflect.Indirect(ru).FieldByName(attributeName)
	return f.String()
}

func getAttribute2(u *testUser, attributeName string) string {
	ru := reflect.ValueOf(u)
	f := reflect.Indirect(ru).FieldByName(attributeName)
	return f.String()
}

func getAttribute3(userName string, attributeName string) string {
	u := getUserObjectByName(userName) // for example using a map
	ru := reflect.ValueOf(u)
	f := reflect.Indirect(ru).FieldByName(attributeName)
	return f.String()
}

alice := newTestUser("alice", "domain1")

I'd like to make the properties of testUser object dynamically parsed in govaluate, the object is an input parameter. I don't know if this is possible.

1. The best expectation is: expression = alice.name, and use alice object as a parameter. If this is not possible:
2. I define a func (u *testUser) getAttribute(attributeName string) string function as above. expression = alice.getAttribute("name"), and use alice object as a parameter. If this is either not possible:
3. I define a global func getAttribute2(u *testUser, attributeName string) string function as above. expression = getAttribute2(alice, "name"), and use alice object as a parameter.
4. The last way to to define func getAttribute3(userName string, attributeName string) string. expression = getAttribute2("alice", "name"), and use alice name as a string parameter. I know this way works. But it is inconvenient because I need to implement a get-object-by-name function via a map. So I don't want this way.

So my priority is: 1. > 2. > 3. > 4. Do any of the above ideas 1, 2, 3 work in govaluate? Thanks!

Would it be possible to add a function which would tell you whether or not a given expression yielded a boolean or numeric value without submitting any parameter values?

Take these two test for example

2 / 6 / 3 and 2 - 6 - 10 - 2, simple enough right?

Running those same expressions through nodejs, ruby, and go gives different results then this evaluator.

Node:

> 2 / 6 / 3
0.1111111111111111
> 2 - 6 - 10 - 2
-16

Ruby:

2.0.0-p645 :002 > 2.0 / 6.0 / 3.0
 => 0.1111111111111111
2.0.0-p645 :003 > 2 - 6 - 10 - 2
 => -16

Go:

/////////////////////////////
// main.go
/////////////////////////////
package main

import (
  "fmt"
)

func main() {
  t1 := 2.0 / 6.0 / 3.0
  fmt.Println(t1)
  t2 := 2 - 6 - 10 - 2
  fmt.Println(t2)
}
/////////////////////////////
/////////////////////////////

$ go run main.go
0.1111111111111111
-16

EvaluationTest{
  Name:     "Incorrect divide behavior",
  Input:    "2 / 6 / 3",
  Expected: 0.1111111111111111,
},
EvaluationTest{
  Name:     "Incorrect subtract behavior",
  Input:    "2 - 6 - 10 - 2",
  Expected: -16.0,
}

evaluation_test.go:877: Test 'Incorrect divide behavior' failed
evaluation_test.go:878: Evaluation result '1' does not match expected: '0.1111111111111111'
evaluation_test.go:877: Test 'Incorrect subtract behavior' failed
evaluation_test.go:878: Evaluation result '4' does not match expected: '-16'

The issue is the parser is moving right -> left NOT left -> right . I tried playing around with swapping the value vs rightValue orders but it gets messy. I'm sure this is a simple fix but I'm still trying to fully understand how the evaluate chain and the token stream all play together in respect to order of evaluation.

Cheers, W

Hello and thanks for the useful library, but i've got an issue with it.

I have a quite simple expression: ([X] >= 2887057408 && [X] <= 2887122943) || ([X] >= 168100864 && [X] <= 168118271)

If i pass X = 2887057409, which satisfies first expression in parenthesis, the expression is for some reason evaluated to FALSE.

If i pass X = 168100865, which satisfies second part of an expression in parenthesis, i get TRUE.

If i swap the sub-expressions, then i get the inverted behaviour.

If i use smaller numbers, like: ([X] >= 0 && [X] <= 10) || ([X] >= 20 && [X] <= 30)

then the expression is evaluated right in all cases.

I think the problem is with numbers being converted to float64, however looking at tokens after expression compilation the numbers seem fine: {Kind:13 Value:40} {Kind:7 Value:X} {Kind:10 Value:>=} {Kind:2 Value:2.887057408e+09} {Kind:11 Value:&&} {Kind:7 Value:X} {Kind:10 Value:<=} {Kind:2 Value:2.887122943e+09} {Kind:14 Value:41} {Kind:11 Value:||} {Kind:13 Value:40} {Kind:7 Value:X} {Kind:10 Value:>=} {Kind:2 Value:1.68100864e+08} {Kind:11 Value:&&} {Kind:7 Value:X} {Kind:10 Value:<=} {Kind:2 Value:1.68118271e+08} {Kind:14 Value:41}

And this does not explain why the behaviour changes if i just reverse the parts before and after || operator...

hi, this library is great. User defined parameters/variables is very welcome. Is there any chance you can add user defined functions as well (ideally nested user defined functions).

example:

"(requests_made("5m") * requests_succeeded("5m") / 100) >= 90"

& (and), | (or), ^ (xor), and ~ (not) are now supported.

Float64 values are truncated to int64 then converted back.

The exponent operator is now **.

Simple syntax for functions conjunction the result if function which before '|>' will be added as last argument to function which is after '|>'

"foo() |> bar(10) |> woo(20)
// it is same as
"woo(20, bar(10, foo()))"

I wrote this function:

    functions := map[string]govaluate.ExpressionFunction{
        "now": func(args ...interface{}) (interface{}, error) {
            return float64(time.Now().UnixNano() / 1e6), nil
        },
    }

Executing 1+now() works but now()+1 yields "Unable to plan token kind: MODIFIER".

More complex arithmetic expressions including now() trigger other errors.

Thanks for this awesome library! For a special use case I tried to slim it down to work only with float64 as parameters and results, and maybe boolean as interim results. I want to get rid of the interfaces for performance reasons and wanted the result to be an error flag when one of the parameters is an error flag (>= 9.999.999). I started by changing the parameters map to be a map[string]float64 and then tried to hunt down the compiler errors. But I have a hard time doing so. May I ask for some hint?

Thanks in advance!

Hi,

First, thanks for the library, its awesome! I have a question on how to use/extent the library to fit my needs. I intend to use it in order to eval questionnaires, while every questionnaire composed of dif questions types. Some are simple, for instance a dates compare, single answer IN array etc.., but how can i implement MANY in ARRAY, e.g. my use selects many choices and there are many possible answers? I checked the library and this expression "(2) IN (1, 2, 3)" works as oppose to "(1,2) IN (1, 2, 3)". I thought about extend it myself but as my expression will be used for many questionnaires i want to cache the right side (1,2,3) into a map to achieve performance... How can it be done?

thanks!

First of all, thank you so much for your library. It is awesome.

I am trying to evaluate an expression with a date value set in parameters. I have posted a question on StackOverflow about this: https://stackoverflow.com/questions/44893202/compare-date-values-in-expression-using-govaluate

Is there a way i can achieve the following:

package main

import (
    "github.com/Knetic/govaluate"
    "fmt"
)

func main()  {
    expression, err := govaluate.NewEvaluableExpression("first_name == 'Julian' && emp_id == 302 && birth_date >= '2016-12-12' && birth_date <= '2016-12-25'")

    parameters := make(map[string]interface{}, 8)
    parameters["first_name"] = "Julian"
    parameters["emp_id"] = 302
    parameters["birth_date"] = "2016-12-15"
    result, err := expression.Evaluate(parameters)

    if err != nil {
        fmt.Println("Error while evaluating the expression")
    }

    if result.(bool) {
        fmt.Println("Condition is evaluated to true")
    } else {
        fmt.Println("Condition is evaluated to false")
    }
}

I a getting this error:

Error while evaluating the expression
panic: interface conversion: interface is nil, not bool

I tried doing the following: convert the date literal into float and pass as a parameter.

dateFloat, _ := strconv.ParseFloat("2016-12-15", 64)
parameters["birth_date"] = dateFloat

Although, the error disappeared, the result value is false which is logically wrong since "2016-12-15" falls between "2016-12-12" and "2016-12-25".

Can you suggest me a way to achieve it?

Got an error when expression is a url string.

`

  package test
  
  import (
      "github.com/Knetic/govaluate"
      "testing"
  )
  
  func TestGovaluate(t *testing.T) {
      _, err := govaluate.NewEvaluableExpression("https://pms.deeptest.com/api/v1")
      if err != nil {
	      return
      }
  }

`

expression, _ := govaluate.NewEvaluableExpression("1 + 2")
result, _ := expression.Evaluate(nil)

Sometimes precision is mandated , is there plan to make it possible to specify the result type as uint64 or big.Int instead of the default type float64 ?

when I use NewEvaluableExpressionWithFunctions, the expression param is a const string. so I hope to pre compile expression to improve performance.

thanks!

The library panics with a single backslash as the input:

govaluate.NewEvaluableExpression(`\`)

panic: runtime error: index out of range [1] with length 1 [recovered]
        panic: runtime error: index out of range [1] with length 1

functions := map[string]govaluate.ExpressionFunction {
		"strlen": func(args ...interface{}) (interface{}, error) {
			length := len(args[0].(string))
			return (float64)(length), nil
		},
	}

	expString := "strlen('someReallyLongInputString') <= 16"
	expression, _ := govaluate.NewEvaluableExpressionWithFunctions(expString, functions)

	result, _ := expression.Evaluate(nil)
	// result is now "false", the boolean value

why does the non-functional expression version handle the type-casting into a number type, while the functional version needs us to explicitly typecast our returned value into a float64? it fails and gives me a comparator/modifier error when i remove the explicit float64() typecasting.

callbackA := func(args ...interface{}) (interface{}, error) {
	return 123, nil
}

callbackB := func(args ...interface{}) (interface{}, error) {
	return 123, nil
}

callbacks := map[string]govaluate.ExpressionFunction{
	"callbackA": callbackA,
	"callbackB": callbackB,
}

expression, _ := govaluate.NewEvaluableExpressionWithFunctions("callbackA() >= callbackB()", callbacks)
res, err := expression.Evaluate(nil)
fmt.Println(res, err)

Returns: Value '123' cannot be used with the comparator '>=', it is not a number