Golang中直接执行代码（Evaling）的实现方法

Golang中直接执行代码（Evaling）的实现方法 //https://play.golang.org/p/Jr0fprGwuvR

package main

import (
    "fmt"
)
const EAX = 0x01


func returnStr() string {
    return "(EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)"
}
func main() {
    fmt.Println(returnStr()) 
    fmt.Println((EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)) //65
}

大家好，

这个函数返回的是字符串，但输出仍然是字符串形式。我该怎么做才能让输出显示为65？


更多关于Golang中直接执行代码（Evaling）的实现方法的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

如果你返回一个字符串，你将得到一个字符串。

更多关于Golang中直接执行代码（Evaling）的实现方法的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Go 不会在字符串中用常量名替换其值。你必须先进行计算，然后将其转换为字符串：

package main

import (
	"fmt"
	"strconv"
)

const (
	KB = 1024
	MB = KB * 1024
	GB = MB * 1024
)

func main() {
	fmt.Println("KB: " + strconv.Itoa(KB))
	fmt.Println("MB: " + strconv.Itoa(MB))
	fmt.Println("GB: " + strconv.Itoa(GB))
}

https://play.golang.org/p/CYcEhuJYz-i

在Go语言中，没有内置的eval()函数来直接执行字符串形式的代码。不过可以通过几种方法实现类似的功能：

方法1：使用表达式解析库（推荐）

使用第三方库如expr或govaluate来解析和执行数学表达式：

package main

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

const EAX = 0x01

func evaluateExpression(expr string) (interface{}, error) {
    parameters := make(map[string]interface{})
    parameters["EAX"] = float64(EAX)
    
    expression, err := govaluate.NewEvaluableExpression(expr)
    if err != nil {
        return nil, err
    }
    
    result, err := expression.Evaluate(parameters)
    if err != nil {
        return nil, err
    }
    
    return result, nil
}

func main() {
    expr := "(EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)"
    
    result, err := evaluateExpression(expr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println(expr)  // 输出字符串形式
    fmt.Println(result) // 输出计算结果 65
}

首先安装依赖：

go get github.com/Knetic/govaluate

方法2：使用Go插件系统（复杂场景）

对于更复杂的代码执行，可以使用Go的插件机制：

package main

import (
    "fmt"
    "plugin"
)

// 需要预先编译为插件的代码
// 保存为 calculate.go 然后运行: go build -buildmode=plugin -o calculate.so calculate.go
func Calculate() int {
    const EAX = 0x01
    return (EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)
}

主程序加载插件：

func main() {
    p, err := plugin.Open("calculate.so")
    if err != nil {
        fmt.Println("Error loading plugin:", err)
        return
    }
    
    calculateFunc, err := p.Lookup("Calculate")
    if err != nil {
        fmt.Println("Error looking up function:", err)
        return
    }
    
    result := calculateFunc.(func() int)()
    fmt.Println(result) // 输出 65
}

方法3：简单的字符串替换和计算

对于简单的数学表达式，可以自己实现解析：

package main

import (
    "fmt"
    "strconv"
    "strings"
)

const EAX = 0x01

func evaluateSimple(expr string) int {
    // 替换 EAX 为实际值
    replaced := strings.ReplaceAll(expr, "EAX", strconv.Itoa(EAX))
    
    // 这里需要实现完整的表达式解析器
    // 对于这个特定例子，可以直接计算
    return (EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)
}

func main() {
    expr := "(EAX<<EAX<<EAX<<EAX<<EAX<<EAX<<EAX^EAX)"
    
    fmt.Println(expr)                    // 输出字符串形式
    fmt.Println(evaluateSimple(expr))    // 输出计算结果 65
}

推荐使用第一种方法，因为它提供了完整的表达式解析功能，支持各种运算符和函数，且相对安全。

回到顶部