var call = fn => fn(3)
var doSomething = (n) => {
  console.log(n)
}

// 函数可以作为参数传给传给函数
call(doSomething)

// 使用函数很方便，可以直接匿名使用
call(() => {
  console.log(2)
})

var a = 1
// eval 在当前作用域调用一段js代码
eval('a = 2')
console.log(a)

const vm = require('vm');

const x = 1;

const sandbox = { x: 2 };
vm.createContext(sandbox); // Contextify the sandbox.

const code = 'x += 40; var y = 17;';
// `x` and `y` are global variables in the sandboxed environment.
// Initially, x has the value 2 because that is the value of sandbox.x.
vm.runInContext(code, sandbox);

console.log(sandbox.x); // 42
console.log(sandbox.y); // 17

console.log(x); // 1; y is not defined.

console.time('timeout')
// setTimeout第一个参数，是一个函数表达式
// 第二个参数时毫秒数，经过指定的延迟调用表达式
// 计时器是一种典型的宿主提供的能力
setTimeout(() => {
    // 100.671ms    
    // console.time/timeEnd是计时api
    console.timeEnd('timeout')
}, 100)

console.time('timeout')
setTimeout(() => {
    // 由于线程忙，所以即时时间到了，也只能排队
    // 1001.671ms    
    console.timeEnd('timeout')
}, 100)

// 线程阻塞
const block = ms => {
    const start = Date.now()
    while(Date.now() - start < ms) {}
}
block(1000)

// no data-race

const fs = require('fs')
const readable = fs.createReadStream('./text')

// poll
readable.on('data', () => {
    console.log('poll: ', Date.now())
})

// close
readable.on('close', () => {
    console.log('close: ', Date.now())
})

// timer
setTimeout(() => {
    console.log('timers: ', Date.now())
}, 1000)

// 当前线程阻塞
const block = ms => {
    const start = Date.now()
    while(Date.now() - start < ms) {}
}

block(3000)
// 开始处理事件队列的callback
console.log('todo queued jobs: ', Date.now())

// todo queued jobs:  1575476371564
// timers:  1575476371566
// poll:  1575476371570
// close:  1575476371571

-> go version
go version go1.13.5 darwin/amd64
-> go get fknsrs.biz/p/ottoext
-> go get github.com/robertkrimen/otto
-> go get github.com/GeertJohan/go.rice
-> go get gopkg.in/readline.v1
-> cd ~/go/src/fknsrs.biz/p/ottoext/cmd/ottoext
-> go build main.go
-> ./main example.js

const Koa = require('koa');
const app = new Koa();

// logger

app.use(async (ctx, next) => {
  await next();
  const rt = ctx.response.get('X-Response-Time');
  console.log(`${ctx.method} ${ctx.url} - ${rt}`);
});

// x-response-time

app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  ctx.set('X-Response-Time', `${ms}ms`);
});

// response

app.use(async ctx => {
  ctx.body = 'Hello World';
});

app.listen(3000);

asyncCall1(res1 => {
  asyncCall2(res2 => {
    asyncCall3(res3 => {
      /// ...
    })
  })
})

asyncCall1().then(res1 => {
  return asyncCall2()
}).then(res2 => {
  return asyncCall3()
}).then(res3 => {
  /// ...
})

async function asyncCalls() {
  const res1 = await asyncCall1()
  const res2 = await asyncCall2()
  const res3 = await asyncCall3()
  // ...
}

const browser = await puppeteer.launch();

const page = await browser.newPage();
await page.goto('https://example.com');

console.log(await page.content());
await page.screenshot({path: 'screenshot.png'});

await browser.close();