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

原文链接：https://studygolang.com/articles/24904

将一段JavaScript代码放在V8引擎当中是怎么执行的呢？

　　将一段JavaScript代码放在V8引擎当中是怎么执行的呢？首先需要明白的是，机器是读不懂 JS 代码，机器只能理解特定的机器码，那如果要让 JS 的逻辑在机器上运行起来，就必须将 JS 的代码翻译成机器码，然后让机器识别。JS属于解释型语言，对于解释型的语言说，解释器会对源代码做如下分析:

　　1.通过词法分析和语法分析生成 AST(抽象语法树)

　　2.生成字节码

　　然后解释器根据字节码来执行程序。但 JS 整个执行的过程其实会比这个更加复杂，接下来就来一一地拆解。

　　1.生成 AST

　　生成 AST 分为两步——词法分析和语法分析。

　　词法分析即分词，它的工作就是将一行行的代码分解成一个个token。 比如下面一行代码:

　　let name = \'sanyuan\'

　　其中会把句子分解成四个部分: