用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，提供必要的宿主语言扩展也是个不错的思路吧。