// .babelrc
{
  "presets": [
    "power-assert"
  ]
}

// package.json
{
    "test": "jest"
}

// demo1.js 

'use strict'
const http = require('http')
const fs = require('fs')

const onRequest = (req, res) => {
  const filepath = './test.html'
  , file = fs.readFileSync(filepath)
  , stats = fs.statSync(filepath)
  , mtime = stats.mtime
  , reqMtimeString = req.headers["if-modified-since"]

  let status = 200

  if(reqMtimeString) {
    const reqMtime = new Date(reqMtimeString)
    if(reqMtime.getTime() === mtime.getTime()) status  = 304
  }

  res.writeHead(status, {'Content-Type': 'text/html', 'Last-Modified': mtime})
  if(200 === status) res.write(file)
  res.end()
}

http.createServer(onRequest).listen('8000', () => console.log('server start:8000'))

// demo2.js
'use strict'
const http = require('http')
const fs = require('fs')

const onRequest = (req, res) => {
  if('/req.js' === req.url) {
    let filepath = './req.js'
    , file = fs.readFileSync(filepath)

    res.writeHead(200, {'Content-Type': 'text/javascript', 'Cache-Control': 'max-age=60'})
    res.write(file)
    res.end()
  } else {
    let filepath = './test2.html'
    , file = fs.readFileSync(filepath)

    res.writeHead(200, {'Content-Type': 'text/html'})
    res.write(file)
    res.end()
  }
}

http.createServer(onRequest).listen('8000', () => console.log('server start:8000'))

// req.js
'use strict'
console.log(123)

var $nav = $('#nav')

var sLi = ['home','about','article','history'].reduce(function(pre, n) {
    return pre + '<li><a href="/' + n + '">' + n + '</a></li>';
}, '');

var sUl = '<ul>' + sLi + '</ul>';

$nav.html(sUl);

$('#nav ul li').on('click', function() {
  var route = $(this).find('a').text()
  history.pushState({ title: route }, route, route)
  show()
  return false;
})

function show() {
  var route = window.location.pathname
  if('/home' === route) {
    $.get('/api/home', function(data) {
      $container.html(data.join('') + '!')
    })
  } else {
    $container.html('这是' + route + '区域哦')
  }
}

    window.addEventListener("popstate", show);

fn = function(a, b) {
    return a + b
}

    fn = new Function('window', functionBody + ';return window.token')
    var token = fn({})
    console.log(token)

{
  "name": "walk-dir-tree",  // 包名称
  "version": "0.0.4", // 包版本号
  "description": "walk-dir-tree is a recursive directory listing command that produces a depth indented listing of files like tree", // 包描述
  "keywords": ["tree", "directory", "walk-dir-tree", "co"],  // 关键字
  "repository": "https://github.com/zwhu/walk-dir-tree", // 包的repo链接
  "bin": "./bin/index", // 命令行工具所要引入的包得位置
  "main": "index.js", // 入口文件
  "author": "zwhu <[email protected]>", // 作者
  "license": "ISC", // 包的开源许可证
  "dependencies": {  // 包依赖
    "co": "^4.6.0",
    "colors": "^1.1.2",
    "mz": "^2.1.0"
  }
}

function tounicode(s) {
  return s.charCodeAt().toString(16)
}

import Canvas  from 'canvas'
import fs from 'fs'

const Image = Canvas.Image

// 初始化 img 和 start time
// 获取命令行输入的源图片和保存的图片地址
let img = new Image
  , start = new Date()
  , rawPath =  process.argv[2]
  , savePath = process.argv[3]

// 在命令行中没有输入图片地址，抛错
if(!rawPath)
  throw new Error('input raw image path')

if(!savePath)
  throw new Error('input save image path')

img.onerror = function(err){
  throw err
}

// 图片加载完成
img.onload = function(){
    //  获取图片的width和height
  let width = img.width
    , height = img.height
    , canvas = new Canvas(width, height)
    , ctx = canvas.getContext('2d')

  // 将源图片复制到画布上
  // canvas 所有的操作都是在 context 上，所以要先将图片放到画布上才能操作
  ctx.drawImage(img, 0, 0, width, height)

  let imageData = ctx.getImageData(0, 0, width, height)

  // 获取画布的像素信息
  // 是一个一维数组，包含以 RGBA 顺序的数据，数据使用  0 至 255（包含）的整数表示
  // 如：图片由两个像素构成，一个像素是白色，一个像素是黑色，那么 data 为
  // [255,255,255,255,0,0,0,255] 
  // 这个一维数组可以看成是两个像素中RBGA通道的数组的集合即:
  // [R,G,B,A].concat([R,G,B,A])
    , data = imageData.data

 // 对像素集合中的单个像素进行循环，每个像素是由4个通道组成，所以 i=i+4
  for(let i = 0; i < data.length; i+=4) {
    // 得到 RGBA 通道的值
    let r = data[i]
      , g = data[i+1]
      , b = data[i+2]

    // 我们从最下面那张颜色生成器中可以看到在图片的右上角区域，有一小块在
    // 肉眼的观察下基本都是白色的，所以我在这里把 RGB 值都在 245 以上的
    // 的定义为白色
    // 大家也可以自己定义的更精确，或者更宽泛一些
    if([r,g,b].every(v => v < 256 && v > 245)) data[i+3] = 0
  }

  // 将修改后的代码复制回画布中
  ctx.putImageData(imageData, 0, 0)

  // 将修改后的图片保存
  let out = fs.createWriteStream(`${__dirname}/${savePath}`)
    , stream = canvas.pngStream()

  stream.on('data', function (chunk) {
    out.write(chunk)
  })

  stream.on('end', function () {
    console.log(`保存到 ${__dirname}/${savePath}`)
    console.log(`耗时: ${new Date()-start}ms`)
  })
}

img.src = `${__dirname}/${rawpath}`

let tree = {
    'id1': {
		message: 'hello'
	},
	'id2': {
		message: 'world',
		children: {
		  'id2-1': {
			  message: 'haha',
			  children: {
			  }
		  },
		  'id2-2': {
			  message: 'heihei'
		  }
		}
	}
}

function dfs(tree = {}, messages = []) {
	let i = 0;
	if(!messages) messages = [];
	if(tree.message) messages.push(tree.message);
	
	const keys = Object.keys(tree.children || {});
	while (i < keys.length) {
		dfs(tree.children[keys[i]], messages);
		i += 1;
	}
	return messages;
}

 tree = {
	message: null,
	children: tree
 };  
 
 dfs(tree);

  function dfs(tree = {}) {
	const array = [tree];
	let messages = [];
	while (array.length) {
	  const top = array.pop();
	  if (top.message) {
		messages.push(top.message);
	  }
	  const keys = Object.keys(top.children || {});
	  let i = keys.length;
	  while (i > 0) {
		i -= 1;
		array.push(top.children[keys[i]]);
	  }
	}
	return messages
  }
  
 tree = {
	message: null,
	children: tree
 };  
 
 dfs(tree);

if(!String.prototype.padStart)
    String.prototype.padStart = 
       // 为了方便表示这里 fillString 用了ES6 的默认参数，不影响理解
        function (maxLength, fillString=' ') {
            if(Object.prototype.toString.call(fillString) !== "[object String]") throw new TypeError('fillString must be String')
            let str = this
            // 返回 String(str) 这里是为了使返回的值是字符串字面量，在控制台中更符合直觉
            if(str.length >= maxLength) return String(str)

            let fillLength = maxLength - str.length, 
 				times = Math.ceil(fillLength / fillString.length)
           
           // 这个算法叫啥？
           // SICP 的中文版第 30页 有用到同种算法计算乘幂计算
            while(times >>= 1) { 
                fillString += fillString
                    if(times === 1){
                       fillString += fillString
                    }     
            }
            return fillString.slice(0, fillLength) + str  
        }

// padStart  对于我来说最常用的地方就在于时间或者数字格式补全了

'5'.padStart(2, '0') // '05'
'15'.padStart(2, '0') // '15'

console.log('a starting'); 
exports.done = false;
var b = require('./b.js'); // ---> 1
console.log('in a, b.done = %j', b.done);
exports.done = true;
console.log('a done') // ---> 4

console.log('b starting'); 
exports.done = false;
var a = require('./a.js');  // ---> 2
// console.log(a);  ---> {done:false}
console.log('in b, a.done = %j', a.done); // ---> 3
exports.done = true;
console.log('b done');

console.log('main starting'); 
var a = require('./a.js'); // --> 0
var b = require('./b.js');
console.log('in main, a.done=%j, b.done=%j', a.done, b.done);

(function(process) {

    this.global = this

    function startup() {
      ...
    }

    startup()

})

if (process.argv[1]) {
     // ...

    var Module = NativeModule.require('module');
    Module.runMain();
}

  function NativeModule(id) {
    this.filename = id + '.js';
    this.id = id;
    this.exports = {};
    this.loaded = false;
  }

  NativeModule._source = process.binding('natives');
  NativeModule._cache = {};

  NativeModule.require = function(id) {
    if (id == 'native_module') {
      return NativeModule;
    }

    var cached = NativeModule.getCached(id);
    if (cached) {
      return cached.exports;
    }

    var nativeModule = new NativeModule(id);

    nativeModule.cache();
    nativeModule.compile();

    return nativeModule.exports;
  };

  NativeModule.getSource = function(id) {
    return NativeModule._source[id];
  };

  NativeModule.wrap = function(script) {
    return NativeModule.wrapper[0] + script + NativeModule.wrapper[1];
  };

  NativeModule.wrapper = [
    '(function (exports, require, module, __filename, __dirname) {\n',
    '\n});'
  ];

  NativeModule.prototype.compile = function() {
    var source = NativeModule.getSource(this.id);
    source = NativeModule.wrap(source);

    var fn = runInThisContext(source, {
      filename: this.filename,
      lineOffset: -1
    });
    fn(this.exports, NativeModule.require, this, this.filename);

    this.loaded = true;
  };

  NativeModule.prototype.cache = function() {
    NativeModule._cache[this.id] = this;
  };

(function (exports, require, module, __filename, __dirname) {
 // 如果是main.js
    console.log('main starting'); 
    var a = require('./a.js'); // --> 0
    var b = require('./b.js');
    console.log('in main, a.done=%j, b.done=%j', a.done, b.done);
})

if (process.argv[1]) {
     // ...

    var Module = NativeModule.require('module');
    Module.runMain();
}

function Module(id, parent) {
  this.id = id;
  this.exports = {};
  this.parent = parent;
  if (parent && parent.children) {
    parent.children.push(this);
  }

  this.filename = null;
  this.loaded = false;
  this.children = [];
}
module.exports = Module;

Module._cache = {};
Module._pathCache = {};
Module._extensions = {};
var modulePaths = [];
Module.globalPaths = [];

Module.wrapper = NativeModule.wrapper;
Module.wrap = NativeModule.wrap;

Module.runMain = function() {
  // Load the main module--the command line argument.
  Module._load(process.argv[1], null, true);
  // Handle any nextTicks added in the first tick of the program
  process._tickCallback();
};

Module._load = function(request, parent, isMain) {
  var filename = Module._resolveFilename(request, parent);
  var cachedModule = Module._cache[filename];

  if (cachedModule) {
    return cachedModule.exports;
  }

  var module = new Module(filename, parent);
  Module._cache[filename] = module;

  module.load(filename);

  return module.exports;
};

Module.prototype.load = function(filename) {
  this.filename = filename;
  this.paths = Module._nodeModulePaths(path.dirname(filename));

  var extension = path.extname(filename) || '.js';
  if (!Module._extensions[extension]) extension = '.js';
  Module._extensions[extension](this, filename);
  this.loaded = true;
};

// Native extension for .js
Module._extensions['.js'] = function(module, filename) {
  var content = fs.readFileSync(filename, 'utf8');
  module._compile(internalModule.stripBOM(content), filename);
};

Module.prototype._compile = function(content, filename) {

  var self = this;

  function require(path) {
    return self.require(path);
  }

  var dirname = path.dirname(filename);
  // create wrapper function
  var wrapper = Module.wrap(content);

  var compiledWrapper = runInThisContext(wrapper,
                                      { filename: filename, lineOffset: -1 });

  var args = [self.exports, require, self, filename, dirname];
  return compiledWrapper.apply(self.exports, args);
};

Module.prototype.require = function(path) {
  return Module._load(path, this);
};

let vdom = {
    tag: 'div',
    props: {
        style: 'display:none'
    },
    children: [{
        tag: 'a',
        props: {
            id: '1',
            href: 'http://test.com',
            target: '_blank'
        },
        children: ["click!"]
    }, 'this is text!!!', {
        tag: 'div',
        props: {
            class: 'class1 class2',
            'data-attr': 'hello'
        },
        children: ['haha', {
            tag: 'br'
        }]
    }, {
        tag: 'br'
    }]
}

function render(root) {

    function dfs(node) {
        let element
        if (node.tag) {
            element = createElement(node.tag, node.props)
            node.children && node.children.map(dfs).forEach(element.appendChild)
        } else if (typeof node === 'string')
            element = createTextNode(node)

        return element
    }
    return dfs(root)
}

function createElement(tag, props = {}) {
    const element = document.createElement(tag)
    Object.keys(props).forEach((key) => { element.setAttribute(key, props[key]) })
    return element
}

function createTextNode(text) {
    return document.createTextNode(text)
}

console.log(render(vdom))

// circle.js
var PI = Math.PI;

exports.area = function (r) {
  return PI * r * r;
};

exports.circumference = function (r) {
  return 2 * PI * r;
};

(function(exports, require, module, __dirname, __filename) {
    // circle.js
    var PI = Math.PI;

    exports.area = function (r) {
      return PI * r * r;
    };

    exports.circumference = function (r) {
      return 2 * PI * r;
    };
})

function Module(id, parent) {
  this.id = id;
  this.exports = {};
  this.parent = parent;
  if (parent && parent.children) {
    parent.children.push(this);
  }

  this.filename = null;
  this.loaded = false;
  this.children = [];
}


Module.prototype._compile = function(content, filename) {
  var self = this;

  function require(path) {
    return self.require(path);
  }

  var dirname = path.dirname(filename);

  var args = [self.exports, require, self, filename, dirname];
  return compiledWrapper.apply(self.exports, args);
};

var module = { exports: {}};
var exports = module.exports;
exports.a = 1;
console.log(module.exports); // {a: 1}

exports = {b:2};
console.log(module.exports); // {a: 1}

        let vdom1 = {
            tag: 'div',
            props: {
                style: 'border: solid 2px red;'
            },
            children: [{
                tag: 'a',
                props: {
                    id: '1',
                    href: 'http://test.com',
                    target: '_blank'
                },
                children: [{ text: 'click!' }]
            }, {
                text: 'text!!'
            }, {
                tag: 'div',
                props: {
                    class: 'class1 class2',
                    'data-attr': 'hello'
                },
                children: [{ text: 'hahaha!' }, {
                    tag: 'br'
                }]
            }, {
                tag: 'br'
            }]
        }

        let vdom2 = {
            tag: 'div',
            props: {
                class: 'vdom2'
            },
            children: [{
                tag: 'a',
                props: {
                    id: '1',
                    href: 'http://test.com',
                    target: '_blank'
                },
                children: [{ text: 'click!!!' }]
            }, {
                tag: 'h2',
                children: [{ text: 'hahahah!' }]
            }, {
                tag: 'div',
                props: {
                    class: 'class1 class2',
                    'data-attr': 'hello'
                },
                children: [{ text: 'xxixii!' }, {
                    tag: 'br'
                }]
            }, {
                tag: 'br'
            }]
        }

        let prev
        function render(container, root) {

            function dfs(node, prev = {}) {
                let element
                if (node.tag) {
                    if (prev && prev.tag === node.tag) {
                        element = prev.raw
                        updateProps(element, node.props, prev.props)
                    } else {
                        element = createElement(node.tag, node.props)
                    }

                    node.children && renderChildren(node.children, prev.children, element)

                } else if (typeof node.text === 'string') {
                    element = createTextNode(node.text)
                }

                node.raw = element
                return node
            }

            function renderChildren(children = [], prevChildren = [], parentElement) {
                children.forEach((child, index) => {
                    let prevChild = null
                    if (prevChildren) prevChild = prevChildren[index]
                    if (prevChild) {
                        let newNode = dfs(child, prevChild)
                        if (prevChild.tag !== child.tag) {
                            parentElement.replaceChild(newNode.raw, prevChild.raw)
                        }
                    } else {
                        let newNode = dfs(child)
                        parentElement.appendChild(newNode.raw)
                    }
                })

                prevChildren.slice(children.length).forEach((child) => {
                    parentElement.removeChild(child.raw)
                })

            }


            dfs(root, prev)
            if (!prev) {
                prev = root
                container.appendChild(prev.raw)
            }
        }

        function createElement(tag, props = {}) {
            const element = document.createElement(tag)
            updateProps(element, props)
            return element
        }

        function updateProps(element, props = {}, oldProps = {}) {
            Object.keys(oldProps).forEach((key) => { element.removeAttribute(key) })
            Object.keys(props).forEach((key) => { element.setAttribute(key, props[key]) })
        }

        function createTextNode(text) {
            return document.createTextNode(text)
        }

        let fake1 = render(root, vdom1)

        update.addEventListener('click', () => {
            fake2 = render(root, vdom2)
        })

import {createReadStream} from 'fs'
import {createInterface} from 'readline'

let readFile = (inputFile, cb) => {
  let inStream = createReadStream(inputFile, 'utf8')
    , rl       = createInterface({input: inStream})

  rl.on('line', function (line) {
    rl.pause()
    //sync
    cb(line)
    rl.resume()
  })
}
export default readFile

import {join} from 'path'
import readFile from './readFile'

readFile(join(__dirname, './path.txt'), (line)=> {
  console.log(line)
})

var exch = (a, k) => {
  return [a[k], ...a.slice(0,k),...a.slice(k+1)]
}

var nextBigger = (n) => {
 if(n < 11) return -1
 var a = Array.from(`${n}`).map(v=>v|0)
   , i = a.length

 while(--i) {
   if(a[i] > a[i-1]) {
    var c = a.slice(i-1).sort((a,b) => (a|0) > (b|0))
      , k = c.indexOf(a[i])
    for(var j = 1; j < c.length; j++) {
      if(c[j] > a[i-1] && c[j] < c[k])
        k = j
    }

     return Number([...a.slice(0, i-1), ...exch(c, k)].join(''))
   }
 }
  return -1
}

import koa from 'koa'
import fs from 'mz/fs'


const app = koa()

app.use(function* (next) {
  if(this.path == '/test')
    return this.status = 200

  yield next
})

app.use(function* (next) {
  this.type = 'html'
  this.body = yield fs.readFile('./index.html')
  yield next
})

app.listen(8080)
console.log('koa server port: 8080')

let vdom = {
    tag: 'div',
    props: {
        style: 'display:none'
    },
    children: [{
        tag: 'a',
        props: {
            id: '1',
            href: 'http://test.com',
            target: '_blank'
        },
        children: ["click!"]
    }, 'this is text!!!', {
        tag: 'div',
        props: {
            class: 'class1 class2',
            'data-attr': 'hello'
        },
        children: ['haha', {
            tag: 'br'
        }]
    }, {
        tag: 'br'
    }]
}

function render(root) {

    function dfs(node, space = '') {
        let str = ''
        if (node.children)
            str = (`<${node.tag}${renderProps(node.props)}>\n${node.children.map(_ => dfs(_, '  ') + '\n').join('')}</${node.tag}>`)
        else if (typeof node === 'string')
            str = node
        else
            str = `<${node.tag}${renderProps(node.props)}/>`

        return str.split('\n').map(_ => space + _).join('\n')
    }
    return dfs(root)
}

function renderProps(props) {
    if (!props) return ''
    return Object.keys(props).reduce((str, key) => `${str} ${key}="${props[key]}"`, '')
}

console.log(render(vdom))

var addEvent = function(el, type, handler) {
  if(window.addEventListener) {
    return el.addEventListener( type, handler, false)
  } else if(window.attachEvent) {
    return el.attachEvent('on' + type, handler)
  }
}

var addEvent = function(el, type, handler) {
  if(window.addEventListener) {
    addEvent = function(el, type, handler) {
      el.addEventListener( type, handler, false)
    }
  } else if(window.attachEvent) {
    addEvent = function(el, type, handler) {
      el.attachEvent('on' + type, handler)
   }
  }
  addEvent.apply(null, arguments)
}

const fsm = {
    currentState: 0,
    create(state) { this.currentState = state },
    getState() {
        return this. currentState
    },
    transition(action) {
        switch(action.type) {
            case 'add': 
                this.currentState =  this.currentState + action.num
                break
            case 'sub': 
                this.currentState =  this.currentState - action.num
                break   
            default:
                break
        } 
    }
}

fsm.create(5)
fsm.transition({'type':'add', 'num':-1})
console.log(fsm.getState())   // ==>  4
fsm.transition({'type':'sub', 'num':1})
console.log(fsm.getState())   // ==>  3

export default function createStore(reducer, initialState) {
  // 在调用 createStore 的时候，必须传入 reducer， 且 reducer 必须为函数
  if (typeof reducer !== 'function') {
    throw new Error('Expected the reducer to be a function.')
  }

  var currentReducer = reducer
  var currentState = initialState
  var listeners = []
  var isDispatching = false

  // 返回此时的状态
  function getState() {
    return currentState
  }

  // 订阅函数，调用 dispatch 的时候会调用 listener
  function subscribe(listener) {
        // ...
  }

  // 发布函数， 在 action 触发状态的改变后，通知所有订阅的 listener
  function dispatch(action) {
    // 传入的 action 必须为 plain object，也就是 action creator 返回的对象
    // 自己传入 action 对象也是可以的
    // 但是 Redux 推荐的写法是 action creator 的写法
    // 至于写成函数的好处不在这里讨论
    if (!isPlainObject(action)) {
      throw new Error(
        'Actions must be plain objects. ' +
        'Use custom middleware for async actions.'
      )
    }

    // 强制要求 action 必须带入 type 属性，比 Flux 有更强的约束
    if (typeof action.type === 'undefined') {
      throw new Error(
        'Actions may not have an undefined "type" property. ' +
        'Have you misspelled a constant?'
      )
    }

    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.')
    }

    try {
      isDispatching = true
      // 这里就是把 action 和当前状态经过 reducer 处理之后返回一个新的状态
      // currentReducer 就是 createStore 传进来的 reducer
      // 可以切回去看看上面我总结的图
      currentState = currentReducer(currentState, action)
    } finally {
      isDispatching = false
    }
    // 通知订阅的事件
    listeners.slice().forEach(listener => listener())
    return action
  }

  // 状态初始话，此时的 Action 为 { type: ActionTypes.INIT }
  dispatch({ type: ActionTypes.INIT })

  // createStore 最后返回一个含有 dispatch 和 getState 的对象
  return {
    dispatch,
    subscribe,
    getState,
    replaceReducer
  }
}

const stream = require('stream')

const last = Symbol()

// 在 selfArray 中接收一个真正的数组
// 返回一个可读流
// 如果再做的精细点，可以做成可读可写流，这样就能通过控制流的大小，来控制内存的大小，别几亿条数据直接撑爆内存了
// 不过对后面 reduce 的处理就比较麻烦
function selfArray(a) {
  const rs = new stream.Readable({
    objectMode: true
  })

  a.forEach((v, index) => {
    rs.push(v)
  })
  rs.push(last)
  rs.push(null)
  return rs
}

function forEach(callback) {
  const ws = new stream.Writable({
    objectMode: true
  })
  let index = 0

  ws._write = function (chunk, enc, next) {
    if (chunk !== last) {
      callback(chunk, index++)
      next()
    }
  }

  return ws
}

function filter(callback) {
  const trans = new stream.Transform({
    readableObjectMode: true,
    writableObjectMode: true
  })

  let index = 0

  trans._transform = function (chunk, enc, next) {
    if (chunk === last) {
      next(null, last)
    } else {
      let condition = callback(chunk, index++)
      if (condition) {
        this.push(chunk)
      }
      next()
    }
  }
  return trans
}

function map(callback) {
  const trans = new stream.Transform({
    readableObjectMode: true,
    writableObjectMode: true
  })
  let index = 0
  trans._transform = function (chunk, enc, next) {
    if (chunk === last) {
      next(null, last)
    } else {
      next(null, callback(chunk, index++))
    }
  }
  return trans
}

function reduce(callback, initial) {
  const trans = new stream.Transform({
    readableObjectMode: true,
    writableObjectMode: true
  })

  let index = 0,
    current = initial,
    prev = initial


  trans._transform = function (chunk, enc, next) {

    if (chunk === last) {
      if (index > 1) {
        prev = callback(prev, current, index - 1)
      }
      this.push(prev)
      this.push(last)
      return next(null, last)
    }

    if (initial === void 0 && index === 0) {
      prev = chunk
    }

    if (index > 0) {
      prev = callback(prev, current, index - 1)
    }

    current = chunk
    index++
    next()
  }

  return trans
}

selfArray([9, 2, 6, 3, 5, 6, 7, 1, 4, 4])
  .pipe(map(v => v * 3))
  .pipe(filter(v => v % 2))
  .pipe(reduce((p, c) => p + c, 0))
  .pipe(forEach(v => {
    console.log('pipe 计算最后的结果是:', v)
  }))

#!/usr/bin/env node
// 在 commit 之前检查是否有冲突，如果有冲突就 process.exit(1)

const execSync = require('child_process').execSync

// git 对所有冲突的地方都会生成下面这种格式的信息，所以写个检测冲突文件的正则
const isConflictRegular = "^<<<<<<<\\s|^=======$|^>>>>>>>\\s"

let results

try {
 // git grep 命令会执行 perl 的正则匹配所有满足冲突条件的文件
    results = execSync(`git grep -n -P "${isConflictRegular}"`, {encoding: 'utf-8'})
} catch (e) {
    console.log('没有发现冲突，等待 commit')
    process.exit(0)
}

if(results) {
    console.error('发现冲突，请解决后再提交，冲突文件：')
    console.error(results.trim())
    process.exit(1)
}

process.exit(0)

#!/usr/bin/env node
const execSync = require('child_process').execSync
execSync("./pre-commit.js" )

const fs = require('fs');

// 判断是否已经存在 pre-commit，不存在就读取 pre-commit.sh 并写入
if (!fs.existsSync('.git/hooks/pre-commit')) {
    if(!fs.existsSync('.git/hooks/')) {
        fs.mkdirSync('.git/hooks/');
    }

    let preCommitFile = fs.readFileSync('./pre-commit.sh');

    fs.writeFileSync('.git/hooks/pre-commit', preCommitFile, {
        encoding: 'utf8',
        mode: 0o777
    });
}

function reg(input) {
    return new RegExp(`\\${input}`)
}

function toUnicode(s) {
    return `\\u{${s.codePointAt().toString(16)}}`
}

toUnicode('$') -> '\u{24}'

function reg(input) {
    return new RegExp(`${toUnicode(input)}`, 'u')
}

function toUnicode(s) {
  var a = `\\u${utf(s.charCodeAt(0).toString(16))}`
  if(s.charCodeAt(1))
    a = `${a}\\u${utf(s.charCodeAt(1).toString(16))}` 
  return a      
}

function utf(s) {
    return Array.from('00').concat(Array.from(s)).slice(-4).join('')
}

// 这里用var而没有用let声明，是因为这些代码直接复制到 chrome 的控制台下就可以看到执行结果
// 测试一下
// toUnicode('a')   --> "\u0061"
// toUnitcode('𠮷')  --> "\ud842\udfb7"

function reg(input) {
    return new RegExp(`${toUnicode(input)}`)
}
// 再测试一下
reg('$').test('$') --> true

let message = 'hello,world!!'
let demo = `
<div id="demo">
    <p>${message}</p>
</div>
`

  $('body').html(demo)

//------ Model
let model = {
  value: 1,
  fns: [],
  set: function(v) {
    this.value = v
    this.fns.forEach(fn => fn.call(this, this.value))
  },
  on: function(fn) {
    this.fns.push(fn)
  }
};


//------ View
let demo = `
<div>
<p>${model.value}</p>
<input value='${model.value}' />
<button id="button1">+1</button>
</div>
`

$('body').html(demo)

//------ ViewModel

$('input').on('keyup', function() {
    model.set($(this).val()|0)
})


$('button#button1').on('click', function() {
    model.set(model.value + 1)
})


model.on(function(value) {
  $('p').html(value)
  $('input').val(value)
})

$('input').on('keyup', function() {
  let value = $(this).val()|0;
  $('p').html(value)
  $('input').val(value)
})

$('button').on('click', function() {
    let value = $('input').val()|0 + 1;
    $('p').html(value)
    $('input').val(value)
})

<button id='button2'>-1</button>
$('button#button2').on('click', function() {
    model.set(model.value - 1)
})

'use strict'

const min = Math.min

// 构造二维数组
const initialArray = (lgt1, lgt2) => {
  let array = []
  for (let i = 0; i < lgt1; i++) {
    array[i] = Array(lgt2)
  }
  return array
}

/**
 * Levenshtein Distance
 * 从一个字符串转成另一个字符串所需要的最小操作步数
 */
const levenshtein = (sa, sb) => {
  let d = []
  , algt = sa.length
  , blgt = sb.length
  , i = 0
  , j = 0

  if(algt === 0) return blgt 

  if(blgt === 0) return algt
  
  // 初始化二维数组
  d = initialArray(algt + 1, blgt + 1)

  for (i = 0; i < algt + 1; i++) {
    d[i][0]  = i
  }

  for (j = 0; j < blgt + 1; j++) {
    d[0][j] = j
  }

  for(i = 1; i < algt + 1; i++) {
    for(j = 1; j < blgt + 1; j++) {
      if(sa[i - 1] === sb[j - 1]) {
        d[i][j] = d[i - 1][j - 1]
      } else {
        d[i][j] = min(
          d[i - 1][j] + 1,
          d[i][j - 1] + 1,
          d[i - 1][j - 1] + 1
        )  
      }
    }
  }

  return d[i - 1][j - 1]
}


// test case
// copy from https://rosettacode.org/wiki/Levenshtein_distance#JavaScript
;[ 
  ['', '', 0],
  ['yo', '', 2],
  ['', 'yo', 2],
  ['yo', 'yo', 0],
  ['tier', 'tor', 2],
  ['saturday', 'sunday', 3],
  ['mist', 'dist', 1],
  ['tier', 'tor', 2],
  ['kitten', 'sitting', 3],
  ['stop', 'tops', 2],
  ['rosettacode', 'raisethysword', 8],
  ['mississippi', 'swiss miss', 8]
].forEach(function(v) {
  var a = v[0], b = v[1], t = v[2], d = levenshtein(a, b);
  if (d !== t) {
    console.log('levenstein("' + a + '","' + b + '") was ' + d + ' should be ' + t)
  }
})