Go otto 介绍 - basic

Otto是用Go实现的Javascript 解析执行库（https://github.com/robertkrimen/otto），没有使用native代码例如v8.

 

1. Go调用js

直接执行一段js，返回结果：

package main

import (
    "fmt"

    "github.com/robertkrimen/otto"
)

func main() {
    vm := otto.New()
    v, err := vm.Run(`
        var a = 1
        a++
        a
    `)

    if v.IsNumber() {
        i, _ := v.ToInteger()
        fmt.Println("result is", i)  // result is 2
    } else if err != nil {
        fmt.Println("there's error:", err)
    }
}

 

先执行一段js 定义function，然后调用它：

func main() {
    vm := otto.New()
    _, err := vm.Run(`
        function foo() {
            var a = 1
            a++
            return a
        }
    `)
    if err != nil { panic("define js function error: " + err.Error()) }

    vf, _ := vm.Get("foo")
    if !vf.IsFunction() { panic("'foo' is not a function") }

    v, err := vf.Call(otto.Value{})  // 第一个参数是this
    if err != nil {
        fmt.Println("call foo() error:", err)
    } else {
        fmt.Println("foo() returns:", v)  // foo() returns: 2
    }
}

 vm代表一个js runtime，可以直接get/set顶层对象。vm.Run先在runtime设置名为“foo”的函数，然后vm.Get获取该函数对象，最后调用它。

2. js调用Go

用Go定义一个foo函数，然后在js里调用：

func main() {
    vm := otto.New()
    err := vm.Set("foo", func (call otto.FunctionCall) otto.Value {
        a := 1
        a++
        v, _ := otto.ToValue(a)
        return v
    })
    if err != nil { panic("define foo func error: " + err.Error()) }

    _, err = vm.Run(`
        console.log("foo()=" + foo())  // foo()=2
    `)
    if err != nil { panic("injs call foo() error: " + err.Error()) }
}

otto.FunctionCall代表js->go调用（可用来获取传参）。

 

下面是一个比较实际并复杂些的例子：在Go定义一个函数按id查询公司详情，在js里调用：

package main

import (
    "database/sql"

    "github.com/robertkrimen/otto"
    _ "github.com/ziutek/mymysql/godrv"
)

func main() {
    // CREATE TABLE IF NOT EXISTS comp (id BIGINT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(64) NOT NULL UNIQUE, create_time DATETIME NOT NULL);
    // INSERT INTO comp (name, create_time) VALUES ('comp-1', now());
    // INSERT INTO comp (name, create_time) VALUES ('comp-2', now());
    db, err := sql.Open("mymysql", "tcp:127.0.0.1:3306*testdb/root/1")
    if err != nil { panic(err) }
    defer db.Close()

    vm := otto.New()
    // comp(id/number) {id/number, name/string, create_time/number}
    // Panics.
    err = vm.Set("comp", func (call otto.FunctionCall) otto.Value {
        arg0 := call.Argument(0)
        id, _ := arg0.ToInteger()  //(错误处理暂忽略)
        name := ""
        create_time := 0
        err = db.QueryRow(`SELECT name,UNIX_TIMESTAMP(create_time) FROM comp WHERE id=? `, id).Scan(
            &name, &create_time)
        if err == sql.ErrNoRows || err != nil {  // 没查到或出错
            panic("query error: " + err.Error())
        }

        ma := map[string]interface{} {
            "id": id,
            "name": name,
            "create_time": create_time,
        }
        v, err := vm.ToValue(ma)  //(otto.ToValue只用于简单对象，map需使用vm)
        if err != nil { panic("convert result error: " + err.Error()) }
        return v
    })
    if err != nil { panic("define comp func error: " + err.Error()) }

    _, err = vm.Run(`
        var co = comp(1)
        console.log("comp(1)=" + JSON.stringify(co) )  // comp(1)={"create_time":1554882802,"id":1,"name":"comp-1"}
        console.log("result type=" + typeof co)  // result type=object
    `)
    if err != nil { panic("injs call comp() error: " + err.Error()) }
}

 需要理解一点：otto是纯用Go实现的，所以上面js里执行“JSON.stringify”时，最终实际是Go来stringify这个co对象。可以想象成每个js对象都有对应的Go对象，这当然会在数据传入传出runtime、以及每次方法调用时产生cost. 初步测试表明1w条数据内速度还是挺快的。

 

用Go编写系统代码，用js编写业务代码（开发敏捷|不需重启），在中小型项目及测试等领域的前景还是值得期待的。