deno学习（2）---从Hello World开始

deno的执行非常简单，使用deno xx.ts即可。 从deno hello.ts出发，探究一下deno的运行机制。

• 学习目标
  1. deno代码的模块
  2. 各模块之间的交互模式

回顾

• 在上一节学习过程中，已经知道了执行make指令之后，会将go代码、ts代码、js代码已经node_module代码打包。可以大致猜测一下，在整个deno项目里面，go会占一部分，js也会占一部分。作为js和go的交互模块，v8worker也是很重要的一部分。

v8worker

• v8worker本身是ry大神基于V8做的一个go和js调用的中间层。主体只有两个功能：
  1. 接收消息
  • golang接收来自js的消息

//worker.go
func New(cb ReceiveMessageCallback) *Worker {
    //...
}

• js接收来自golang的消息

V8Worker2.recv((ab: ArrayBuffer) => {
//...
}

2. 发送消息给js

• golang分送消息到js

//worker.go
func (w *Worker) SendBytes(msg []byte) error {

• js分送消息到golang

V8Worker2.send(msg)

在deno里面，作者对v8worker做了简单的封装，在go和js层面分别做了一个 分发器。dispatch.go 和 dispatch.ts，分别提供了订阅、发布功能。

dispatch.go

func Sub(channel string, cb Subscriber) {
    subscribers, ok := channels[channel]
    subscribers = append(subscribers, cb)
    channels[channel] = subscribers
}

func Pub(channel string, payload []byte) {
    wg.Add(1)
    resChan <- &BaseMsg{
        Channel: channel,
        Payload: payload,
    }
}

dispatch.js

export function sub(channel: string, cb: MessageCallback): void {
  let subscribers = channels.get(channel);
  subscribers.push(cb);
}

export function pub(channel: string, payload: Uint8Array): null | ArrayBuffer {
  const msg = pb.BaseMsg.fromObject({ channel, payload });
// ...
  return send(ab);
}

通过以上代码，就可以实现一个订阅者模式，从而实现数据交互。值得一提的是，数据交互格式为protobuf。这种方式相当安全、高效。

main.go

• 通过下面代码可以知道，deno的主入口就是 ./cmd/main.go文件

deno: msg.pb.go $(GO_FILES)
   go build -o deno ./cmd

• ./cmd/main.go

package main

import (
    "github.com/ry/deno"
)
func main() {
    //初始化deno配置，预加载js代码。形成bridger
    deno.Init()

    //执行denoMain()方法
    deno.Eval("deno_main.js", "denoMain()")
    deno.Loop()
}

1. 初始化 2. 执行js 里面的 denoMain方法 3.执行一个轮询

• main.go 。 ./cmd/main.go引用了 deno包。Init、Eval、Loop都位于main.go下

• Init

    //创建所需文件夹 在 ${home}/.deno   创建 src cache 两个文件夹
    createDirs()
    //订阅 os
    InitOS()
    //订阅echox
    InitEcho()
    //订阅timers
    InitTimers()
    //订阅fetch
    InitFetch()


    //一个v8工作线程
    worker = v8worker2.New(recv)

    //加载main.js代码.
    //main.js就是Makefile里面通过
    /**
    #生成 dist/main.js 通过 ts文件 和 node_moduels
dist/main.js: $(TS_FILES) node_modules
    ./node_modules/.bin/tsc --noEmit # Only for type checking.
    ./node_modules/.bin/parcel build --out-dir=dist/ --log-level=1 --no-minify main.ts
        打包生成的代码。
    */
    main_js = stringAsset("main.js")
    //加载main.js
    err := worker.Load("/main.js", main_js)
    exitOnError(err)
    //代码的map，用于定位代码.
    main_map = stringAsset("main.map")

• Eval

    // It's up to library users to call
// deno.Eval("deno_main.js", "denoMain()")
func Eval(filename string, code string) {
    //执行代码
    err := worker.Load(filename, code)
    exitOnError(err)
}

• Loop

func Loop() {
    cwd, err := os.Getwd()
    check(err)
    /**
        可以将v8worker2 理解为一个C/S的架构。
        Client发送消息，Server端回复消息。
    */
    PubMsg("start", &Msg{
        Command:        Msg_START,
        StartCwd:       cwd,
        StartArgv:      workerArgs,
        StartDebugFlag: *flagDebug,
        StartMainJs:    main_js,
        StartMainMap:   main_map,
    })
    DispatchLoop()
}

执行流程

1. 初始化。
   • 下面四个方法，通过V8注册方法，实现对js调用的订阅。

    InitOS()
    //订阅echox
    InitEcho()
    //订阅timers
    InitTimers()
    //订阅fetch
    InitFetch()

os.go

//订阅了os。提供了5种模式。
Sub("os", func(buf []byte) []byte {
        switch msg.Command {
        case Msg_CODE_FETCH:
        case Msg_CODE_CACHE:
        case Msg_EXIT:  
        case Msg_READ_FILE_SYNC:
                //读取文件      
        case Msg_WRITE_FILE_SYNC:   
        }
    })

剩下三个大同小异，不做具体说明。

  - 加载 js文件

//会加载 /dist/main.js 文件
main_js = stringAsset("main.js")
//加载main.js，编译并执行。
err := worker.Load("/main.js", main_js)

2. 执行denoMain方法。

• denoMain方法是 位于main.js 里面。实际上在打包之前，是位于main.ts下。

(window as any)["denoMain"] = () => {
  initTimers(); //初始化timer
  initFetch(); //初始化fetch 

//订阅start事件。
  dispatch.sub("start", (payload: Uint8Array) => {
    runtime.setup(mainJs, mainMap);
//就是文件路径
    const inputFn = argv[0];
//模块加载
    const mod = runtime.resolveModule(inputFn, `${cwd}/`);
//执行编译和运行ts代码
    mod.compileAndRun();
  });

这里订阅了start事件，等待触发。触发的时候，就是对ts文件做编译、执行的时候。

3. 开始Loop
   main.go

func Loop() {
    cwd, err := os.Getwd()
    /**
      触发start事件。
    */
    PubMsg("start", &Msg{
        Command:        Msg_START,
        StartCwd:       cwd,
        StartArgv:      workerArgs,
        StartDebugFlag: *flagDebug,
        StartMainJs:    main_js,
        StartMainMap:   main_map,
    })
        //对消息轮询，实现数据交换。
    DispatchLoop()
}

dispatch.go

func DispatchLoop() {
      // 对协程做监控。
    //实际上，Pub会新建一个协程消息，这里做监听。有新信息就通过worker发送给js层。
    for {
        select {
        case msg := <-resChan:
            out, err := proto.Marshal(msg)
            err = worker.SendBytes(out)
        case <-doneChan:
            return
        }
}

image.png

总结

• 目前来看deno是一个很简单的执行ts的程序。效率也不是很高。实际上对ts的解析和执行都是在runtime时期运行的，相对于以前对typescript先编译成js再使用的方式，是一种全新的尝试。