//通過go get直接安裝即可
go get github.com/expr-lang/expr

package main

import (
        "fmt"
        "github.com/expr-lang/expr"
)

func main() {
        // 編譯一個(gè)基礎(chǔ)的加法表達(dá)式
        program, err := expr.Compile(`2 + 2`)
        if err != nil {
                panic(err)
        }

        // 運(yùn)行編譯后的表達(dá)式，并沒有傳入環(huán)境，因?yàn)檫@里不需要使用任何變量
        output, err := expr.Run(program, nil)
        if err != nil {
                panic(err)
        }

        // 打印結(jié)果
        fmt.Println(output)  // 輸出 4
}

package main

import (
    "fmt"
    "github.com/expr-lang/expr"
)

func main() {
    // 創(chuàng)建一個(gè)包含變量的環(huán)境
    env := map[string]interface{}{
       "apple":  5,
       "banana": 10,
    }

    // 編譯一個(gè)使用環(huán)境中變量的表達(dá)式
    program, err := expr.Compile(`apple + banana`, expr.Env(env))
    if err != nil {
       panic(err)
    }

    // 運(yùn)行表達(dá)式
    output, err := expr.Run(program, env)
    if err != nil {
       panic(err)
    }

    // 打印結(jié)果
    fmt.Println(output) // 輸出 15
}

// (1) 數(shù)字
42      // 表示整數(shù) 42
3.14    // 表示浮點(diǎn)數(shù) 3.14


// (2) 字符串
"hello, world" // 雙引號包裹的字符串，支持轉(zhuǎn)義字符
`hello, world` // 反引號包裹的字符串，保持字符串格式不變，不支持轉(zhuǎn)義

// (3)布爾值
true   // 布爾真值
false  // 布爾假值

// (1)表達(dá)式定義變量
env := map[string]interface{}{
    "age": 25,
    "name": "Alice",
}

// (2)表達(dá)式中引用變量
age > 18  // 檢查age是否大于18
name == "Alice"  // 判斷name是否等于"Alice"

2 + 2 // 計(jì)算結(jié)果為4
7 % 3 // 結(jié)果為1
!true // 結(jié)果為false
age >= 18 && name == "Alice" // 檢查age是否不小于18且name是否等于"Alice"

age == 25 // 檢查age是否等于25
age != 18 // 檢查age是否不等于18
age > 20  // 檢查age是否大于20

"user" in ["user", "admin"]  // true，因?yàn)?user"在數(shù)組中
3 in {1: true, 2: false}     // false，因?yàn)?不是字典的鍵

all(tweets, {.Len <= 240})  // 檢查所有tweets的Len字段是否都不超過240
any(tweets, {.Len > 200})   // 檢查是否存在tweets的Len字段超過200

// (1) 定義結(jié)構(gòu)體
type User struct {
    Name string
    Age  int
}

// (2)訪問結(jié)構(gòu)體變量
env := map[string]interface{}{
    "user": User{Name: "Alice", Age: 25},
}

code := `user.Name`

program, err := expr.Compile(code, expr.Env(env))
if err != nil {
    panic(err)
}

output, err := expr.Run(program, env)
if err != nil {
    panic(err)
}

fmt.Println(output) // 輸出: Alice

author.User?.Name

// 等價(jià)于下面的表達(dá)式
author.User != nil ? author.User.Name : nil

author.User?.Name ?? "Anonymous"

// 等價(jià)于下面表達(dá)式
author.User != nil ? author.User.Name : "Anonymous"

// 檢查所有 tweets 的 Content 長度是否小于 240
code := `all(tweets, len(.Content) < 240)`
program, err := expr.Compile(code, expr.Env(env))
if err != nil {
    panic(err)
}

// 檢查是否有任一 tweet 的 Content 長度大于 240
code := `any(tweets, len(.Content) > 240)`

// 確保沒有 tweets 是重復(fù)的
code := `none(tweets, .IsRepeated)`

// 內(nèi)置函數(shù)示例
program, err := expr.Compile(`all(users, {.Age >= 18})`, expr.Env(env))
if err != nil {
    panic(err)
}

// 注意：這里env需要包含users變量，每個(gè)用戶都需要有Age屬性
output, err := expr.Run(program, env)
fmt.Print(output) // 如果env中所有用戶年齡都大于等于18，返回true

// 自定義函數(shù)示例
env := map[string]interface{}{
    "greet": func(name string) string {
        return fmt.Sprintf("Hello, %s!", name)
    },
}

program, err := expr.Compile(`greet("World")`, expr.Env(env))
if err != nil {
    panic(err)
}

output, err := expr.Run(program, env)
fmt.Print(output) // 返回 Hello, World!

package main

import (
    "fmt"
    "log"
    "time"

    "github.com/expr-lang/expr"
    "github.com/expr-lang/expr/vm"
)

// 用戶信息
type User struct {
    ID       int
    Name     string
    Level    int    // 會員等級（1-普通, 2-黃金, 3-鉆石）
    Region   string // 用戶所在地區(qū)
    JoinTime time.Time
}

// 訂單信息
type Order struct {
    OrderID     string
    Amount      float64 // 訂單金額
    Category    string  // 商品類目（electronics, clothing, food）
    CreatedTime time.Time
}

// 促銷規(guī)則配置
type PromotionRule struct {
    Condition string  // Expr表達(dá)式，判斷是否滿足條件
    Discount  float64 // 折扣比例（0.9表示9折）
}

// 初始化規(guī)則引擎環(huán)境
func createEnv(user User, order Order) map[string]interface{} {
    return map[string]interface{}{
       "User":  user,
       "Order": order,
       "Now":   time.Now(), // 內(nèi)置當(dāng)前時(shí)間函數(shù)
       // 可添加其他輔助函數(shù)，如字符串處理、數(shù)學(xué)計(jì)算等
    }
}

// 編譯促銷規(guī)則條件
func compileRule(rule string) (*vm.Program, error) {
    return expr.Compile(rule, expr.Env(createEnv(User{}, Order{})))
}

// 應(yīng)用促銷規(guī)則
func ApplyPromotion(user User, order Order, rule PromotionRule) (bool, float64, error) {
    // 1. 編譯規(guī)則（生產(chǎn)環(huán)境需緩存編譯結(jié)果）
    program, err := compileRule(rule.Condition)
    if err != nil {
       return false, 0, fmt.Errorf("規(guī)則編譯失敗: %v", err)
    }

    // 2. 創(chuàng)建執(zhí)行環(huán)境
    env := createEnv(user, order)

    // 3. 執(zhí)行規(guī)則判斷
    output, err := expr.Run(program, env)
    if err != nil {
       return false, 0, fmt.Errorf("規(guī)則執(zhí)行失敗: %v", err)
    }

    // 4. 類型斷言判斷結(jié)果
    conditionMet, ok := output.(bool)
    if !ok {
       return false, 0, fmt.Errorf("規(guī)則必須返回布爾值")
    }

    // 5. 返回是否滿足條件及折扣
    return conditionMet, rule.Discount, nil
}

func main() {
    // 模擬用戶和訂單數(shù)據(jù)
    user := User{
       ID:       1001,
       Name:     "Alice",
       Level:    3,
       Region:   "CN",
       JoinTime: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC),
    }
    order := Order{
       OrderID:     "20231020001",
       Amount:      1500.00,
       Category:    "electronics",
       CreatedTime: time.Now(),
    }

    // 從數(shù)據(jù)庫/配置中心讀取促銷規(guī)則（示例）
    rules := []PromotionRule{
       {
          // 規(guī)則1：鉆石會員且訂單金額>1000，享85折
          Condition: `User.Level >= 3 && Order.Amount > 1000 && Order.Category == "electronics"`,
          Discount:  0.85,
       },
       {
          // 規(guī)則2：注冊超過2年的用戶，任意訂單享9折
          Condition: `Now.Sub(User.JoinTime).Hours() > 24*365*2`,
          Discount:  0.9,
       },
    }

    // 遍歷所有規(guī)則，應(yīng)用最優(yōu)折扣
    bestDiscount := 1.0 // 默認(rèn)無折扣
    for _, rule := range rules {
       valid, discount, err := ApplyPromotion(user, order, rule)
       if err != nil {
          log.Printf("規(guī)則應(yīng)用錯(cuò)誤: %v", err)
          continue
       }
       if valid && discount < bestDiscount {
          bestDiscount = discount
       }
    }

    // 計(jì)算最終價(jià)格
    finalPrice := order.Amount * bestDiscount
    fmt.Printf("原價(jià): ￥%.2f\n", order.Amount)
    fmt.Printf("適用折扣: %.0f%%\n", (1-bestDiscount)*100)
    fmt.Printf("最終價(jià)格: ￥%.2f\n", finalPrice)
}

// 規(guī)則配置（存儲于數(shù)據(jù)庫）
rules := []PromotionRule{
    {
        Condition: `User.Level >= 3 && Order.Amount > 1000 && Order.Category == "electronics"`,
        Discount:  0.85,
    },
}
// 動(dòng)態(tài)執(zhí)行
valid, _ := ApplyPromotion(user, order, rule)

func IsPromotionValid(user User, order Order) bool {
    return user.Level >= 3 && 
           order.Amount > 1000 && 
           order.Category == "electronics"
}