Golang中如何按顺序评估表达式中的每个必需变量

要按顺序评估表达式中的每个必需变量，可以使用拓扑排序来处理依赖关系。以下是一个实现示例：

package main

import (
	"fmt"
	"log"

	"github.com/Knetic/govaluate"
)

func evaluateFormulas(expressionsMap map[string]*govaluate.EvaluableExpression,
	requiredVariables map[string][]string,
	initialParams map[string]interface{}) (map[string]interface{}, error) {

	// 复制初始参数
	params := make(map[string]interface{})
	for k, v := range initialParams {
		params[k] = v
	}

	// 跟踪已评估的表达式
	evaluated := make(map[string]bool)
	for k := range initialParams {
		evaluated[k] = true
	}

	// 拓扑排序评估
	for {
		progress := false

		for exprName, expr := range expressionsMap {
			if evaluated[exprName] {
				continue
			}

			// 检查所有依赖是否已评估
			allDepsEvaluated := true
			for _, dep := range requiredVariables[exprName] {
				if _, exists := params[dep]; !exists {
					allDepsEvaluated = false
					break
				}
			}

			if allDepsEvaluated {
				// 评估表达式
				result, err := expr.Evaluate(params)
				if err != nil {
					return nil, fmt.Errorf("failed to evaluate %s: %v", exprName, err)
				}
				params[exprName] = result
				evaluated[exprName] = true
				progress = true
			}
		}

		// 如果没有进展，检查是否所有表达式都已评估
		if !progress {
			// 检查是否有未评估的表达式
			remaining := []string{}
			for exprName := range expressionsMap {
				if !evaluated[exprName] {
					remaining = append(remaining, exprName)
				}
			}
			if len(remaining) > 0 {
				return nil, fmt.Errorf("circular dependency detected or missing dependencies: %v", remaining)
			}
			break
		}
	}

	return params, nil
}

func main() {
	// 示例数据
	functions := map[string]govaluate.ExpressionFunction{}
	
	// 创建表达式
	markupExpr, _ := govaluate.NewEvaluableExpressionWithFunctions("totalCost / .85", functions)
	handlingExpr, _ := govaluate.NewEvaluableExpressionWithFunctions("cost > 100 ? 25 : cost * 0.1", functions)
	totalCostExpr, _ := govaluate.NewEvaluableExpressionWithFunctions("(cost * qty) + handlingCharge", functions)

	expressionsMap := map[string]*govaluate.EvaluableExpression{
		"markup":        markupExpr,
		"handlingCharge": handlingExpr,
		"totalCost":     totalCostExpr,
	}

	requiredVariables := map[string][]string{
		"markup":        {"totalCost"},
		"handlingCharge": {"cost"},
		"totalCost":     {"cost", "qty", "handlingCharge"},
	}

	initialParams := map[string]interface{}{
		"cost": 9.99,
		"qty":  2.0,
	}

	// 评估所有公式
	results, err := evaluateFormulas(expressionsMap, requiredVariables, initialParams)
	if err != nil {
		log.Fatal(err)
	}

	// 输出结果
	fmt.Printf("cost: %.2f\n", results["cost"])
	fmt.Printf("qty: %.0f\n", results["qty"])
	fmt.Printf("handlingCharge: %.2f\n", results["handlingCharge"])
	fmt.Printf("totalCost: %.2f\n", results["totalCost"])
	fmt.Printf("markup: %.2f\n", results["markup"])
}

对于更复杂的依赖关系，可以使用基于深度优先搜索的拓扑排序：

func topologicalSort(requiredVariables map[string][]string) ([]string, error) {
	visited := make(map[string]int) // 0=未访问, 1=访问中, 2=已访问
	order := []string{}

	var dfs func(string) error
	dfs = func(node string) error {
		if visited[node] == 1 {
			return fmt.Errorf("circular dependency detected at %s", node)
		}
		if visited[node] == 2 {
			return nil
		}

		visited[node] = 1
		for _, dep := range requiredVariables[node] {
			if _, exists := requiredVariables[dep]; exists {
				if err := dfs(dep); err != nil {
					return err
				}
			}
		}
		visited[node] = 2
		order = append(order, node)
		return nil
	}

	for node := range requiredVariables {
		if visited[node] == 0 {
			if err := dfs(node); err != nil {
				return nil, err
			}
		}
	}

	return order, nil
}

func evaluateWithTopologicalSort(expressionsMap map[string]*govaluate.EvaluableExpression,
	requiredVariables map[string][]string,
	initialParams map[string]interface{}) (map[string]interface{}, error) {

	// 获取评估顺序
	order, err := topologicalSort(requiredVariables)
	if err != nil {
		return nil, err
	}

	// 合并参数
	params := make(map[string]interface{})
	for k, v := range initialParams {
		params[k] = v
	}

	// 按顺序评估
	for _, exprName := range order {
		expr, exists := expressionsMap[exprName]
		if !exists {
			continue
		}

		result, err := expr.Evaluate(params)
		if err != nil {
			return nil, fmt.Errorf("failed to evaluate %s: %v", exprName, err)
		}
		params[exprName] = result
	}

	return params, nil
}

这些实现会按依赖顺序评估所有公式，自动处理嵌套的公式引用，并检测循环依赖。