let res = []
const inOrder = (root) => {
    while(root) {
        root.left && inOrder(root.left)
        res.push(root.val)
        root.right && inOrder(root.right)
    }
}

function createPerson(name, age, job) {
    var o = new Object()
    o.name = name
    o.age = age
    o.job = job
    o.sayName = function() {
        console.log(this.a)
    }
    return o
}

var person1 = new createPerson('Tom', 20, 'software Engineer')

function Person(name) {
    this.name = name
    this.getName = function() {
        console.log(this.name)
    }
}

var person1 = new Person('Tom')

function Person(name) {
    this.name = name
    this.getNmae = getName
}
function getName = function() {
    console.log(this.name)
}

var person1 = new Person('Tom')

function Person(name) {

}

Person.prototype.name = 'keivn';
Person.prototype.getName = function () {
    console.log(this.name);
};

var person1 = new Person();

function Person(name) {

}

Person.prototype = {
    constructor: Person,
    name: 'kevin',
    getName: function () {
        console.log(this.name);
    }
}
var person1 = new Person()

function Person(name) {
    this.name = name
}
Person.prototype = {
    constructor: Person,
    getName: function() {
        console.log(this.name)
    }
}

var person1 = new Person()

function Person(name) {
    this.name = name;
    if (typeof this.getName != "function") {
        Person.prototype.getName = function () {
            console.log(this.name);
        }
    }
}

var person1 = new Person();

function Person(name) {
    this.name = name;
    if (typeof this.getName != "function") {
        Person.prototype = {
            constructor: Person,
            getName: function () {
                console.log(this.name);
            }
        }

        return new Person(name);
    }
}

var person1 = new Person('kevin');
var person2 = new Person('daisy');

person1.getName(); // kevin
person2.getName();  // daisy

function Person(name) {

    var o = new Object();
    o.name = name;
    o.getName = function () {
        console.log(this.name);
    };

    return o;

}

var person1 = new Person('kevin');
console.log(person1 instanceof Person) // false
console.log(person1 instanceof Object)  // true

function person(name){
    var o = new Object();
    o.sayName = function(){
        console.log(name);
    };
    return o;
}

var person1 = person('kevin');

person1.sayName(); // kevin

person1.name = "daisy";

person1.sayName(); // kevin

console.log(person1.name); // daisy

let func = (arg1, arg2) => {
    return arg1 + arg2
}
// 上面写法等价于：
let func = function(arg1, arg2) {
    retrun arg1 + arg2
}

// HTML代码
<button id="button">点击变色</button>

// javascript代码
function Button(id) {
    this.element = document.querySelector("#" + id);
    this.bindEvent()
}

Button.prototype.bindEvent = function() {
    this.element.addEventListener("click", this.setBgColor, false);
}

Button.prototype.setBgColor = function() {
    this.element.style.backgroundColor = '#1abc9c'
};

var button = new Button("button");

Button.prototype.bindEvent = function() {
    this.element.addEventListener("click", this.setBgColor.bind(this), false);
};

Button.prototype.bindEvent = function() {
    this.element.addEventListener("click", (event)=>{this.setBgColor(event)}, false)
}

function constant() {
    const h = ()=>{console.log(arguments[0])}
    h()
    return () => arguments[0]
}

var result = constant(1);
console.log(result());
// 1
// 1

const help = (...rest) => {console.log(rest)}

(function() {
    console.log('do somethings')
})()
// 用箭头函数转换
(
    ()=>{
        console.log('do somethings')
    }
)()

(function(){
    console.log('do somethings')
}())
// 当使用箭头函数替换时，会报错
(
    ()=>{
        console.log('do somethings')
    }()
)

function add(a, b) {
    return a + b;
}

// 执行 add 函数，一次传入两个参数即可
add(1, 2) // 3

// 假设有一个 curry 函数可以做到柯里化

var addCurry = curry(add);
addCurry(1)(2) // 3

// 其中addCurry等效于下面
function addCurry(a) {
    return function(b) {
        return a+b
    }
}

// 示意而已
function ajax(type, url, data) {
    var xhr = new XMLHttpRequest();
    xhr.open(type, url, true);
    xhr.send(data);
}

// 虽然 ajax 这个函数非常通用，但在重复调用的时候参数冗余
ajax('POST', 'www.test.com', "name=kevin")
ajax('POST', 'www.test2.com', "name=kevin")
ajax('POST', 'www.test3.com', "name=kevin")

// 利用 curry
var ajaxCurry = curry(ajax);

// 以 POST 类型请求数据
var post = ajaxCurry('POST');
post('www.test.com', "name=kevin");

// 以 POST 类型请求来自于 www.test.com 的数据
var postFromTest = post('www.test.com');
postFromTest("name=kevin");

// 假设我们有一个数据
var person = [{name: 'kevin'}, {name: 'daisy'}]

// 需求：我们要遍历对象的name属性

// 一般情况下
var name = person.map(function (item) {
    return item.name;
})

// 当使用柯里化之后，假定curry函数
var prop = curry(function (key, obj) {
    return obj[key]
});

var name = person.map(prop('name'))

function curry(fn,args) {
    var length = fn.length
    var args = args || []

    return function() {
        var _args = args.slice(0)

        var arg,i
        for(i=0; i<arguments.length; i++) {
            arg = arguments[i]
            _args.push(arg)
        }

        if(_args.length < length) {
            return curry.call(this, fn, _args)
        } else{
            return fn.apply(this, _args)
        }
    }
}

var fn = curry(function(a, b, c) {
    console.log([a, b, c]);
});

fn("a", "b", "c") // ["a", "b", "c"]
fn("a", "b")("c") // ["a", "b", "c"]
fn("a")("b")("c") // ["a", "b", "c"]
fn("a")("b", "c") // ["a", "b", "c"]

function* gen() {
    console.log('hello')
    let a = 1
    yield a
    a+=1
    yield a
    a+=1
    return a
}

let g = gen()
console.log(g) // gen {<suspended>}

let y1 = g.next()
console.log(y1) // 2 {value: 1, done: false}

let y2 = g.next()
console.log(y2) // 4 {value: 2, done: false}

let r = g.next()
console.log(r) // 7 {value: 3, done: true}

let f = g.next()
console.log(f) // 10 {value: undefined, done: true}

function* gen() {
  yield  123 + 456;
}

function* foo(x) {
  var y = 2 * (yield (x + 1));
  var z = yield (y / 3);
  return (x + y + z);
}

var a = foo(5);
console.log(a.next()) // Object{value:6, done:false}
console.log(a.next()) // Object{value:NaN, done:false}
console.log(a.next()) // Object{value:NaN, done:true}

var b = foo(5);
console.log(b.next()) // { value:6, done:false }
console.log(b.next(12)) // { value:8, done:false }
console.log(b.next(13)) // { value:42, done:true }

function* gen() {
    yield '1'
    yield* foo()
    yield '2'
}

function* foo() {
    yield 'a'
    yield 'b'
    return 'c'
}

for(const i of gen()) {
    console.log(i)
}

// 等价于下面写法

function* gen() {
    yield '1'
    for(const i of foo()) {
        console.log(i)
    }
    yield '2'
}

function* foo() {
    yield 'a'
    yield 'b'
}

for(const i of gen()) {
    console.log(i)
}

// 1 -> a -> b -> 2

function* gen() {
    yield '1'
    let c = yield* foo()
    yield c
}

function* foo() {
    yield 'a'
    yield 'b'
    return 'c'
}

for(const i of gen()) {
    console.log(i)
}

// 1 -> a -> b -> b

function* gen() {
  this.a = 1;
  yield this.b = 2;
  yield this.c = 3;
}

function F() {
  return gen.call(gen.prototype);
}

var f = new F();

f.next();  // Object {value: 2, done: false}
f.next();  // Object {value: 3, done: false}
f.next();  // Object {value: undefined, done: true}

f.a // 1
f.b // 2
f.c // 3

function showLoadingScreen(){
    console.log('showLoadingScreen')
}

function loadUIDataAsynchronously(){
    setTimeout(()=>{console.log('loadUIDataAsynchronously')},1000)
}

function hideLoadingScreen(){
    console.log('hideLoadingScreen')
}

function* loadUI() {
  showLoadingScreen();
  yield loadUIDataAsynchronously();
  hideLoadingScreen();
}
var loader = loadUI();

loader.next()
//  showLoadingScreen
//  loadUIDataAsynchronously

loader.next()
// hideLoadingScreen

step1(function (value1) {
  step2(value1, function(value2) {
    step3(value2, function(value3) {
      step4(value3, function(value4) {
        // Do something with value4
      });
    });
  });
});

Promise.resolve(step1)
  .then(step2)
  .then(step3)
  .then(step4)
  .then(function (value4) {
    // Do something with value4
  }, function (error) {
    // Handle any error from step1 through step4
  })
  .done();

function* longRunningTask(value1) {
  try {
    var value2 = yield step1(value1);
    var value3 = yield step2(value2);
    var value4 = yield step3(value3);
    var value5 = yield step4(value4);
    // Do something with value4
  } catch (e) {
    // Handle any error from step1 through step4
  }
}

// Generator处理多个异步操作部分
var fetch = require('node-fetch');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var r3 = yield fetch('https://api.github.com/users/github/repos');

    console.log([r1.bio, r2[0].login, r3[0].full_name].join('\n'));
}

// Generator自动运行函数 run
function run(gen) {
    var gen = gen();

    return new Promise(function(resolve, reject) {

        function next(data) {
            try {
                var result = gen.next(data);
            } catch (e) {
                return reject(e);
            }

            if (result.done) {
                return resolve(result.value)
            };

            var value = toPromise(result.value);

            value.then(function(data) {
                next(data);
            }, function(e) {
                reject(e)
            });
        }

        next()
    })

}

function isPromise(obj) {
    return 'function' == typeof obj.then;
}

function toPromise(obj) {
    if (isPromise(obj)) return obj;
    if ('function' == typeof obj) return thunkToPromise(obj);
    return obj;
}

function thunkToPromise(fn) {
    return new Promise(function(resolve, reject) {
        fn(function(err, res) {
            if (err) return reject(err);
            resolve(res);
        });
    });
}

run(gen)

// yield 后是一个 Promise
var fetch = require('node-fetch');
var co = require('co');

function* gen() {
    var r1 = yield fetch('https://api.github.com/users/github');
    var json1 = yield r1.json();
    var r2 = yield fetch('https://api.github.com/users/github/followers');
    var json2 = yield r2.json();
    var r3 = yield fetch('https://api.github.com/users/github/repos');
    var json3 = yield r3.json();

    console.log([json1.bio, json2[0].login, json3[0].full_name].join('\n'));
}

co(gen);
// yield 后是一个回调函数
var co = require('co');

function fetchData(url) {
    return function(cb) {
        setTimeout(function() {
            cb(null, { status: 200, data: url })
        }, 1000)
    }
}

function* gen() {
    var r1 = yield fetchData('https://api.github.com/users/github');
    var r2 = yield fetchData('https://api.github.com/users/github/followers');

    console.log([r1.data, r2.data].join('\n'));
}

co(gen);

function animal() {
    this.name = 'cat'
    this.age = 3
}

animal.prototype.speed = 'fast'

animal.prototype.say = function() {
    console.log(this.name, ':miao miao')
}

var xiaoHua = new animal()
console.log(xiaoHua.age) // 3
console.log(xiaoHua.speed) // 'fast'
xiaoHua.say() // cat:miao miao

function imiate_new() {
    var obj = new Object()
    // arguments参数会因为shift去掉第一个,shift会改变原数组
    Constructor = Array.prototype.shift.call(arguments)
    obj.__proto__ = Constructor.prototype

    var ret = Constructor.apply(obj, arguments)
    return typeof obj === 'object' ? ret : obj
}

{
    "presets": ["env"],
    "plugins": [
        ["transform-react-jsx", {
            "pragma": "React.createElement"
        }]
    ]
}

function Component(props, context, updater) {
  this.props = props;
  this.context = context; // If a component has string refs, we will assign a different object later.

  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
  // renderer.

  this.updater = updater || ReactNoopUpdateQueue;
}

Component.prototype.isReactComponent = {};

Component.prototype.setState = function (partialState, callback) {
  if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {
    {
      throw Error( "setState(...): takes an object of state variables to update or a function which returns an object of state variables." );
    }
  }

  this.updater.enqueueSetState(this, partialState, callback, 'setState');
};

class App extends React.Component {
  constructor(props) {
    super(props)
    this.state = {name: 'tom'}
  }

  componentDidMount() {
    
  }

  render() {
    return (
      <div>{this.state.name}</div>
    )
  }
}

var App = /*#__PURE__*/function (_React$Component) {
  _inheritsLoose(App, _React$Component);

  function App(props) {
    var _this;

    _this = _React$Component.call(this, props) || this;
    _this.state = {
      name: 'tom'
    };
    return _this;
  }

  var _proto = App.prototype;

  _proto.componentDidMount = function componentDidMount() {};

  _proto.render = function render() {
    return /*#__PURE__*/React.createElement("div", null, this.state.name);
  };

  return App;
}(React.Component);

function createElement(type, config, children) {
 // ...
  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
}

var ReactElement = function (type, key, ref, self, source, owner, props) {
  var element = {
    // This tag allows us to uniquely identify this as a React Element
    $$typeof: REACT_ELEMENT_TYPE,
    // Built-in properties that belong on the element
    type: type,
    key: key,
    ref: ref,
    props: props,
    // Record the component responsible for creating this element.
    _owner: owner
  };

  return element;
};

function render(element, container, callback) {
    ...
  return legacyRenderSubtreeIntoContainer(null, element, container, false, callback);
}

function legacyRenderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {
    ...
  var root = container._reactRootContainer;
  var fiberRoot;

  if (!root) {
    // Initial mount
    root = container._reactRootContainer = legacyCreateRootFromDOMContainer(container, forceHydrate);
    fiberRoot = root._internalRoot;

    if (typeof callback === 'function') {
      var originalCallback = callback;

      callback = function () {
        var instance = getPublicRootInstance(fiberRoot);
        originalCallback.call(instance);
      };
    } // Initial mount should not be batched.


    unbatchedUpdates(function () {
      updateContainer(children, fiberRoot, parentComponent, callback);
    });
  } else {
    fiberRoot = root._internalRoot;

    if (typeof callback === 'function') {
      var _originalCallback = callback;

      callback = function () {
        var instance = getPublicRootInstance(fiberRoot);

        _originalCallback.call(instance);
      };
    } // Update


    updateContainer(children, fiberRoot, parentComponent, callback);
  }

  return getPublicRootInstance(fiberRoot);
}

class App extends React.Component {
  constructor(props) {
    super(props)
    this.state = {
      anything: '初始化'
    }  
  }
  
  render() {
    console.log('outer', this.state.anything)
    return (
      <div>
        <button
          onClick={() => {
            this.setState({
              anything:'同步1'
            })
            this.setState({
              anything:'同步2'
            })
            Promise.resolve().then(()=>{
              this.setState({
                anything:'微任务1'
              })
            })
            Promise.resolve().then(()=>{
              this.setState({
                anything:'微任务2'
              })
            })
            setTimeout(()=>{
              this.setState({
                anything: 'after 宏任务1',
              })
            },1000)
            setTimeout(()=>{
              this.setState({
                anything: 'after 宏任务2',
              })
            },1000)
          }}
        >
          {this.state.anything}
        </button>
      </div>
    )
  }
}

// 循环的方式
var fib = function(n) {
    if(n==0) return 0
    if(n==1) return 1

    // loop
    let fn1 = 0
    let fn2 = 1
    let fn3 
    for(let i=2; i<=n; i++) {
        fn3 = (fn1 + fn2) % 1000000007
        fn1 = fn2
        fn2 = fn3
    }
    return fn2 
};

var minArray = function(numbers) {

    let left = 0
    let right = numbers.length - 1
    let mid
    while(left < right) {
        mid = ~~((left + right) / 2)
        if(numbers[mid] > numbers[right]) {
            left = mid + 1
        } else if(numbers[mid] == numbers[left]) {
            right = right - 1
        } else {
            right = mid 
        }

    }
    // 因为mid没有及时更新，最后left==right，返回最小也就时返回numbers[left]
    return numbers[left] 
};

 for(let i=0; i<nums.length; i++) { 
     for(let j=0; j<nums.length; j++) {
   }
}

var LRUCache = function(capacity) {
    this.cache = new Map()
    this.capacity = capacity
};

LRUCache.prototype.get = function(key) {
    const cache = this.cache
    if(!cache.has(key)) return -1

    const value = cache.get(key)
    cache.delete(key)
    cache.set(key, value)

    return value
};

LRUCache.prototype.put = function(key, value) {
    const cache = this.cache
    if(cache.has(key)) cache.delete(key)
    cache.set(key, value)
    if(cache.size > this.capacity) cache.delete(cache.keys().next().value)
};

Function.prototype.bind2 = function(context) {
    // 如果调用bind2不是函数，抛出错误
    if (typeof this !== "function") {
      throw new Error("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var self = this
    var args = Array.prototype.slice.call(arguments, 1)

    var tempF = function () {}

    var fBound = function() {
        var bindArgs = Array.prototype.slice.call(arguments)
        // 如果作为构造函数时，this指向实例，将绑定的函数指向该函数，可以让实例获得来自绑定函数的值
        //如果作为普通函数时，this指向window，将指定的函数指向context
        return self.apply(this instanceof tempF ? this : context, args.concat(bindArgs))
    }

    tempF.prototype = this.prototype
    // 修改返回函数的原型为绑定函数的原型，实例可以继承绑定函数原型的值；这里用了tempF来作中转，避免直接修改fBound.prototype时，也会修改绑定函数
    fBound.prototype = new tempF()

    return fBound
}

function Parent() {
    this.name = 'tom'
}

parent.protoype.sayName = function() {
    console.log(this.name)
}

function child() {

}

child.prototype = new Parent()

var child1 = new child()  

function Parent() {
    this.names = ['tom', 'JieNi']
    this.sayName = function() {
        console.log(this.names)
    }
}

function child() {
    Parent.call(this)
}

var child1 = new child()
child1.names.push('Pika')
console.log(child1.names) // ['tom', 'JieNi', 'Pika']

var child2 = new child()
console.log(child2.names) // ['tom', 'JieNi']

function Parent(name) {
    this.name = name
    this.colors = ['green', 'yellow', 'red']
}

Parent.prototype.sayName = function() {
    console.log(this.name)
}

function child(name, age) {
    Parent.call(this, name)

    this.age = age
}
child.prototype = new Parent()
child.prototype.constructor = child

var child1 = new child('Tom', 18)
child1.colors.push('black')
console.log(child1.name) // Tom
console.log(child1.age) // 18
console.log(child1.colors) // ["green", "yellow", "red", "black"]
child1.sayName() // Tom

var child2 = new child('JieNi', 20)
console.log(child2.name) // JieNi
console.log(child2.age) // 20
console.log(child2.colors) // ["green", "yellow", "red"]
child2.sayName() // JieNi

function createObj(o) {
    function F(){}
    F.prototype = o;
    return new F();
}
var person = {
    name: 'kevin',
    friends: ['daisy', 'kelly']
}

var person1 = createObj(person);
var person2 = createObj(person);

person1.name = 'person1';
console.log(person2.name); // kevin

person1.friends.push('taylor')
console.log(person2.friends); // ["daisy", "kelly", "taylor"]

function createObj(o) {
    var clone = Object.create(o)
    clone.sayName = function() {
        console.log('do somethings')
    }
    return clone
}

function Parent (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}

Parent.prototype.getName = function () {
    console.log(this.name)
}

function Child (name, age) {
    Parent.call(this, name);
    this.age = age;
}

// 关键的三步
var F = function () {};

F.prototype = Parent.prototype;

Child.prototype = new F();


var child1 = new Child('kevin', '18');

console.log(child1);

function object(o) {
    function F() {}
    F.prototype = o
    return new F()
}

function inherit(child, parent) {
    var prototype = object(parent.prototype)
    prototype.constructor = child
    child.prototype = child
}
// 需要继承时
inherit(child, parent)

let m = new WeakMap()
m.set({}, 'tom')

m.set(1, 'tom')// Invalid value used as weak map key
m.set(null, 'tom') // Invalid value used as weak map key

let key = new Array(1024*1024*5)
let wm = new WeakMap()
wm.set(key, 1)

var element = documnet.getElementById('button')

let wm = new WeakMap()
wm.set(element, 'red button')

wm.get(element) // red button
element.parentNode.removeChild(element);

element = null;

const cache = new WeakMap();
function countOwnKeys(obj) {
    if (cache.has(obj)) {
        console.log('Cached');
        return cache.get(obj);
    } else {
        console.log('Computed');
        const count = Object.keys(obj).length;
        cache.set(obj, count);
        return count;
    }
}

const privateData = new WeakMap();

class Person {
    constructor(name, age) {
        privateData.set(this, { name: name, age: age });
    }

    getName() {
        return privateData.get(this).name;
    }

    getAge() {
        return privateData.get(this).age;
    }
}

export default Person;

var exist = function(board, word) {

    let m = board.length
    let n = board[0].length
    const directions = [
        [0, 1],
        [0, -1],
        [1, 0],
        [-1, 0]
    ]

    const dfs = (i, j, k) => {
        if(board[i][j] != word[k]) return false
        if(k == word.length-1) return true
        // *表示这个格子已经用过了
        board[i][j] = '*'
        // 左、右、上、下都可以走
        for(const [dx, dy] of directions) {
            const newX = i + dx
            const newY = j + dy
            // 左右上下边界情况
            if(newX>=0 && newX<m && newY>=0 && newY<n) {
                if(dfs(newX, newY, k+1)) return true
            }
        }
        // reserve
        board[i][j] = word[k]
        return false
    }

    for(let p=0; p<m; p++) {
        for(let q=0; q<n; q++) {
            if(dfs(p, q, 0)) {
                return true
            }
        }
    }

    return false
};

let promise = new Promise(function(resolve, reject) {
  console.log('Promise');
  resolve(['arg1','arg2']);
});

promise.then(function(...args) {
  console.log('resolved.',args);
});

let p1 = new Promise((resolve, reject) => {
    setTimeout(()=> reject(new Error('some error')), 2000)
})

let p2 = new Promise((resolve, reject) => {
    setTimeout(()=> resolve(p1), 1000)
})

p2
.then((result) => {console.log(result)})
.catch((error) => {console.log(error)})
// Error: some error

let p1 = new Promise((resolve, reject) => {
    setTimeout(()=> reject(new Error('some error')), 2000)
})

let p2 = new Promise((resolve, reject) => {
    setTimeout(()=> resolve(p1), 1000)
})

p1.then((value) => {},(error)=>{console.log('p1',error)})

p2
.then((result) => {console.log(result)})
.catch((error) => {console.log(error)})
// p1  Error: some error
//  Error: some error

let p1 = new Promise((resolve, reject) => {
    resolve('p1')
})

let p2 = p1.then((value)=>{console.log(value)})

console.log(p2 instanceof Promise) // true
console.log(p1 === p2) // false

function addone(x) {
    console.log('addone parmas',x)
    return x+1
}

function addtwo(x) {
    console.log('addtwo parmas',x)
    return x+2
}    


let p1 = new Promise((resolve, reject) => {
    resolve(1)
})

p1
.then(result => addone(result))
.then(newResult => addtwo(newResult))
.then(finalResult => {
  console.log(`Got the final result: ${finalResult}`);
})
.catch((error)=>{console.log(error)});
// parmas 1
// addtwo parmas 2
// Got the final result: 4

setTimeout(function(){console.log('timer1')}, 0)

requestAnimationFrame(function(){
    console.log('requestAnimationFrame')   
})

setInterval(() => {
    console.log('setInterval')
}, 5000);

setTimeout(function(){ console.log('timer2' )}, 0)


new Promise(function executor(resolve) {
    console.log('promise 1')
    resolve()
    console.log('promise2')
}).then(function(){
    console.log('promise then')
})

console.log('end')

// bad
loadSomething().then(function(something) {
    loadAnotherthing().then(function(another) {
        DoSomethingOnThem(something, another);
    });
});
// good
Promise.all([loadSomething(), loadAnotherthing()])
.then(function ([something, another]) {
    DoSomethingOnThem(...[something, another]);
});

// bad
function anAsyncCall() {
    var promise = doSomethingAsync();
    promise.then(function() {
        somethingComplicated();
    });

    return promise;
}
// good
function anAsyncCall() {
    var promise = doSomethingAsync();
    return promise.then(function() {
        somethingComplicated()
    });
}

// bad
somethingAync.then(function() {
    return somethingElseAsync();
}, function(err) {
    handleMyError(err);
});

// good
somethingAsync()
.then(function() {
    return somethingElseAsync();
})
.catch(function(err) {
    handleMyError(err);
});

function red(){
    console.log('red');
}
function green(){
    console.log('green');
}
function yellow(){
    console.log('yellow');
}

var light = function(timer, cb) {
    return new Promise((resolve, reject) => {
        setTimeout(function(){
            cb()
            resolve()
        }, timer)
    })
}

var step = function() {
    return Promise.resolve()
                        .then(() => light(3000, red))
                        .then(() => light(2000, green))
                        .then(() => light(1000, yellow))
                        .then(() => { step() })
}

step()

let promise = new Promise(() => {
    throw new Error('error')
});
console.log(2333333);

Promise.all([Promise.resolve(1), Promise.resolve(2)])
.then(([x, y]) => {
    console.log(x, y);
});

"husky": {
    "hooks": {
      "pre-commit": "npm run lint", // 在git commit之前执行 "npm run lint"
      "commit-msg": "commitlint -e $HUSKY_GIT_PARAMS" // 检测提交信息的规范
    }
  }

  0.1100110011001100110011001100110011001100110011001101
+ 1.1001100110011001100110011001100110011001100110011010
————————————————————————————————————————————————————————
 10.0110011001100110011001100110011001100110011001100111

// 十进制转二进制
parseFloat(0.1).toString(2);
=> "0.0001100110011001100110011001100110011001100110011001101"

// 二进制转十进制
parseInt(1100100,2)
=> 100

// 以指定的精度返回该数值对象的字符串表示
(0.1 + 0.2).toPrecision(21)
=> "0.300000000000000044409"
(0.3).toPrecision(21)
=> "0.299999999999999988898"

// 暴力法
var hammingWeight = function(n) {
    let mask = 1
    let res = 0
    for(let i=0; i<32; i++) {
        // js 进行&运算时，要用()，如果mask & n这么写，结果不正确
        if((mask&n) != 0) {
            res++
        }
        n >>= 1
    }
    return res
};

// 优化版
var hammingWeight = function(n) {
    let res = 0
    while(n!=0) {
        n = n & (n-1)
        res++
    }
    return res
};

var reversePrint = function(head) {
    let a = []
    while(head != null) {
        a.unshift(head.val)
        head = head.next
    }
    return a
};

// 1.暴力法：把整数n转换成二进制数，遍历然后统计1的个数 O(32)
// 2.x&(x-1)每次清零最低为的1，判断x是否为0，
var hammingWeight = function(n) {
    let res = 0
    while(n!=0) {
        n = n & (n-1)
        res++
    }
    
    return res
};

var reverseBits = function(n) {
    let res = 0
    let count = 32

    while(count--) {
        res *= 2 // 可以用 res << 1 替换
        res += n&1
        n>>=1
    }
    return res
};

var reverseBits = function(n) {
    if (n === 0) return 0;

    var result = 0;
    for (var i = 0; i < 32; i ++) {
        result <<= 1;
        if (n & 1 === 1) {
            result += 1;
        }
        
        n >>= 1;
    }
    return result>>>0; // 在js中，用>>>0把结果转换成无符号整数
};

var totalNQueens = function(n) {
    let res = 0

    // n,row,col,ld,rd 表示n行，当前第几行，列，撇，捺是否有皇后
    const dfs = (n, row, col, ld, rd) => {
        if(row >= n) {
            res++
            return
        }
        // bits代表当前行可以放置皇后的位置，二进制中的1代表可以放置皇后
        let bits = ~(col | ld | rd) & ((1 << n) - 1)
        while(bits > 0) {
            // 拿到bits最低的1
            const p = bits & -bits
            dfs(n, row+1, col | p, (ld | p) << 1, (rd | p) >> 1)
            bits &= bits - 1
        }
    }
    dfs(n, 0, 0, 0, 0)
    return res
};

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;
// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

var arr = []
for(var i = 0; i<10; i++) {    
    arr[i] = function() {
            console.log(i)    
        }
    }
arr[3]() // 预期值是3，实际上是10

var arr = []
for(var i=0; i<10; i++) {
    (function(val) {
        arr[i] = function() {
            console.log(i)
        }
    })(i)
}
arr[3]()

var arr = []
for(let i = 0; i<10; i++) {    
    arr[i] = function() {
            console.log(i)    
        }
    }
arr[3]() 

// ES6
let a = 1

// after babel
"use strict";

var a = 1; 

// ES6
if (false) {
    let value = 1;
}
console.log(value); // Uncaught ReferenceError: value is not defined

// after babel
"use strict";

if (false) {
  var _value = 1;
}

console.log(value); // Uncaught ReferenceError: value is not defined

// ES6
var arr = []
for(let i=0; i<10; i++) {
    arr[i] = function() {
        console.log(i)
    }
}
arr[0]()

// after babel
"use strict";

var arr = [];

var _loop = function _loop(i) {
  arr[i] = function () {
    console.log(i);
  };
};

for (var i = 0; i < 10; i++) {
  _loop(i);
}

arr[0]();

var replaceSpace = function(s) {
      if (typeof s == "string" && s.length >= 0 && s.length <= 10000) {
        return s.split(' ').join('%20');
      }
      return '';
};

// 方式一
function f() {
    if(typeof XMLHttpRequest != 'undefined') {
        f = function() {
            // do something
        }
    } else if(typeof ActiveXObject != 'undefined') {
        f = function() {
            // do somethins
        }
    } else {
        f = function() {
            throw new Error('some error')
        }
    }
    return f()
}

// 方式二
var f = (function() {
    if(typeof XMLHttpRequest != 'undefined') {
        return function() {
            // do something
        }
    } else if(typeof ActiveXObject != 'undefined') {
        return function() {
            // do somethins
        }
    } else {
        return function() {
            throw new Error('some error')
        }
    }
})()

function fun3() {
    console.log('fun3')
}

function fun2() {
    fun3();
}

function fun1() {
    fun2();
}

fun1();

var buildTree = function(preorder, inorder) {
    if(!preorder.length || !inorder.length) return null

    const recursion = (left, right) =>{
        if(left > right) return null

        const val = preorder.shift()
        const root = new TreeNode(val)
        // 只有left>right，那么说明左(右)子树还有相应结点
        root.left = recursion(left, inorder.indexOf(val) - 1)
        root.right = recursion(inorder.indexOf(val) + 1, right)

        return root
    }

    return recursion(0, inorder.length-1)
};

let obj ={name:'jack',age:'20'};
// 字符串拼接
console.log('我的名字'+obj.name+'年龄是'+obj.age);
// ES6的模板字符串
console.log(`es6   我的名字${obj.name},年龄是${obj.age}`);

let a = 5
let b = 10
tag`five${a} add ten${b}`
tag = function(strArray, value1, value2) {
    console.log(strArray)
    console.log(value1)
    console.log(value2)
}
// console result
strArray -- ["five", " add ten", ""] 
value1 -- 5
value2 -- 10

function tag(literals, ...values) {
    let result = ''
    for(let i=0; i<values.length; i++) {
        result += literals[i]
        result += values[i]
    }
    
    result += literals[literals.length-1]

    return result
}

function tag(literals, ...values) {
    let result = literals.reduce((acc, curr, i) => {
        let value = values[i-1]
        return acc + value + curr
    })
}

// no initialValue
arr.reduce(callback(acc, curr, i, sourceArray) => {
    // do some things
    return 
})

// initialValue
arr.reduce(callback(acc, curr, i, sourceArray) => {
    // do some things
    return 
}, 10)

// 当有初始值的时候，累计器初始化是这个值，当前值从array[0]开始，索引从0开始
// 没有初始值的时候，累计器初始化的值为array[0]，当前值从array[1]开始，索引从1开始

let sender = '<script>alert("abc")</script>'; // 恶意代码

let message = SaferHTML`<p>${sender} has sent you a message.</p>`;

function SaferHTML(templateData) {
    let s = templateData[0];

    for (let i = 1; i < arguments.length; i++) {
    
        let arg = String(arguments[i]);
    
        // Escape special characters in the substitution.
        s += arg.replace(/&/g, "&amp;")
        .replace(/</g, "&lt;")
        .replace(/>/g, "&gt;");
    
        // Don't escape special characters in the template.
        s += templateData[i];
    }

    return s;
}
// after deal, message is:
"<p>&lt;script&gt;alert("abc")&lt;/script&gt; has sent you a message.</p>"

i18n`Welcome to ${siteName}, you are visitor number ${visitorNumber}!`
// "欢迎访问xxx，您是第xxxx位访问者！"

// 下面的hashTemplate函数
// 是一个自定义的模板处理函数
let libraryHtml = hashTemplate`
<ul>
#for book in ${myBooks}
<li><i>#{book.title}</i> by #{book.author}</li>
#end
</ul>
`;

let message = oneLine `
    Hi,
    Daisy!
    I am
    Kevin.
`;
console.log(message); // Hi, Daisy! I am Kevin.

function oneLine(arrStr, ...values) {
    let result = arrStr.reduce((acc, curr, i) => {
        let value = values[i-1]
        return acc + value + curr
    })

    result = result.replace(/(\n\s*)/g, " ")
    result = result.trim()

    return result
}

let a = {'0':1, 'length':1}
a.push() // 抛出错误

let a = ['old', 1, null]
let new_a = a.concat()
let new_b = a.slice()

let a = [{'old': 'old'}, [1]]
let new_a = a.concat()

new_a[1][0] = 2

console.log(a) // [{'old': 'old'}, [2]]
console.log(new_a) // [{'old': 'old'}, [2]]

let a = [1, null, [1, 2], {'name': 'tom'}]
let new_a = JSON.parse(JSON.stringify(a))
console.log(new_a)

function deepCopy (obj) {
    if(typeof obj !== 'object') return
    var new_arr = Array.isArray(obj) ? [] : {}

    for(let key in obj) {
        if(obj.hasOwnProperty(key)) {
            if(obj[key]==null) {
                new_arr[key] = null
            } else{
                new_arr[key] = typeof obj[key] === 'object' ? deepCopy(obj[key]) : obj[key]
            }
        }
    }
    return new_arr
}

// 都能生效
console.log(Math.random());
console.log(this.Math.random());

// 在客户端中，this引用就是Windows对象
console.log(this);

this.parseInt == parseInt // true

function foo(a) {
  var b = 2;
  function c() {}
  var d = function() {};

  b = 3;

}

foo(1);

OA = {
    arguments: {
        0: 1, // 如果参数超过2个以上，那么超过的参数会以callee的方式存储
        length: 1 // 表示参数的个数
    },
    a: 1,
    b: undenfined,
    c: reference to function c(){},
    d: undenfined
}

AO = {
    arguments: {
        0:1,
        length:1
    },
    a: 1,
    b: 3,
    c: reference to function c(){},
    d: reference to FunctionExpression "d",
}

// 快排代码模板
/**
* @param {array[]} arr
* @param {Number} begin
* @param {Number} end
* @return void
*/
function quicksort(arr, begin, end){
    if(begin >= end) return
    let pivot = partition(arr, begin, end)
    quicksort(arr, begin, pivot-1)
    quicksort(arr, pivot+1, end)
}

// partition:找出标杆位置
function partition(arr, begin, end) {
    // pivot标杆位置从end开始，counter表示小于pivot位置的元素个数
    let pivot = end, counter = begin
    for(let i=begin; i<end; i++) {
        if(arr[i] < arr[pivot]) {
            // swap:即把小于pivot的值全部防止到0~counter-1的位置
            let temp = arr[counter]
            arr[counter] = arr[i]
            arr[i] = temp
            counter++
        }
    }
    // swap:把pivot换到该到的位置arr[counter]
    let temp = arr[pivot]
    arr[pivot] = arr[counter]
    arr[counter] = temp

    return counter
}

function mergeSort(arr, left, right) {
    if(left >= right) return
    let mid = ~~((right+left)/2)

    mergeSort(arr, left, mid)
    mergeSort(arr, mid+1, right)
    merge(arr, left, mid, right)
}

function merge(arr, left, mid, right) {
    let temp = [] // 长度为right-left+1
    let i=left, j=mid+1, k=0 // k表示temp中目前有多少个成员

    while(i<=mid && j<=right) {
        temp[k++] = arr[i] >= arr[j] ? arr[j++] : arr[i++]
    }
    while(i<=mid) temp[k++] = arr[i++]
    while(j<=right) temp[k++] = arr[j++]

    //把排序好的temp给arr
    for(let p=0; p<temp.length; p++) {
        arr[left+p] = temp[p]
    }
}

function animal () {

}
animal.prototype.age = 'ten'
let dog = new animal()
let cat = new animal()
console.log(dog.name) // console result --> ten
console.log(cat.name) // console result --> ten
console.log(dog.prototype) // console result --> undefined

function animal() {

}
let dog = new animal()
console.log(dog.__proto__ === animal.prototype) // console result --> true

function animal() {

}
let dog = new animal()
console.log(animal == animal.prototype.constructor) // ture
console.log(Object.getPrototypeOf(dog) == animal.prototype) // ture

function animal() {

}
animal.prototype.age = 10
let dog = new animal()
dog.age = 5
console.log(dog.age) // 5
delete dog.age
console.log(dog.age) // 10

function animal() {

}
let dog = new animal()
console.log(animal.prototype.__proto__.constructor) // Object() 

console.log(Object.prototype.__proto__ === null) // ture

function createIterator(items) {
    var i = 0
    return {
        next: function() {
            var done = i >= items.length
            var value = !done ? items[i++] : undefined

            return {
                done: done,
                value: value
            }
        }
    }
}

var iterator = createIterator([3, 4, 5])
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())
console.log(iterator.next())

var obj = {
    value: 1
};

for (value of obj) {
    console.log(value);
}

// TypeError: iterator is not iterable

const obj = {
    value: 1
};

obj[Symbol.iterator] = function() {
    return createIterator([1, 2, 3]);
};

for (value of obj) {
    console.log(value);
}

var a = [1, 2, 3]
for(const i of a) {
    console.log(i)
}

var a = [1, 2, 3]

a[Symbol.iterator] = function() {
    return createIterator(['Tom', 'JieNi'])
}

for(const i of a) {
    console.log(i)
}

// 原本的for...of
var a = [1, 2, 3]
for(const i of a) {
    console.log(i)
}
// 模拟实现for...of
function forOf (obj, cb) {
    let iterator, res
    if(typeof obj[Symbol.iterator] != 'function')
        throw new TypeError(obj+'is not iterator')
    if(typeof cb != 'function')
        throw new TypeError('cb must be callable')
    
    iterator = obj[Symbol.iterator]()

    res = iterator.next()
    while(!res) {
        cb(res.value)
        res = iterator.next()
    }
}
function cb(i) {
    // cb 函数模拟for...of循环代码内部的逻辑
    console.log(i)
}

var a = ['Tom', 'JieNi']

for(const i of a.keys()) {
    console.log(i)
}

for(const i of a.values()) {
    console.log(i)
}

for(const i of a.entries()) {
    console.log(i)
}

var a = new Set(['Tom', 'JieNi'])

for(const i of a.keys()) {
    console.log(i)
}

for(const i of a.values()) {
    console.log(i)
}

for(const i of a.entries()) {
    console.log(i)
}

var data = [];

for (var i = 0; i < 3; i++) {
  data[i] = function () {
    console.log(i);
  };
}

data[0]();
data[1]();
data[2]();

globalContext = {
    VO: {
        data:[...],
        i:3
    }
}

data[0]Context = {
    scope: [VO, globalContext]
}

var data = []

for(var i=0; i<3; i++) {
    data[i] = (function (i) {
        return function () {
            console.log(i)
        }
    })(i)
}

data[0]();
data[1]();
data[2]();

globalContext = {
    VO: {
        data: [...],
        i:3
    }
}

data[0]Context = {
    scope:[VO, 匿名函数Context.VO, globalContext.VO]
}

匿名函数Context = {
    VO:{
        arguments:{
            0:0,
            length:1
        },
        i: 0
    }
}

var data = []

for(var i=0; i<3; i++) {
    data[i] = (function (i) {
        return function () {
            console.log(this.i)
        }
    })(i)
}

data[0]();
data[1]();
data[2]();

function f(){
  var o = {};
  var o2 = {};
  o.a = o2; // o 引用 o2
  o2.a = o; // o2 引用 o

  return "azerty";
}

f();

var foo =  {
    value : 1
}

function bar() {
    console.log(this.value)
}
bar.call(foo) // 1

Function.prototype.call2 = function(context) {
    context = context || window
    // this是调用call2的函数，也就是需要执行的函数bar
    context.fn = this

    const args = []
    for(let i=1; i<arguments.length; i++) {
        args.push(arguments[i])
    }

    const result = context.fn(...args)

    delete context.fn

    return result
}

var value = 1

var foo = {
    value: 2
}

function bar(age, name) {
    console.log(this.value)
    return {
        age: age,
        name: name,
        value: this.value
    }
}

bar.call2(null) // 1

bar.call2(foo, 20, 'tom')
// Object = {
//    age: 20
//    name: "tom"
//    value: 2
//}

Function.prototype.apply2 = function(context) {
    context = context || window
    // this是调用call2的函数，也就是需要执行的函数bar
    context.fn = this
    
    var result
    if(arguments.length==1) {
        result = context.fn()
    } else{
        // apply接收一个参数数组
        const args = arguments[1]
        const result = context.fn(...args)
    }

    delete context.fn
    return result
}

var arr1 = [1,2,3]
var arr2 = [4,5,6]

arr1.push.apply(arr1, arr2)
console.log(arr1) // [1, 2, 3, 4, 5, 6]

/* 找出数组中最大/小的数字 */
var numbers = [5, 6, 2, 3, 7];

var max = Math.max.apply(null, numbers); 
var min = Math.min.apply(null, numbers);

function minOfArray(arr) {
  var min = Infinity; // 无穷大
  var QUANTUM = 32768; // 参数上限长度

  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
    min = Math.min(submin, min);
  }

  return min;
}

var min = minOfArray([5, 6, 2, 3, 7]);

function f(n) {
    if(n<=1) return 1
    return f(n-1) + f(n-2)
}

let men = new Map()
function f(n) {
    if(n<=1) return 1
    if(!men.has(n)) {
        map.set(n, f(n-1)+f(n-2))
    }
    return m.get(n)
}

function f(n) {
    dp = [1, 1]
    for(let i=2;i<=n; i++) {
        dp[i] = dp[i-1] + dp[i-2]
    }
    return dp[n]
}

function f(n) {
    fn0 = 1
    fn1 = 1
    fn2
    for(let i=2;i<=n; i++) {
        fn2 = fn1 + fn2
        fn0 = fn1
        fn1 = fn2
    }
    return fn2
}

function f(m, n) {
    if(m<=0 || n<=0) return 0
    if(m==1 && n==1) return 1
    return f(m-1, n) + f(m, n-1)
}

function f(m, n) {
    let dp = Array(m).fill(1).map(x => Array(n).fill(1))
    for(let i=1; i<m; i++) {
        for(let j=1; j<n; j++) {
            dp[i][j] = dp[i-1][j] + dp[i][j-1]
        }
    }
    return dp[m-1][n-1]
}

var rob = function(nums) {
    if(nums.length==0) return 0
    if(nums.length==1) return nums[0]
    dp = []
    dp[0] = nums[0]
    dp[1] = Math.max(dp[0], nums[1])
    for(let i=2;i<nums.length; i++) {
        dp[i] = Math.max(dp[i-1], dp[i-2]+nums[i])
    }
    return dp[dp.length-1]
}

var rob = function(nums) {
    if(nums.length==0||nums==null) return 0
    if(nums.length==1) return nums[0]
    let f1 = nums[0]
    let f2 = Math.max(nums[0], nums[1])
    let temp
    for(let i=2; i<nums.length; i++) {
        temp = f2
        f2 = Math.max(f2, f1+nums[i])
        f1 = temp
    }
    return f2
}

// dp[i][0] 表示第i没偷,dp[i][1] 表示第i偷,那么前一天一定没偷,今天偷.
dp[i][0] = max(dp[i-1][0], dp[i-1][1])
dp[i][1] = dp[i-1][0] + nums[i]

var minimumTotal = function(triangle) {
    for(let i=triangle.length-2; i>=0; i--) {
        for(let j=0; j<triangle[i].length; j++) {
            triangle[i][j] = Math.min(triangle[i+1][j], triangle[i+1][j+1]) + triangle[i][j]
        }
    }
    return triangle[0][0]
};

var maxProfit = function(prices) {
    let minPrice = prices[0]
    let maxProfit = 0
    for(let i=1; i<prices.length; i++) {
        if(prices[i] < minPrice) {
            minPrice = prices[i]
        } else if(prices[i]-minPrice>maxProfit) {
            maxProfit = prices[i] - minPrice
        }
    }
    return maxProfit
};

dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k][1]+prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0]-prices[i])

// Generator写法
function f(time) {
    return new Promise(
        (resolve, reject) => {
            setTimeout(() => {
                console.log("after time:", time)
                resolve()
            }, time)

        }
    )
}


function* gen() {
    yield f(1000)
    yield f(2000)
}

var g = gen()

g.next().value.then(()=>{console.log('successs')})
g.next().value.then(()=>{console.log('successs')})

async function asyncGen() {
    await f(1000).then(()=>{console.log('success')})
    await f(2000).then(()=>{console.log('success')})
}

asyncGen()

/**
 * 处理单个异步操作
 */
function fetch() {
  return (
    fetchData()
    .then(() => {
      return "done"
    });
  )
}

async function fetch() {
  await fetchData()
  return "done"
};
/**
 * 对单个异步操作返回值进行操作
 */
function fetch() {
  return fetchData()
  .then(data => {
    if (data.moreData) {
        return fetchAnotherData(data)
        .then(moreData => {
          return moreData
        })
    } else {
      return data
    }
  });
}

async function fetch() {
  const data = await fetchData()
  if (data.moreData) {
    const moreData = await fetchAnotherData(data);
    return moreData
  } else {
    return data
  }
};
/**
 * 对于流操作，一系列异步操作有着关联，一个异步操作需要使用到上一个异步操作的结果
 */
function fetch() {
  return (
    fetchData()
    .then(value1 => {
      return fetchMoreData(value1)
    })
    .then(value2 => {
      return fetchMoreData2(value2)
    })
  )
}

async function fetch() {
  const value1 = await fetchData()
  const value2 = await fetchMoreData(value1)
  return fetchMoreData2(value2)
};

function fetch() {
  try {
    fetchData()
      .then(result => {
        const data = JSON.parse(result)
      })
      .catch((err) => {
        console.log(err)
      })
  } catch (err) {
    console.log(err)
  }
}

async function fetch() {
    try {
        const data = JSON.parse(await fetchData())
    } catch(err) {
        console.log(err)
    }
}

(async () => {
  const getList = await getList();
  const getAnotherList = await getAnotherList();
})();

(async () => {
    const listPromise = getList()
    const anotherListPromise = getAnotherList()
    await listPromise
    await anotherListPromise
})()

(async () => {
    Promise.all([getList(), getAnoterList()]).then()
})()

(async () => {
  const listPromise = await getList();
  const anotherListPromise = await getAnotherList();

  // do something

  await submit(listData);
  await submit(anotherListData);

})();

async function handleList() {
  const listPromise = await getList();
  // ...
  await submit(listData);
}

async function handleAnotherList() {
  const anotherListPromise = await getAnotherList()
  // ...
  await submit(anotherListData)
}

async function handleList() {
  const listPromise = await getList();
  // ...
  await submit(listData);
}

async function handleAnotherList() {
  const anotherListPromise = await getAnotherList()
  // ...
  await submit(anotherListData)
}

// 方法一
(async () => {
  const handleListPromise = handleList()
  const handleAnotherListPromise = handleAnotherList()
  await handleListPromise
  await handleAnotherListPromise
})()

// 方法二
(async () => {
  Promise.all([handleList(), handleAnotherList()]).then()
})()

// 继发一
async function loadData() {
    const res1 = await fetch(url1)
    const res2 = await fetch(url2)
    const res3 = await fetch(url3)
    return 'done'
}

// 继发二
async function loadData(urls) {
  for (const url of urls) {
    const response = await fetch(url);
    console.log(await response.text());
  }
}

// 并发一
async function loadData() {
  var res = await Promise.all([fetch(url1), fetch(url2), fetch(url3)]);
  return "whew all done";
}
// 并发二
async function loadData(urls) {
  // 并发读取 url
  const textPromises = urls.map(async url => {
    const response = await fetch(url);
    return response.text();
  });

  // 按次序输出
  for (const textPromise of textPromises) {
    console.log(await textPromise);
  }
}

async function asyncTask(cb) {
    try {
       const user = await UserModel.findById(1);
       if(!user) return cb('No user found');
    } catch(e) {
        return cb('Unexpected error occurred');
    }

    try {
       const savedTask = await TaskModel({userId: user.id, name: 'Demo Task'});
    } catch(e) {
        return cb('Error occurred while saving task');
    }

    if(user.notificationsEnabled) {
        try {
            await NotificationService.sendNotification(user.id, 'Task Created');
        } catch(e) {
            return cb('Error while sending notification');
        }
    }

    if(savedTask.assignedUser.id !== user.id) {
        try {
            await NotificationService.sendNotification(savedTask.assignedUser.id, 'Task was created for you');
        } catch(e) {
            return cb('Error while sending notification');
        }
    }

    cb(null, savedTask);
}

// to.js
export default function to(promise) {
   return promise.then(data => {
      return [null, data];
   })
   .catch(err => [err]);
}

import to from './to.js';

async function asyncTask() {
     let err, user, savedTask;

     [err, user] = await to(UserModel.findById(1));
     if(!user) throw new CustomerError('No user found');

     [err, savedTask] = await to(TaskModel({userId: user.id, name: 'Demo Task'}));
     if(err) throw new CustomError('Error occurred while saving task');

    if(user.notificationsEnabled) {
       const [err] = await to(NotificationService.sendNotification(user.id, 'Task Created'));
       if (err) console.error('Just log the error and continue flow');
    }
}

//  暴力法：每一行的检测，每一列的检测，9个小块检测 map 
var isValidSudoku = function(board) {
    let cols = {}
    let rows = {}
    let boxes = {}

    for(let i=0; i<9; i++) {
        for(let j=0; j<9; j++) {
            
            let num = board[i][j]
            if(num != '.') {
                let boxIndex = parseInt(i/3)*3 + parseInt(j/3)
                if(cols[j+'-'+num] || rows[i+'-'+num] || boxes[boxIndex+'-'+num]) {
                    return false
                }
                cols[j+'-'+num] = true
                rows[i+'-'+num] = true
                boxes[boxIndex+'-'+num] = true
            }
        }
    }

    return true
};

var solveSudoku = function(board) {
    if(board.length == 0 || board == null) return
    dfs(board)
};

var dfs = function(board) {
    for(let i=0; i<9; i++) {
        for(let j=0; j<9; j++) {
            if(board[i][j] == '.') {
                for(let c=1; c<=9; c++) {
                    if(isValidSudoku(board, i, j, c)) {
                        board[i][j] = `${c}`                            
                        if(dfs(board)) {
                            return true
                        }
                        board[i][j] = '.'
                    }
                }

                return false            
            }
        }
    }
    return true
}

var isValidSudoku = function(board, row, col, c) {
    for(let i=0; i<9; i++) {
        if(board[i][col] != '.' && board[i][col] == c) return false
        if(board[row][i] != '.' && board[row][i] == c) return false
        let x = parseInt(row/3) * 3 + parseInt(i/3)
        let y = parseInt(col/3) * 3 + i%3
        if(board[x][y] != '.' && board[x][y] == c) return false
    }
    return true
};

var ladderLength = function(beginWord, endWord, wordList) {
    if(!beginWord || !endWord || wordList.indexOf(endWord) == -1) return 0

    // 对wordlist预处理
    let commonDict = {}
    let len = beginWord.length
    for(let i=0; i<wordList.length; i++) {
        for(let r=0; r<len; r++) {
            // let comState = wordList[i].substring(0,r)+'*'+wordList[i].substring(r+1,len);
            let comState = wordList[i].substring(0,r)+'*'+wordList[i].substring(r+1,len);
            (!commonDict[comState]) && (commonDict[comState] = [])
            commonDict[comState].push(wordList[i])
        }
    }

    // queue for bfs
    let queue = [[beginWord, 1]]
    // visted
    let visted = {beginWord: true}
    while(queue.length > 0) {
        let currNode = queue.shift()
        let currWord = currNode[0]
        let currLevel = currNode[1]
        for(let i=0; i<len; i++) {
            let comState = currWord.substring(0, i) + '*' + currWord.substring(i+1, len)
            if(comState in commonDict) {
                let temp = commonDict[comState]
                for(let j=0; j<temp.length; j++) {
                    if(temp[j] == endWord) {
                        return currLevel + 1
                    }
                    if(!visted[temp[j]]) {
                        visted[temp[j]] = true
                        queue.push([temp[j], currLevel+1])
                    }
                }
            }
        }
    }
    return 0
};

// 相对之前的单向bfs，终结条件变成两端访问过同一个结点
var ladderLength = function(beginWord, endWord, wordList) {
    let wordListSet = new Set(wordList)
    if(!wordListSet.has(endWord)) return 0
    let beginSet = new Set()
    beginSet.add(beginWord)
    let endSet = new Set()
    endSet.add(endWord)
    let level = 1
    // bfs
    while(beginSet.size > 0) {
        let nextBeginSet = new Set()
        for(let key of beginSet) {
            for(let i=0; i<key.length; i++) {
                for(let j=0; j<26; j++) {
                    let s = String.fromCharCode(97+j)
                    if(key[i] != s) {
                        let newWord = key.slice(0, i) + s + key.slice(i+1)
                        if(endSet.has(newWord)) {
                            return level + 1
                        }
                        if(wordListSet.has(newWord)) {
                            nextBeginSet.add(newWord)
                            wordListSet.delete(newWord)
                        }
                    }
                }
            }
        }
        beginSet = nextBeginSet
        level++
        // 做一个交换，让size小的端先进行扩散
        if(beginSet.size > endSet.size) {
            [beginSet, endSet] = [endSet, beginSet]
        }
    }
    return 0
};

function throttle(func, wait) {
    var context, args
    var pre = 0
    return function() {
        var now = +new Date()
        args = arguments
        context = this
        if(now-pre >= wait) {
            func.apply(context, args)
            pre = now
        }
    }
}

function throttle(func, wait) {
    var context, args
    var timeout
    return function() {
        context = this
        args = arguments
        if(!timeout) {
            timeout = setTimeout(function(){
                func.apply(context, args)
                timeout=null
            }, wait)
        }
    }
}

function throttle(func, wait) {
    var timeout, context, args
    var pre = 0
    var timer = function () {
        pre = +new Date()
        func.apply(context, args)
        timeout = null
    }
    var main = function () {
        var now = +new Date()
        var rest = wait - (now - pre)
        context = this
        args = arguments
        // 如果没有剩余的时间了或者你改了系统时间
        if (rest <= 0 || rest > wait) {
            // 清除定时器
            if (timeout) {
                clearTimeout(timeout);
                timeout = null;
            }
            pre = now
            func.apply(context, args)
        } else if (!timeout) {
            timeout = setTimeout(timer, rest)
        }
    }
    return main
}

function throttle(func, wait, options) {
    var timeout, context, args
    var pre = 0
    if(!options) options={}
    var timer = function () {
        pre = +new Date()
        func.apply(context, args)
        timeout = null
        if (!timeout) context = args = null;
    }
    var main = function () {
        var now = +new Date()
        if(!pre && options.leading === false) pre = now
        var rest = wait - (now - pre)
        context = this
        args = arguments
        // 如果没有剩余的时间了或者你改了系统时间
        if (rest <= 0 || rest > wait) {
            // 清除定时器
            if (timeout) {
                clearTimeout(timeout);
                timeout = null;
            }
            pre = now
            func.apply(context, args)
            if (!timeout) context = args = null;
        } else if (!timeout && options.trailing !== false) {
            timeout = setTimeout(timer, rest)
        }
    }
    return main
}

main.cancel = function() {
    clearTimeout(timeout);
    pre = 0;
    timeout = null;
}

// 例子1
var value = 1
function foo (v) {
    v = 2
    console.log(v)
}
foo(value) // 2
console.log(value) // 1

// 例子2
var obj = {
    value: 1
};
function foo(o) {
    o.value = 2;
    console.log(o.value); //2
}
foo(obj);
console.log(obj.value) // 2

// 例子3
var obj = {
    value: 1
};
function foo(o) {
    o = 2;
    console.log(o); //2
}
foo(obj);
console.log(obj.value) // 1

// 思路：用两个栈，一个栈维护进栈的元素，另一个维护出栈的元素
var CQueue = function() {
    this.stackIn = []
    this.stackOut = []
};


CQueue.prototype.appendTail = function(value) {
    this.stackIn.push(value)
};

CQueue.prototype.deleteHead = function() {
    const {stackIn, stackOut} = this
    if(stackOut.length) {
        return stackOut.pop()
    } else{
        while(stackIn.length) {
            stackOut.push(stackIn.pop())
        }
        return stackOut.pop() || -1
    }
};

<!DOCTYPE html>
<html lang="zh-cmn-Hans">

<head>
    <meta charset="utf-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge, chrome=1">
    <title>debounce</title>
    <style>
        #container {
            width: 100%;
            height: 200px;
            line-height: 200px;
            text-align: center;
            color: #fff;
            background-color: #444;
            font-size: 30px;
        }
    </style>
</head>

<body>
    <div id="container"></div>
    <script>
        var count = 1;
        var container = document.getElementById('container');

        function getUserAction() {
            container.innerHTML = count++;
        };

        container.onmousemove = getUserAction;
    </script>
</body>

</html>

function debounce(func, wait, immediate) {

    var timeout, result;

    var debounced = function () {
        var context = this;
        var args = arguments;

        if (timeout) clearTimeout(timeout);
        if (immediate) {
            // 如果已经执行过，不再执行
            var callNow = !timeout;
            timeout = setTimeout(function(){
                timeout = null;
            }, wait)
            if (callNow) result = func.apply(context, args)
        }
        else {
            timeout = setTimeout(function(){
                func.apply(context, args)
            }, wait);
        }
        return result;
    };

    debounced.cancel = function() {
        clearTimeout(timeout);
        timeout = null;
    };

    return debounced;
}

## bitarray 一个bit数组
from bitarray import bitarray
## python3 用来hash算法的库
import mmh3


class BloomFilter:
    def __init__(self, size, hash_num):
        self.size = size
        self.hash_num = hash_num
        self.bit_array = bitarray(size)
        self.bit_array.setall(0)

    def add(self, s):
        for seed in range(self.hash_num):
            ## 取模，避免index溢出bit_array的下标长度
            index = mmh3.hash(s, seed) % self.size
            self.bit_array[index] = 1

    def lookup(self, s):
        for seed in range(self.hash_num):
            index = mmh3.hash(s, seed) % self.size
            if self.bit_array[index] == 0:
                return "Nope"
        return "Probably"


if __name__ == "__main__":
    bf = BloomFilter(500000, 7)
    bf.add("zero")
    print(bf.lookup("zero"))
    print(bf.lookup("two"))

let a = []
a['0'] = 1
a[0] // 1
a['0'] // 1

// 等价于
let a = {
    '0' : 1
}

// js中对象的key会被转换成string存储，尽管是number类型

let arr = [1, 2]
arr.length = 5
console.log(arr) [1, 2, empty x 3]

console.log(typeof arr[3]); // undefined
arr[3] === undefined // true

arr.indexOf(undefined) // -1
arr.filter(item => item===undefined) // []

arr.forEach(item=>{
    console.log(item)
}) // 1 , 2

arr.map(item => {
    console.log(item)
})
// map会保留empty

let a = [1, 2] // PACKED_SMI_ELEMENTS
a.length = 5 // HOLEY_SMI_ELEMENTS

const a = Symbol('a')
typeof a // symbol

const a = Symbol('a')
a instanceof Symbol // false

const a = Symbol('a')
console.log(a) // Symbol(a)

const obj = {
  toString() {
    return 'abc';
  }
};
const sym = Symbol(obj);
console.log(sym); // Symbol(abc)

var a1 = Symbol()
var a2 = Symbol()
console.log(a1===a2) // flase

var b1 = Symbol('tom') 
var b2 = Symbol('tom') 
console.log(b1===b2) // flase

var b1 = Symbol('tom') 
b1 + 'as' // Uncaught TypeError: Cannot convert a Symbol value to a string

var b1 = Symbol('tom') 
console.log(String(b1)) // Symbol(tom)
console.log(b1.toString()) // Symbol(tom)

var objName = Symbol()

// 第一种写法
var obj1 = {}
obj1[objName] = 'tom'

// 第二种写法
var obj2 = {
    [objName]: 'tom'
}

// 访问这个属性
console.log(obj[objName]) // 'tom'

var mySymbol = Symbol('address')
var o = {name: 'tom'}
o[mySymbol] = '安阳路'

for(const i in o) {
    console.log(i)
} // name

var objectSymbols = Object.getOwnPropertySymbols(o) // [Symbol(address)]

var s1 = Symbol.for('address')
var s2 = Symbol.for('address')

console.log(s1 === s2) // true

var globalSym = Symbol.for('foo')
console.log(Symbol.keyFor(globalSym)) // foo

var localSym = Symbol()
console.log(Symbol.keyFor(localSym)) // undefined

const AGE = Symbol()
const GET_AGE = Symbol()
class User {
    constructor(name, sex, age) {
        this.name = name
        this.sex = sex
        this[AGE] = age
        this[GET_AGE] = function () {
            return this[AGE]
        }
    }
    printAge() {
        console.log(this[GET_AGE]())
    }

}
// test

let u1 = new User('xm', 'M', 18)
let u2 = new User('xh', 'W', 20)
console.log(u1.name) // xm
console.log(u1.age) // undefined
u1.printAge() // 18
console.log(u2.name) // xh
console.log(u2.age) // undefined
u2.printAge() // 20

// Phone.js
class Phone {
    constructor() {
        this.name = '小米'
        this.price = '1999'
    }
}

let key = Symbol.for('Phone')

if (!global[key]) {
    global[key] = new Phone()
}

module.exports = global[key]

// test.js
let p1 = require('./Phone')
let p2 = require('./Phone')
console.log(p1 === p2) // true

var a = 1
function foo() {
    console.log(a)
}
function bar() {
    var a = 2
    foo()
}
bar()
// reuslt a = 1

let s = new Set()

let s_arr = new Set([1,2,3])
console.log(s_arr) // Set(3) {1, 2, 3}

let map = new Map()
Map.set('name','tom')
let s_map = new Set(map)
console.log(s_map) // Set(1) {Array(2)}

let s_arr = new Set([1, 2, 3])
s_arr.forEach( (key, value) => {console.log(key, value)}) // forEach不会改变原Set

let set = new Set();
let a = NaN;
let b = NaN;
set.add(a);
set.add(b);
set // Set {NaN}

console.log(NaN === NaN) // false

let set = new Set();
set.add({});
set.size // 1
set.add({});
set.size // 2

比较下面两段代码，试述两段代码的不同之处
// A--------------------------
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f();
}
checkscope();

// B---------------------------
var scope = "global scope";
function checkscope(){
    var scope = "local scope";
    function f(){
        return scope;
    }
    return f;
}
checkscope()();

Estack = {
    globalContext
}

globalContext = {
    VO: global,
    Scope: [globalContext.Vo],
    this: globalContext.Vo
}

checkscope.[[Scope]] = {
    globalContext.Vo
}

Estack = {
    checkscopeContext,
    globalContext
}

checkscopeContext = {
    VO: {
        arguments: {
            length: 0
        },
        scope: undefined,
        f: reference to function f(){}
    },
    Scope: [VO, globalContext.Vo]
}

f.[[Scope]] = {
    chechscopeContext.VO,
    globalContext.VO
}

Estack = {
    globalContext
}

Estack = {
    fContext,
    globalContext
}

fContext = {
    VO: {
        arguments: {
            length: 0
        }
    },
    Scope: [VO, chechscopeContext.VO, globalContext.VO]
}

Estack = {
    globalContext
}

var myString = "abbdef"; 
myString[2] = 'c'
console.log(myString) // abbdef

// ACSLL+遍历：a-z:[97,122] A-Z：[65,90]
var toLowerCase = function(str) {
    let res = ''
    for(const i of str) {
        if(i>='A' && i<='Z') {
            res+=String.fromCharCode(i.charCodeAt()+32)
        } else{
            res+=i
        }
    }
    return res
};

var lengthOfLastWord = function(s) {
    let end = s.length-1
    while(end>=0 && s[end]==' ') end--
    let start = end
    while(start>=0 && s[start]!=' ') start--
    return end-start
};

var numJewelsInStones = function(J, S) {
    const set = new Set();
    for(const s of J) {
        set.add(s);
    }
    let ans = 0;
    for(const s of S) {
        if(set.has(s)){
            ans++;
        }
    }
    return ans;
};

var firstUniqChar = function(s) {
    let a = Array(26).fill(0)

    for(const i of s) {
        a[i.charCodeAt()-97]++
    }
    for(let j=0; j<s.length; j++) {
        if(a[s[j].charCodeAt()-97]==1) {
            return j
        }
    }
    return -1
};

var myAtoi = function(s) {
    // sign：符号位，total：绝对值，flag：排除多个正负号情况
    let index = 0, sign = 1,  total = 0, flag=0
    // 空字符
    if(s.length == 0) return 0 
    
    // 移除空字符，trim会产生新的字符串，使用额外的内存
    while(s[index] == ' ' && index < s.length) {
        index++
    }

    // 处理正负号
    while(s[index] == '+' || s[index] == '-') {
        sign = s[index] == '+' ? 1 : -1
        flag++
        index++
    }

    // 找出数字部分
    while(index < s.length) {
        let digit = s[index].charCodeAt() - '0'.charCodeAt()
        if(digit > 9 || digit < 0) break
        total = total*10 + digit
        index++
        // 检测total是否大于题目给的整数范围
        if(total>=Math.pow(2,31)) {
            return sign==1 ? Math.pow(2,31)-1 : -1*Math.pow(2, 31)
        }
    }

    return flag > 1 ? 0 : sign*total 
};

/**
* @param {string} a
* @param {string} b
* @return {number} 
*/
function forceSearch(a, b) {
    // a：待字符串 b：需要匹配的字符串
    let m = a.length
    let n = b.length
    for(let i=0; i<m; i++) {
        let j = 0
        for(j; j<n; j++) {
            if(a.charCodeAt(i+j) != b.charCodeAt(j)) {
                break
            }
        }
        // 在a中匹配到b
        if(j==n) {
            return i
        }
    }
    return -1
}

function RabinKarpSearch(a, b) {
    // a：待字符串 b：需要匹配的字符串
    let m = a.length
    let n = b.length
    // 定义哈希值,因为字符是256进制 d=256; q是为了避免每次乘256数值过大，模一个大的素数
    let d = 256
    let q = 9997
    let aHash = 0, bHash = 0
    let i,j
    // 初始化匹配字符串和待匹配字符串的哈希值
    for(i=0; i<n; i++) {
        aHash = (d*aHash + a.charCodeAt(i)) % q
        bHash = (d*bHash + b.charCodeAt(i)) % q
    }
    // 计算出最高位的幂次数
    let highestPow = 1
    for(i=0; i<n-1; i++) {
        highestPow = (d*highestPow) % q
    }

    for(i=0; i<m-n+1; i++) {
        if(aHash==bHash) {
            for(j=0; j<n; j++) {
                if(a.charCodeAt(i+j) != b.charCodeAt(j)) {
                    break
                }
                if(j==n) {
                    return i
                }
            }
        }
        // 如果两个hash值不相等，利用滑动窗口**，让之前高位移除，把下一个字符的asccl加入到aHash中,整个hash移动的过程是O(1)的复杂度
        if(i<n-m) {
            aHash = (d*( aHash - highestPow*a.charCodeAt(i) ) + b.charCodeAt(i+n) )% q
            if(aHash<0) {
                aHash+=q
            }
        }
    }

    return -1
}

function fun(){
    console.log(this)
}
fun()
// Window

var a = 2
var obj = {
    foo: function () {console.log(this.a)},
    a:1
}
obj.foo()
// a = 1

var a = 2
var obj = {
    foo: (function () {
        console.log(this.a)
        })(),
    a:1
}
obj.foo