日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

Golang?動態腳本調研詳解_Golang

作者：輕聆月下 ? 更新時間： 2022-10-29 編程語言

一、技術背景

1.1 程序的動態鏈接技術

在實際開發過程中，我們經常需要動態地更新程序的功能，或者在不變更程序主體文件的情況下添加或者更新程序模塊。

1.1.1 動態鏈接庫

首先最常見的是windows平臺所支持的動態鏈接庫（Dynamic Link Library），一般后綴名為.dll?。其優勢非常明顯：

  • 多個程序可以共享代碼和數據。即多個程序加載同一個DLL文件。
  • 可以自然地將程序劃分為若干個模塊。每個模塊輸出為單獨的DLL文件，由主程序加載執行。
  • 跨語言調用。由于DLL文件是語言無關的，一個DLL文件可以被多種編程語言加載執行。
  • 便于更新。在程序更新過程中，僅更新對應模塊的DLL文件即可，無需重新部署整個程序。
  • 為熱更新提供技術可能性。動態鏈接庫可以通過編程手段實現加載和卸載，以此可以支持不重啟程序的情況下更新模塊。
  • 為程序提供編程接口。可以將自己程序的調用接口封裝為DLL文件，供其他程序調用。

1.1.2 動態共享對象

在Linux平臺，此項技術名為動態共享對象（dynamic shared objects），常見后綴名為.so。

動態共享對象除了上述“動態鏈接庫”的優勢之外，也能解決由于Linux的開放性帶來的底層接口兼容問題。即通過動態共享對象封裝操作系統底層接口，對外提供統一的調用接口，以供上層應用程序調用。相當于提供了一層兼容層。

1.1.3 非編譯語言的動態技術

非編譯語言，由于本身是通過源代碼發布，所以實現動態加載程序模塊或者更新模塊，直接修改源代碼即可。思路簡單且容易實現。

1.2 Golang 的動態技術

Golang作為編譯型的開發語言，本身并不支持通過源代碼實現動態加載和更新。但Golang官方提供了Plugin技術，實現動態加載。

通過在編譯時添加參數，將Go程序編譯為 Plugin：

go build -buildmode=plugin

但是此技術在當前版本（1.19）局限性非常大。通過其文檔?https://pkg.go.dev/plugin?可知：

  • 平臺限制，目前僅支持：Linux, FreeBSD 和 macOS
  • 卸載限制，僅支持動態加載，不支持動態卸載。
  • 不提供統一接口，只能通過反射處理Plugin內部的屬性和函數。

并且上述問題，Golang官方并不打算解決……

二、Golang 的第三方解釋器（Yaegi）

解釋器一般只存在于腳本語言中，但是Traefik為了實現動態加載的插件功能，開發了一個Golang的解釋器。提供了在運行時直接執行Golang源代碼的能力。

參考項目：https://github.com/traefik/yaegi

2.1 使用場景

yaegi 項目官方推薦三種場景：

  • 內嵌解釋器
  • 動態擴展框架
  • 命令行解釋器

并且官方針對上述三種場景，均給出了相應的示例：

2.1.1 內嵌解釋器

package main
import (
    "github.com/traefik/yaegi/interp"
    "github.com/traefik/yaegi/stdlib"
)
func main() {
    i := interp.New(interp.Options{})
    i.Use(stdlib.Symbols)
    _, err := i.Eval(`import "fmt"`)
    if err != nil {
        panic(err)
    }
    _, err = i.Eval(`fmt.Println("Hello Yaegi")`)
    if err != nil {
        panic(err)
    }
}

2.1.2 動態擴展框架

package main
import "github.com/traefik/yaegi/interp"
const src = `package foo
func Bar(s string) string { return s + "-Foo" }`
func main() {
    i := interp.New(interp.Options{})
    _, err := i.Eval(src)
    if err != nil {
        panic(err)
    }
    v, err := i.Eval("foo.Bar")
    if err != nil {
        panic(err)
    }
    bar := v.Interface().(func(string) string)
    r := bar("Kung")
    println(r)
}

2.1.3 命令行解釋器

Yaegi提供了一個命令行工具，實現了 讀取-執行-顯示 的循環。

$ yaegi
> 1 + 2
3
> import "fmt"
> fmt.Println("Hello World")
Hello World
>

2.2 數據交互

數據交互方式比較多，需要注意的是從解釋器內部返回的數據都是?reflect.Value?類型，獲取其實際的值需要類型轉換。

2.2.1 數據輸入

可以有（但不限于）下述四種方法：

  • 通過 os.Args 傳入數據
  • 通過 環境變量 傳入數據
  • 通過 賦值語句 傳入數據
  • 通過 函數調用 傳入數據

下面是我自己寫的代碼示例：

package main
import (
	"fmt"
	"github.com/traefik/yaegi/interp"
	"github.com/traefik/yaegi/stdlib"
)
func main() {
	{ // 通過 os.Args 傳入數據
		i := interp.New(interp.Options{
			Args: []string{"666"},
		})
		i.Use(stdlib.Symbols)
		i.Eval(`import "fmt"`)
		i.Eval(`import "os"`)
		i.Eval(`fmt.Printf("os.Args[0] --- %s\n", os.Args[0])`) 
               // os.Args[0] --- 666
	}
	{ // 通過 環境變量 傳入數據
		i := interp.New(interp.Options{
			Env: []string{"inputEnv=666"},
		})
		i.Use(stdlib.Symbols)
		i.Eval(`import "fmt"`)
		i.Eval(`import "os"`)
		i.Eval(`fmt.Printf("os.Getenv(\"inputEnv\") --- %s\n", os.Getenv("inputEnv"))`)
               // os.Getenv("inputEnv") --- 666
	}
	{ // 執行賦值語句傳入數據
		i := interp.New(interp.Options{})
		i.Use(stdlib.Symbols)
		i.Eval(`import "fmt"`)
		i.Eval(fmt.Sprintf("inputVar:=\"%s\"", "666"))
		i.Eval(`fmt.Printf("inputVar --- %s\n", inputVar)`)
               // inputVar --- 666
	}
        { // 通過函數調用傳遞
		i := interp.New(interp.Options{})
		i.Use(stdlib.Symbols)
		i.Eval(`import "fmt"`)
		i.Eval(`var data map[string]interface{}`)
		i.Eval(`func SetData(d map[string]interface{}){ data = d }`)
		f, _ := i.Eval("SetData")
		fun := f.Interface().(func(map[string]interface{}))
		fun(map[string]interface{}{
			"data01": 666,
		})
		i.Eval(`fmt.Printf("SetData --- %d\n", data["data01"])`)
               // SetData --- 666
	}
}

2.1.2 數據輸出

從解釋器獲取數據，實際上是獲取全局變量的值，可以通過下述方法：

  • Eval 方法直接獲取
  • 通過函數調用獲取
  • Global 方法獲取所有全局變量
package main
import (
	"fmt"
	"github.com/traefik/yaegi/interp"
	"github.com/traefik/yaegi/stdlib"
)
func main() {
	{ // 通過 Eval 直接獲取
		i := interp.New(interp.Options{})
		i.Use(stdlib.Symbols)
		i.Eval(`data := 666`)
		v, _ := i.Eval("data")
		value := v.Interface().(int)
		fmt.Printf("data = %d\n", value)
               // data = 666
	}
        { // 通過函數返回值獲取
		i := interp.New(interp.Options{})
		i.Use(stdlib.Symbols)
		i.Eval(`data := 666`)
		i.Eval(`func GetData() int {return data}`)
		f, _ := i.Eval("GetData")
		fun := f.Interface().(func() int)
		fmt.Printf("data = %d\n", fun())
               // data = 666
	}
	{ // 通過 Eval 直接獲取
		i := interp.New(interp.Options{})
		i.Use(stdlib.Symbols)
		i.Eval(`dataInt := 666`)
		i.Eval(`dataStr := "666"`)
		for name, v := range i.Globals() {
			value := v.Interface()
			switch value.(type) {
			case int:
				fmt.Printf("%s = %d\n", name, value)
                               // dataInt = 666
			case string:
				fmt.Printf("%s = %s\n", name, value)
                               // dataStr = 666
			}
		}
	}
}

三、實現原理

就解釋器的實現原理，各個語言都大差不差。Golang由于其強大的基礎庫，直接提供了構建抽象語法樹（Abstract Syntax Tree）的能力。基于抽象語法樹實現腳本解釋器，就容易很多。

3.1 AST - 抽象語法樹

在計算機科學中，抽象語法樹（Abstract?Syntax?Tree，AST），或簡稱語法樹（Syntax tree），是源代碼語法結構的一種抽象表示。它以樹狀的形式表現編程語言的語法結構，樹上的每個節點都表示源代碼中的一種結構。

Golang 通過?go/ast?包（https://pkg.go.dev/go/ast），提供抽象語法樹相關能力。

3.1.1 抽象語法樹示例

我們取Golang語法的子集進行示例：一個簡單的條件表達式

`A!=1 && (B>1 || (C<1 && A>2))`

抽象語法樹長這樣：

   *ast.BinaryExpr {
   .  X: *ast.BinaryExpr {
   .  .  X: *ast.Ident {
   .  .  .  NamePos: -
   .  .  .  Name: "A"
   .  .  }
   .  .  OpPos: -
   .  .  Op: !=
   .  .  Y: *ast.BasicLit {
   .  .  .  ValuePos: -
   .  .  .  Kind: INT
   .  .  .  Value: "1"
   .  .  }
   .  }
   .  OpPos: -
   .  Op: &&
   .  Y: *ast.ParenExpr {
   .  .  Lparen: -
   .  .  X: *ast.BinaryExpr {
   .  .  .  X: *ast.BinaryExpr {
   .  .  .  .  X: *ast.Ident {
   .  .  .  .  .  NamePos: -
   .  .  .  .  .  Name: "B"
   .  .  .  .  }
   .  .  .  .  OpPos: -
   .  .  .  .  Op: >
   .  .  .  .  Y: *ast.BasicLit {
   .  .  .  .  .  ValuePos: -
   .  .  .  .  .  Kind: INT
   .  .  .  .  .  Value: "1"
   .  .  .  .  }
   .  .  .  }
   .  .  .  OpPos: -
   .  .  .  Op: ||
   .  .  .  Y: *ast.ParenExpr {
   .  .  .  .  Lparen: -
   .  .  .  .  X: *ast.BinaryExpr {
   .  .  .  .  .  X: *ast.BinaryExpr {
   .  .  .  .  .  .  X: *ast.Ident {
   .  .  .  .  .  .  .  NamePos: -
   .  .  .  .  .  .  .  Name: "C"
   .  .  .  .  .  .  }
   .  .  .  .  .  .  OpPos: -
   .  .  .  .  .  .  Op: <
   .  .  .  .  .  .  Y: *ast.BasicLit {
   .  .  .  .  .  .  .  ValuePos: -
   .  .  .  .  .  .  .  Kind: INT
   .  .  .  .  .  .  .  Value: "1"
   .  .  .  .  .  .  }
   .  .  .  .  .  }
   .  .  .  .  .  OpPos: -
   .  .  .  .  .  Op: &&
   .  .  .  .  .  Y: *ast.BinaryExpr {
   .  .  .  .  .  .  X: *ast.Ident {
   .  .  .  .  .  .  .  NamePos: -
   .  .  .  .  .  .  .  Name: "A"
   .  .  .  .  .  .  }
   .  .  .  .  .  .  OpPos: -
   .  .  .  .  .  .  Op: >
   .  .  .  .  .  .  Y: *ast.BasicLit {
   .  .  .  .  .  .  .  ValuePos: -
   .  .  .  .  .  .  .  Kind: INT
   .  .  .  .  .  .  .  Value: "2"
   .  .  .  .  .  .  }
   .  .  .  .  .  }
   .  .  .  .  }
   .  .  .  .  Rparen: -
   .  .  .  }
   .  .  }
   .  .  Rparen: -
   .  }
   }

圖形表示：

3.1.2 執行抽象語法樹

簡要說明一下如果要執行抽象語法樹，應該怎么做：

執行過程與程序執行過程相似。先遍歷聲明列表，將已聲明的內容初始化到堆內存（可以使用字典代替）。深度優先遍歷抽象語法樹，處理遍歷過程中遇到的抽象對象，比如（舉例而已，實際可能有出入）：

  • 初始化堆內存和執行棧。
  • 遍歷聲明部分，寫入堆，等待調用。
  • 找到主函數聲明，主函數入棧，遍歷其函數體語句，逐語句進行深度優先遍歷執行。

    遇到變量定義，則寫入棧頂緩存。

    遇到函數調用，則函數入棧。從堆中尋找函數定義，遍歷其函數體語句，遞歸執行語句。

    遇到變量使用，依次從下述位置獲取值：棧頂緩存 -> 堆內存

    遇到表達式，遞歸執行表達式。

    函數體執行結束后出棧，出棧后將返回值寫入棧頂緩存。

  • 上述遞歸過程完成，程序結束。

上述是簡單的執行過程，并未處理特殊語法和語法糖，各個語言的語法定義均有不同，需要單獨處理。比如，Golang支持的語法可以參考：https://pkg.go.dev/go/ast

若能對其中定義的所有語法進行處理，就可以實現golang的腳本解釋器。

對于上面（3.1.1）的那個簡單示例，可以通過下述代碼直接執行：

（不處理函數，只處理括號和有限的操作符。也未定義執行棧，堆內存使用全局變量Args代替）

package main
import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"strconv"
)
var Args map[string]int
func main() {
	{
		Args = map[string]int{"A": 1, "B": 2, "C": 3}
		code := `A==1 && (B>1 || C<1)`
		expr, _ := parser.ParseExpr(code)
		result := runExpr(expr)
		fmt.Println(result)
	}
	{
		Args["A"] = 3
		Args = map[string]int{"A": 1, "B": 2, "C": 3}
		code := `A!=1 && (B>1 || (C<1 && A>2))`
		expr, _ := parser.ParseExpr(code)
		result := runExpr(expr)
		fmt.Println(result)
	}
}
// 執行表達式
// 支持操作：>, <, ==, !=, &&, ||
// 支持括號嵌套
func runExpr(expr ast.Expr) interface{} {
	var result interface{}
	// 二元表達式
	if binaryExpr, ok := expr.(*ast.BinaryExpr); ok {
		switch binaryExpr.Op.String() {
		case "&&":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(bool) && y.(bool)
		case "||":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(bool) || y.(bool)
		case ">":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(int) > y.(int)
		case "<":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(int) < y.(int)
		case "==":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(int) == y.(int)
		case "!=":
			x := runExpr(binaryExpr.X)
			y := runExpr(binaryExpr.Y)
			return x.(int) != y.(int)
		}
	}
	// 基本類型值
	if basicLit, ok := expr.(*ast.BasicLit); ok {
		switch basicLit.Kind {
		case token.INT:
			v, _ := strconv.Atoi(basicLit.Value)
			return v
		}
	}
	// 標識符
	if ident, ok := expr.(*ast.Ident); ok {
		return Args[ident.Name]
	}
	// 括號表達式
	if parenExpr, ok := expr.(*ast.ParenExpr); ok {
		return runExpr(parenExpr.X)
	}
	return result
}

執行結果：

A==1 && (B>1 || C<1) => true

A!=1 && (B>1 || (C<1 && A>2)) => false

原文鏈接：https://www.cnblogs.com/moonlightwatch/p/16649242.html

欄目分類
最近更新