用Golang運行JavaScript

C++太麻煩(難)了，想要盤弄一下V8實在是有些費勁，可是Golang社區出了幾個Javascript引擎，要嘗試在別的語言中如何集成Javascript，是個不錯的選擇。如下選了github.com/dop251/goja 來作例子。

Hello world

照着倉庫的Readme，來一個：

package main

import (
    "fmt"
    js "github.com/dop251/goja"
)

func main() {
    vm := js.New() // 建立engine實例
    r, _ := vm.RunString(`
        1 + 1
    `) // 執行javascript代碼
    v, _ : = r.Export().(int64) // 將執行的結果轉換爲Golang對應的類型
    fmt.Println(r)
}複製代碼

這個例子展現了最基本的能力，給定一段Javascript的代碼文本，它能執行獲得一個結果，而且能獲得執行結果的宿主語言的表示形式。

交互

Javascript和Golang之間的交互分紅兩個方面：Golang向Javascript引擎中注入一些上下文，例如註冊一些全局函數供Javascript使用，建立一個對象等；Golang從Javascript引擎中讀取一些上下文，例如一個計算過程的計算結果。先看第一類。

經常使用的手段是，經過Runtime類型提供的Set方法在全局註冊一個變量，例如

...
rts := js.New()
rts.Set("x", 2)
rts.RunString(`x+x`) // 4
...複製代碼

此處Set的方法簽名是func (r *Runtime) Set(name string, value interface{})，對於基本類型，不須要額外的包裝，就能夠自動轉換，可是當須要傳遞一個複雜對象時，須要用NewObject包裝一下：

rts := js.New()
o := rts.NewObject()
o.Set("x", 2)
rts.Set("o", o)
rts.RunString(`o.x+o.x`) // 4複製代碼

切換到Golang的視角，是個很天然的過程，想要建立一個對象，須要在Golang中先建立一個對應的表述，而後在Javascript中才能使用。對於更復雜的對象，嵌套就行了。

定義函數則有所不一樣，不一樣之處在於Javascript中的函數在Golang中的表示和其它類型的值不太同樣，Golang中表式Javascript中的函數的簽名爲：func (js.FunctionCall) js.Value，js.FunctionCall中包含了調用函數的上下文信息，基於此咱們能夠嘗試給Javascript增長一個console.log的能力：

...
func log(call js.FunctionCall) js.Value {
    str := call.Argument(0)
    fmt.Print(str.String())
    return str
}
...
rts := js.New()
console := rts.NewObject()
console.Set("log", log)
rts.Set("console", console)
rts.RunString(`console.log('hello world')`) // hello world複製代碼

相較於向Javascript引擎中注入一些信息，從中讀取信息則比較簡單，前面的hello world中展現了一種方法，執行一段Javascript代碼，而後獲得一個結果。可是這種方法不夠靈活，若是想要精確的獲得某個上下文，變量的值，就不那麼方便。爲此，goja提供了Get方法，Runtime類型的Get方法能夠從Runtime中讀取某個變量的信息，Object類型的Get方法則能夠從對象中讀取某個字段的值。簽名以下：func (r *Runtime) Get(name string) Value，func (o *Object) Get(name string) Value。可是獲得的值的類型都是Value類型，想要轉換成對應的類型，須要經過一些方法來轉換，這裏就再也不贅述，有興趣能夠去看它的文檔。

一個複雜些的例子

goja值提供了基本的解析執行Javascript代碼的能力，可是咱們常見的宿主提供的能力，須要在使用的過程當中本身去補充。下面就基於上面的技巧，提供一個簡單的require加載本地Javascript代碼的能力。

經過require加載一段Commjs格式Javascript代碼，直觀的流程：根據文件名，讀取文本，組裝成一個當即執行函數，執行，而後返回module對象，可是中間能夠作一些小優化，好比已經被加載過的代碼， 就不從新加載，執行，只是返回就行了。大概的實現以下：

package core

import (
    "io/ioutil"
    "path/filepath"

    js "github.com/dop251/goja"
)

func moduleTemplate(c string) string {
    return "(function(module, exports) {" + c + "\n})"
}

func createModule(c *Core) *js.Object {
    r := c.GetRts()
    m := r.NewObject()
    e := r.NewObject()
    m.Set("exports", e)

    return m
}

func compileModule(p string) *js.Program {
    code, _ := ioutil.ReadFile(p)
    text := moduleTemplate(string(code))
    prg, _ := js.Compile(p, text, false)

    return prg
}

func loadModule(c *Core, p string) js.Value {
    p = filepath.Clean(p)
    pkg := c.Pkg[p]
    if pkg != nil {
        return pkg
    }

    prg := compileModule(p)

    r := c.GetRts()
    f, _ := r.RunProgram(prg)
    g, _ := js.AssertFunction(f)

    m := createModule(c)
    jsExports := m.Get("exports")
    g(jsExports, m, jsExports)

    return m.Get("exports")
}複製代碼

要想讓引擎能使用這個能力，就須要將require這個函數註冊到Runtime中，

// RegisterLoader register a simple commonjs style loader to runtime
func RegisterLoader(c *Core) {
    r := c.GetRts()

    r.Set("require", func(call js.FunctionCall) js.Value {
        p := call.Argument(0).String()
        return loadModule(c, p)
    })
}複製代碼

完整的例子有興趣可看github.com/81120/gode

寫在後面

以前一直分不清Javascript引擎和Javascript執行環境的界限，經過這個例子，有了一個很具體的認識。並且，對Node自己的結構也有了一個更清楚的認知。在一些場景下，須要將一些語言嵌入到另外一個語言中實現一些更靈活的功能和解耦，例如nginx中的lua，遊戲引擎中的lua，mongodb shell中的Javascipt，甚至nginx官方頭提供了一個閹割版本的Javascript實現做爲配置的DSL。那麼在這種須要嵌入DSL的場景下，嵌入一個成熟語言的執行引擎比本身實現一個DSL要簡單方便得多。並且，各類場景下，對語言自己的要求也不盡相同，例如邊緣計算場景，嵌入式下，能夠用Javascript來開發，可是是否是須要一個完整的V8呢？對環境和性能有特殊要求的場景下，限制DSL，提供必要的宿主語言擴展也是個不錯的思路吧。