// 定义产品
class Product {
    constructor(name) {
        this.name = name
    }
    init() {
        console.log('初始化产品')
    }
}

// 定义工厂
class Factory {
    create(name) {
        return new Product(name) // 重点!!!
    }
}
let c = new Factory()
let p = c.create('p1')
p.init()

//User类
class User {
  constructor(opt) {
    this.name = opt.name;
    this.viewPage = opt.viewPage;
  }

  static getInstance(role) {
    switch (role) {
      case 'superAdmin':
        return new User({ name: '超级管理员', viewPage: ['首页', '通讯录', '发现页', '应用数据', '权限管理'] });
        break;
      case 'admin':
        return new User({ name: '管理员', viewPage: ['首页', '通讯录'] });
        break;
      default:
        throw new Error('params error')
    }
  }
}

//调用
let superAdmin = user.getInstance('superAdmin');
let admin = user.getInstance('admin');

class User {
  constructor(name = '', viewPage = []) {
    this.name = name;
    this.viewPage = viewPage;
  }
}

class UserFactory extends User {
  constructor(name, viewPage) {
    super(name, viewPage)
  }
  create(role) {
    switch (role) {
      case 'superAdmin': 
        return new UserFactory( '超级管理员', ['首页', '通讯录', '发现页', '应用数据', '权限管理'] );
        break;
      case 'admin':
        return new UserFactory( '管理员', ['首页', '通讯录'] );
        break;
      default:
        throw new Error('params error');
    }
  }
}
let userFactory = new UserFactory();
let superAdmin = userFactory.create('superAdmin');
let admin = userFactory.create('admin');
let user = userFactory.create('user');

class jQuery {
    constructor(selector) {
        super(selector)
    }
    // ...
}

window.$ = function(selector) {
    return new jQuery(selector)
}

Vue.component('async-example' , (resolve , reject) => {
    setTimeout(function() {
        resolve({
            template: `<div>I am async!</div>`
        })
    }, 1000)
})

const singleton = function(name) {
  this.name = name
  this.instance = null
}

singleton.getInstance = function(name) {
  if (!this.instance) { // 创建过一次就能再次创建了
    this.instance = new singleton(name)
  }
  return this.instance
}

// 只能创建一遍
const a = singleton.getInstance('a') // 通过 getInstance 来获取实例
const b = singleton.getInstance('b')
console.log(a === b) //true 

var obj = {}

const createLayer = function() {
  const div = document.createElement('div')
  div.innerHTML = '我出现了'
  div.style.display = 'none'
  document.body.appendChild(div)
  return div
}

const getSingle = function(fn) {
  const result
  return function() {
    return result || result = fn.apply(this, arguments)
  }
}
//创建一次，可多次调用
const createSingleLayer = getSingle(createLayer)

document.getElementById('Btn').onclick = function() {
  createSingleLayer()
}

const setCommand = function(button, command) {
  button.onClick = function() {
    command.excute()
  }
}

// 上面的界面逻辑由A完成, 下面的由B完成

// 对象中含有多个命令
const menu = {
  updateMenu: function() {
    console.log('更新菜单')
  },
  addMenu：fuction() {
  	 console.log('增加菜品')
  }
}
// 对不同命令进行解耦合
const UpdateCommand = function(receive) {
  return {
    excute: receive.updateMenu
  }
}
const AddCommand = function(receive) {
  return {
    excute: receive.addMenu
  }
}

const updateCommand = UpdateCommand(menu) // 创建命令
const addCommand = AddCommand(menu) // 创建命令

const button1 = document.getElementById('button1')
const button2 = document.getElementById('button2')

setCommand(button1, updateCommand)
setCommand(button2, addCommand)

MyHashSet hashSet = new MyHashSet();
hashSet.add(1);         
hashSet.add(2);         
hashSet.contains(1);    // 返回 true
hashSet.contains(3);    // 返回 false (未找到)
hashSet.add(2);          
hashSet.contains(2);    // 返回 true
hashSet.remove(2);          
hashSet.contains(2);    // 返回  false (已经被删除)
/**
 * Initialize your data structure here.
 */
var MyHashSet = function() {
    this.hash = {}
};

/** 
 * @param {number} key
 * @return {void}
 */
MyHashSet.prototype.add = function(key) {
    if(!this.hash[key]){
       this.hash[key] = true
    }
};

/** 
 * @param {number} key
 * @return {void}
 */
MyHashSet.prototype.remove = function(key) {
    if(this.hash[key]){
      delete(this.hash[key])
    }
};

/**
 * Returns true if this set contains the specified element 
 * @param {number} key
 * @return {boolean}
 */
MyHashSet.prototype.contains = function(key) {
    return !!this.hash[key]
};

/** 
 * Your MyHashSet object will be instantiated and called as such:
 * var obj = new MyHashSet()
 * obj.add(key)
 * obj.remove(key)
 * var param_3 = obj.contains(key)
 */

add(value)

delete(value)

has(value)

clear()

function Set() {
  this.items = {}
  this.size = 0
}

Set.prototype.add = function(value) {
  if (!this.items[value]) {
    this.items[value] = value // 这样子不能实现存储数组、对象
    this.size = Object.keys(this.items).length
  }
}

Set.prototype.has = function(value) {
  if (this.items.hasOwnProperty(value)) {
    return true
  } else {
    return false
  }
}

Set.prototype.delete = function(value) {
  for (let i in this.items) {
    if (this.items.hasOwnProperty(i)) {
      if (i === value.toString()) {
        delete(this.items[i])
        this.size = Object.keys(this.items).length
        return true
      }
    }
  }
}

Set.prototype.clear = function() {
  this.items = {}
  this.size = 0
}

let unique = (likeArr)=>{
	return Array.from(new Set(likeArr))
}

// 方法一
const set1 = new Set()
set.add(1)

// 方法二
const set2 = new Set([1])

function Map() {
  this.items = {}
  this.size = 0
}

Map.prototype.has = function(key) {
  for (let i in this.items) {
    if (this.items.hasOwnProperty(i)) {
      return true
    }
  }
  return false
}

Map.prototype.delete = function(key) {
  if (this.has(key)) {
    delete(this.items[key])
    this.size--
    return true
  }
  return false
}

Map.prototype.set = function(key, value) {
  this.items[key] = value // 这里是不严谨的实现
  this.size++
}

Map.prototype.get = function(key) {
  return this.items[key]
}

Map.prototype.clear = function() {
  this.items = {}
  this.size = 0
}

Map.prototype.values = function() {
  const arr = []
  Object.keys(this.items).forEach(r => {
    arr.push(this.items[r])
  })
  return arr
}

// 方式一
const map1 = new Map()
map.set('a', 1)

// 方式二
const map2 = new Map([['a', 1]])

// 老接口
const zhejiangCityOld = (function() {
  return [
    {
      name: 'hangzhou',
      id: 11,
    },
    {
      name: 'jinhua',
      id: 12
    }
  ]
}())

console.log(getZhejiangCityOld())

// 新接口希望是下面形式
{
  hangzhou: 11,
  jinhua: 12,
}

// 这时候就可采用适配者模式
const adaptor = (function(oldCity) {
  const obj = {}
  for (let city of zhejiangCityOld) {
    obj[city.name] = city.id
  }
  return obj
}())

typeof 37 //'number'

typeof NaN //'number'

typeof "bla" //'string'

typeof false //boolean

typeof Symbol('foo') //'symbol';

typeof undefind 
//"undefined"

typeof window // "object"

typeof {} // "object"

typeof [] // "object"

var o = {};
var a = [];

o instanceof Array // false
a instanceof Array // true

// 函数
typeof function(){} === 'function';
typeof class C{} === 'function'
typeof Math.sin === 'function';
typeof new Function() === 'function';

typeof null // "object"

function chris(){} 
function james(){} 

var o = new chris();

o instanceof chris; // true，因为 Object.getPrototypeOf(o) === chris.prototype

o instanceof james; // false，因为 james.prototype不在o的原型链上

o instanceof Object // true 原型链上也有Object

function chris(){} 
function james(){} 

var o = new chris();

o instanceof chris //true

chris.prototype = {};

o instanceof chris; // false,C.prototype指向了一个空对象,这个空对象不在o的原型链上.

var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(2); // [object Number]
toString.call([]); // [object Array]

toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]

var a = undefined;
// 或者
var a = null;

if (!undefined) {
console.log('undefined is false');
}
// undefined is false

if (!null) {
  console.log('null is false');
}
// null is false

undefined == null
// true

Number(null) // 0
5 + null // 5

Number(undefined) // NaN
5 + undefined // NaN

var i
function f(i = null){
	return i
}
f(i)//null

// 变量声明了，但没有赋值
var i;
i // undefined

// 调用函数时，应该提供的参数没有提供，该参数等于 undefined
function f(x) {
  return x;
}
f() // undefined

// 对象没有赋值的属性
var  o = new Object();
o.p // undefined

// 函数没有返回值时，默认返回 undefined
function f() {}
f() // undefined

function Stack() {
  this.items = []
}

Stack.prototype.push = function(item) {
  this.items.push(item)
}

Stack.prototype.pop = function() {
  return this.items.pop()
}

Stack.prototype.size = function() {
  return this.items.length
}

Stack.prototype.isEmpty = function() {
  return this.items.length === 0
}

Stack.prototype.clear = function() {
  this.items = []
}

测试用例:
{{([][])}()} => true
[{()] => false


function isBalance(symbol) {
  const stack = new Stack()
  const left = '{[('
  const right = '}])'
  let popValue
  let tag = true

  const match = function(popValue, current) {
    if (left.indexOf(popValue) !== right.indexOf(current)) {
      tag = false
    }
  }

  for (let i = 0; i < symbol.length; i++) {
    if (left.includes(symbol[i])) {
      stack.push(symbol[i])
    } else if (right.includes(symbol[i])) {
      popValue = stack.pop()
      match(popValue, symbol[i])
    }
  }
  return tag
}

/**
 * 利用栈先入后出的特性
 * @param {*} node 
 */
//递归
let DFS= (node, nodeList = []) => {
    if (node !== null) {
      nodeList.push(node)
      //获取父节点，拿到子节点
      let children = node.children
      for (let i = 0; i < children.length; i++) {
        //继续遍历
        DFS(children[i], nodeList)
      }
    }
    return nodeList
  }
//非递归
const DFS = (node) => {
    let stack = []
    let nodes = []
    if (node) {
      // 推入当前处理的node
      stack.push(node)
      while (stack.length) {
        let item = stack.pop()
        let children = item.children
        nodes.push(item)
        for (let i = children.length - 1; i >= 0; i--) {
          stack.push(children[i])
        }
      }
    }
    return nodes
  }

function Queue() {
  this.items = []
}

Queue.prototype.push = function(item) {
  this.items.push(item)
}

Queue.prototype.shift = function() {
  return this.items.shift()
}

Queue.prototype.isEmpty = function() {
  return this.items.length === 0
}

Queue.prototype.size = function() {
  return this.items.length
}

Queue.prototype.clear = function() {
  this.items = []
}

// 继承 Queue 类
const PriorityQueue = function () {
  Queue.apply(this)
}

PriorityQueue.prototype = Object.create(Queue.prototype)

PriorityQueue.prototype.constructor = PriorityQueue

// 修改 push 方法
PriorityQueue.prototype.push = function(item, level) {
  if (this.isEmpty()) {
    this.items.push({ item, level })
  } else {
    let add = true
    for (let i = 0; i < this.size(); i++) {
      if (level < this.items[i].level) {
        add = false
        this.items.splice(i, 0, { item, level })
        return
      }
    }
    add && this.items.push({ item, level })
  }
}

PriorityQueue.prototype.print = function() {
  for (let obj of this.items) {
    console.log(obj.item)
  }
}
// 调用
const queue = new PriorityQueue()
queue.push('张三', 2)
queue.push('李四', 1)
queue.push('赵五', 1)
queue.print() // 李四 赵五 张三

const drumGame = function(names, number) {
  const queue = new Queue()
  for (let i = 0; i < names.length; i++) {
    queue.push(names[i])
  }

  while (queue.size() > 1) {
    for (let i = 0; i < number; i++) {
      queue.push(queue.shift())  // 这句是循环队列的核心
    }
    const loser = queue.shift()
    console.log(loser + ' 出局')
  }
  return queue.shift()           // 留下的最后一个就是胜利者
}

const names = ['John', 'Jack', 'Camila', 'Ingrid', 'Carl']
const winner = drumGame(names, 7) // 假设每轮传花 7 次
console.log('胜利者是: ' + winner)

// Camila 出局
// Jack 出局
// Carl 出局
// Ingrid 出局
// 胜利者是: John

/**
 * 利用队列先入先出的特性。
 * @param {*} node 
 */
const BFS = (node) => {
    // 记录节点
    let nodes = []
    // 执行队列
    let queue = []
    if (node) {
      queue.push(node)
      while (stack.length) {
        // 首部先出
        let item = queue.shift()
        // 获得子节点
        let children = item.children
        // 父节点任务完成
        nodes.push(item)
        //把子节点压入执行栈中，重复操作，知道执行栈执行结束
        for (let i = 0; i < children.length; i++) {
          queue.push(children[i])
        }
      }
    }
    return nodes
  }

// 将状态封装成不同类
const weakLight = function(light) {
  this.light = light
}

weakLight.prototype.press = function() {
  console.log('打开强光')
  this.light.setState(this.light.strongLight)
}

const strongLight = function(light) {
  this.light = light
}

strongLight.prototype.press = function() {
  console.log('关灯')
  this.light.setState(this.light.offLight)
}

const offLight = function(light) {
  this.light = light
}

offLight.prototype.press = function() {
  console.log('打开弱光')
  this.light.setState(this.light.weakLight)
}

const Light = function() {
  this.weakLight = new weakLight(this)
  this.strongLight = new strongLight(this)
  this.offLight = new offLight(this)
  this.currentState = this.offLight          // 初始状态
}

Light.prototype.init = function() {
  const btn = document.createElement('button')
  btn.innerHTML = '按钮'
  document.body.append(btn)
  const self = this
  btn.addEventListener('click', function() {
    self.currentState.press()
  })
}

Light.prototype.setState = function(state) { // 改变内部状态
  this.currentState = state
}

const light = new Light()
light.init()

// 打开弱光
// 打开强光
// 关灯

const obj = {
  'weakLight': {
    press: function() {
      console.log('打开强光')
      this.currentState = obj.strongLight
    }
  },
  'strongLight': {
    press: function() {
      console.log('关灯')
      this.currentState = obj.offLight
    }
  },
  'offLight': {
    press: function() {
      console.log('打开弱光')
      this.currentState = obj.weakLight
    }
  },
}

const Light = function() {
  this.currentState = obj.offLight
}

Light.prototype.init = function() {
  const btn = document.createElement('button')
  btn.innerHTML = '按钮'
  document.body.append(btn)
  const self = this
  btn.addEventListener('click', function() {
    self.currentState.press.call(self) // 通过 call 完成委托
  })
}

const light = new Light()
light.init()

var foo = {
    value: 1
};

function bar() {
    console.log(this.value);
}

bar.call(foo); // 1

var foo = {
    value: 1,
    bar: function() {
        console.log(this.value)
    }
};

foo.bar(); // 1

// 第一步
foo.fn = bar
// 第二步
foo.fn()
// 第三步
delete foo.fn

Function.prototype._call = function(context) {
    // 首先要获取调用call的函数，用this可以获取
    context.fn = this;
    context.fn();
    delete context.fn;
}

// 测试一下
var foo = {
    value: 1
};

function bar() {
    console.log(this.value);
}

bar._call(foo); // 1

var foo = {
    value: 1
};

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

bar.call(foo, 'chris', 10);
// chris
// 10
// 1

// 以上个例子为例，此时的arguments为：
// arguments = {
//      0: foo,
//      1: 'kevin',
//      2: 18,
//      length: 3
// }
// 因为arguments是类数组对象，所以可以用for循环
var args = [];
vae len = arguments.length
for(var i = 1,  i < len; i++) {
    args.push('arguments[' + i + ']');
}

// 执行后 args为 ["arguments[1]", "arguments[2]", "arguments[3]"]

eval('context.fn(' + args +')')

Function.prototype._call = function(context) {
    context.fn = this;
    var args = [];
    for(var i = 1, len = arguments.length; i < len; i++) {
        args.push('arguments[' + i + ']');
    }
    eval('context.fn(' + args +')');
    delete context.fn;
}

// 测试一下
var foo = {
    value: 1
};

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

bar._call(foo, 'chris', 10); 
// chris
// 10
// 1

var value = 1;

function bar() {
    console.log(this.value);
}

bar.call(null); // 1

var obj = {
    value: 1
}

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

bar.call(obj, 'chris', 10)
// Object {
//    value: 1,
//    name: 'chris',
//    age: 10
// }

Function.prototype._call = function (context = window) {
    var context = context;
    context.fn = this;

    var args = [];
    for(var i = 1, len = arguments.length; i < len; i++) {
        args.push('arguments[' + i + ']');
    }

    var result = eval('context.fn(' + args +')');

    delete context.fn
    return result;
}

// 测试一下
var value = 2;

var obj = {
    value: 1
}

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

bar._call(null); // 2

console.log(bar._call(obj, 'kevin', 18));
// 1
// Object {
//    value: 1,
//    name: 'kevin',
//    age: 18
// }

Function.prototype.apply = function (context = window, arr) {
    var context = context;
    context.fn = this;

    var result;
    if (!arr) {
        result = context.fn();
    }
    else {
        var args = [];
        for (var i = 0, len = arr.length; i < len; i++) {
            args.push('arr[' + i + ']');
        }
        result = eval('context.fn(' + args + ')')
    }

    delete context.fn
    return result;
}

var foo = {
    value: 1
};

function bar() {
    console.log(this.value);
}

var bindFoo = bar.bind(foo); // 返回了一个函数

bindFoo(); // 1

Function.prototype._bind = function (context) {
    var self = this;
    return function () {
        return self.apply(context);
    }
}

var foo = {
    value: 1
};

function bar() {
	return this.value;
}

var bindFoo = bar.bind(foo);

console.log(bindFoo()); // 1

var foo = {
    value: 1
};

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

var bindFoo = bar.bind(foo, 'chris');
bindFoo('18');
// 1
// chris
// 18

Function.prototype._bind = function (context) {
    var self = this;
    // 获取_bind函数从第二个参数到最后一个参数
    var args = Array.prototype.slice.call(arguments, 1);

    return function () {
        // 这个时候的arguments是指bind返回的函数传入的参数
        var bindArgs = Array.prototype.slice.call(arguments);
        return self.apply(context, args.concat(bindArgs));
    }
}

var value = 2;

var foo = {
    value: 1
};

function bar(name, age) {
    this.habit = 'shopping';
    console.log(this.value);
    console.log(name);
    console.log(age);
}

bar.prototype.friend = 'james';

var bindFoo = bar.bind(foo, 'chris');

var obj = new bindFoo('18');
// undefined
// chris
// 18
console.log(obj.habit);
console.log(obj.friend);
// shopping
// james

Function.prototype.bind2 = function (context) {
    var self = this;
    var args = Array.prototype.slice.call(arguments, 1);

    var fBound = function () {
        var bindArgs = Array.prototype.slice.call(arguments);
        // 当作为构造函数时，this 指向实例，此时结果为 true，将绑定函数的 this 指向该实例，可以让实例获得来自绑定函数的值
        // 以上面的是 demo 为例，如果改成 `this instanceof fBound ? null : context`，实例只是一个空对象，将 null 改成 this ，实例会具有 habit 属性
        // 当作为普通函数时，this 指向 window，此时结果为 false，将绑定函数的 this 指向 context
        return self.apply(this instanceof fBound ? this : context, args.concat(bindArgs));
    }
    // 修改返回函数的 prototype 为绑定函数的 prototype，实例就可以继承绑定函数的原型中的值
    fBound.prototype = this.prototype;
    return fBound;
}

Function.prototype._bind = function (context) {

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

    var fNOP = function () {};

    var fBound = function () {
        var bindArgs = Array.prototype.slice.call(arguments);
        return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
    }

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();
    return fBound;
}

if (typeof this !== "function") {
  throw new Error("Function.prototype.bind - what is trying to be bound is not callable");
}

Function.prototype.bind = Function.prototype.bind || function () {
    ……
};

Function.prototype._bind = function (context) {

    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 fNOP = function () {};

    var fBound = function () {
        var bindArgs = Array.prototype.slice.call(arguments);
        return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
    }

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();
    return fBound;
}

var x = 2;
var y = 39;
function add(x,y){
	return x + y
}
eval('add('+ ['x','y'] + ')')//等于add(x,y)

const Drinks = function() {}

Drinks.prototype.firstStep = function() {
  console.log('烧开水')
}

Drinks.prototype.secondStep = function() {}

Drinks.prototype.thirdStep = function() {
  console.log('倒入杯子')
}

Drinks.prototype.fourthStep = function() {}

Drinks.prototype.init = function() { // 模板方法模式核心: 在父类上定义好执行算法
  this.firstStep()
  this.secondStep()
  this.thirdStep()
  this.fourthStep()
}

const Tea = function() {}

Tea.prototype = new Drinks

Tea.prototype.secondStep = function() {
  console.log('浸泡茶叶')
}

Tea.prototype.fourthStep = function() {
  console.log('加柠檬')
}

const Coffee = function() {}

Coffee.prototype = new Drinks

Coffee.prototype.secondStep = function() {
  console.log('冲泡咖啡')
}

Coffee.prototype.fourthStep = function() {
  console.log('加糖')
}

const tea = new Tea()
tea.init()

// 烧开水
// 浸泡茶叶
// 倒入杯子
// 加柠檬

const coffee = new Coffee()
coffee.init()

// 烧开水
// 冲泡咖啡
// 倒入杯子
// 加糖

Drinks.prototype.ifNeedFlavour = function() { // 加上钩子
  return true
}

Drinks.prototype.init = function() { // 模板方法模式核心: 在父类上定义好执行算法
  this.firstStep()
  this.secondStep()
  this.thirdStep()
  if (this.ifNeedFlavour()) { // 默认是 true, 也就是要加调料
    this.fourthStep()
  }
}

// ...
const Coffee = function() {}

Coffee.prototype = new Drinks()
// ...

Coffee.prototype.ifNeedFlavour = function() {
  return window.confirm('是否需要佐料吗？') // 弹框选择是否佐料
}

7，0，1，2，0，3，0，4，2，3，0，3，2，1，2，0，1，7，0，1

function Parent () {
    this.name = 'chris';
}

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

function Child () {

}

Child.prototype = new Parent();

var child = new Child();

console.log(child.getName()) // chris

function Parent () {
    this.names = ['chris', 'daisy'];
}

function Child () {

}

Child.prototype = new Parent();

var child1 = new Child();

child1.names.push('james');

console.log(child1.names); // ["chris", "daisy", "james"]

var child2 = new Child();

console.log(child2.names); // ["chris", "daisy", "james"]

function Parent () {
    this.names = ['chris', 'daisy'];
}

function Child () {
    Parent.call(this);
}

var child1 = new Child();

child1.names.push('james');

console.log(child1.names); // ["chris", "daisy", "yayu"]

var child2 = new Child();

console.log(child2.names); // ["chris", "daisy"]

function Parent (name) {
    this.name = name;
}

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

var child1 = new Child('chris');

console.log(child1.name); // chris

var child2 = new Child('daisy');

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

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;

}

Child.prototype = new Parent();
Child.prototype.constructor = Child;

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

child1.colors.push('black');

console.log(child1.name); // chris
console.log(child1.age); // 18
console.log(child1.colors); // ["red", "blue", "green", "black"]

var child2 = new Child('james', '20');

console.log(child2.name); // james
console.log(child2.age); // 20
console.log(child2.colors); // ["red", "blue", "green"]

var person = {
    name: 'chris',
    friends: ['daisy', 'james']
}

var person1 = Object.create(person);
var person2 = Object.create(person);

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

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

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

function createObj (o) {
    var clone = Object.create(o);
    clone.sayName = function () {
        console.log('hi');
    }
    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;
}

Child.prototype = new Parent();

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

console.log(child1)

Child.prototype = new Parent();

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

Parent.call(this, name);

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;
}

// 关键的三步，只获取prototype,不再调用构造函数
var F = function () {};

F.prototype = Parent.prototype;

Child.prototype = new F();


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

console.log(child1);

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

function prototype(child, parent) {
    var prototype = object(parent.prototype);
    prototype.constructor = child;
    child.prototype = prototype;
}

// 当我们使用的时候：
prototype(Child, Parent);

class Parent {
  constructor(name) {
    this.name = name
  }
  sayName() {
    console.log(this.name)
  }
}

class Child extends Parent {
  constructor(name,age) {
    super(name)
    this.age = age
  }
}

let child1 = new Child('chris',18)

"use strict";

function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }

var Parent =
/*#__PURE__*/
function () {
  function Parent(name) {
    this.name = name;
  }

  var _proto = Parent.prototype;

  _proto.sayName = function sayName() {
    console.log(this.name);
  };

  return Parent;
}();

var Child =
/*#__PURE__*/
function (_Parent) {
  _inheritsLoose(Child, _Parent);

  function Child(age) {
    var _this;

    _this = _Parent.call(this, name) || this;
    _this.age = age;
    return _this;
  }

  return Child;
}(Parent);

class A {}

class B extends A {
  constructor() {
    super();
  }
}

class A {
  p() {
    return 2;
  }
}

class B extends A {
  constructor() {
    super();
    console.log(super.p()); // 2
  }
}

let b = new B();

const calculateBonus = function(level,salary){
    if(level === 'S'){
        return salary * 4
    }else if(level === 'A'){
        return salary * 3
    }else if(level === 'B'){
        return salary * 2
    }
  }
 calculateBonus('A', 10000) // 30000

const strategy = {
  'S': function(salary) {
    return salary * 4
  },
  'A': function(salary) {
    return salary * 3
  },
  'B': function(salary) {
    return salary * 2
  }
}

const calculateBonus = function(level, salary) {
  return strategy[level](salary)
}

calculateBonus('A', 10000) // 30000

const S = function(salary) {
  return salary * 4
}

const A = function(salary) {
  return salary * 3
}

const B = function(salary) {
  return salary * 2
}

const calculateBonus = function(func, salary) {
  return func(salary)
}

calculateBonus(A, 10000) // 30000

function Person (name, age) {
    this.name = name;
    this.age = age;
    this.habit = 'Games';
}

Person.prototype.strength = 60;

Person.prototype.sayYourName = function () {
    console.log('I am ' + this.name);
}

var person = new Person('Kevin', '18');

function Person () {
    ……
}

// 使用 new
var person = new Person(……);
// 使用 objectFactory
var person = fakeNew(Person, ……)

//1. 创建一个新对象

//2. 获取Constructor为传入的第一个参数（Constructor必须大写哦）

//3. obj.__proto__实例下为Constructor,prototype

//4. 将Constructor所有属性继承到obj上

//5. 返回这个obj

function fakeNew() {

    var obj = new Object(),

    Constructor = [].shift.call(arguments);

    obj.__proto__ = Constructor.prototype;

    Constructor.apply(obj, arguments);

    return obj;

};

function Person (name, age) {
    this.name = name;
    this.age = age;
    this.habit = 'Games';
}

Person.prototype.strength = 60;

Person.prototype.sayYourName = function () {
    console.log('I am ' + this.name);
}

function fakeNew() {
    var obj = new Object(),
    Constructor = [].shift.call(arguments);
    obj.__proto__ = Constructor.prototype;
    Constructor.apply(obj, arguments);
    return obj;
};

var person = fakeNew(Person, 'Kevin', '18')

function Person (name, age) {
    this.strength = 60;
    this.age = age;

    return {
        name: name,
        habit: 'Games'
    }
}

var person = new Person('Kevin', '18');

console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // undefined
console.log(person.age) // undefined

function Person (name, age) {
    this.strength = 60;
    this.age = age;

    return 'handsome boy';
}

var person = new Person('Kevin', '18');

console.log(person.name) // undefined
console.log(person.habit) // undefined
console.log(person.strength) // 60
console.log(person.age) // 18

function fakeNew() {

    var obj = new Object(),

    Constructor = [].shift.call(arguments);

    obj.__proto__ = Constructor.prototype;

    var ret = Constructor.apply(obj, arguments);

    return typeof ret === 'object' ? ret : obj;

};

let wear = function() {
  console.log('穿上第一件衣服')
}

const _wear1 = wear

wear = function() {
  _wear1()
  console.log('穿上第二件衣服')
}

const _wear2 = wear

wear = function() {
  _wear2()
  console.log('穿上第三件衣服')
}

wear()

// 穿上第一件衣服
// 穿上第二件衣服
// 穿上第三件衣服

Function.prototype.after = function(fn) {
  const self = this
  return function() {
    self.apply(new(self), arguments)
    return fn.apply(new(self), arguments)
  }
}

const wear1 = function() {
  console.log('穿上第一件衣服')
}

const wear2 = function() {
  console.log('穿上第二件衣服')
}

const wear3 = function() {
  console.log('穿上第三件衣服')
}

const wear = wear1.after(wear2).after(wear3)
wear()

// 穿上第一件衣服
// 穿上第二件衣服
// 穿上第三件衣服

const after = function(fn, afterFn) {
  return function() {
    fn.apply(this, arguments)
    afterFn.apply(this, arguments)
  }
}

const wear = after(after(wear1, wear2), wear3)
wear()

示例一：js代码按值传递
如果按引用传递，那么函数里面的num会变成类似全局变量，最后输出60

function box(num){ // 按值传递
    num+=10;
    return num;
}
var num=50;

console.log(box(num));  // 60
console.log(num);        // 50

示例二：php代码传递一个参数：
function box(&$num){ 
    //加上&符号将num变成全局变量
    $num+=10;
    return $num;
}
$num = 50;
echo box($num);    // 60
echo $num;    // 60

function box(o){ // 按对象传递
        o.num = 10;
	return obj.num;
}
var obj = { num: 50 };

console.log(box(obj));  // 10
console.log(obj.num);    // 10

function box(o){ // 按对象传递
        o = 10;
	return o;
}
var obj = { num: 50 };

console.log(box(obj));  // 10
console.log(obj.num);    // 50

const myImage = (function() {
  const imgNode = document.createElement('img')
  document.body.appendChild(imgNode)
  return {
    setSrc: function(src) {
      imgNode.src = src
    }
  }
})()

const proxyImage = (function() {
  const img = new Image()
  img.onload = function() { // http 图片加载完毕后才会执行
    myImage.setSrc(this.src)
  }
  return {
    setSrc: function(src) {
      // 代理对象
      // 两者使用同一个元素的src
      myImage.setSrc('loading.jpg') // 先用loading占位
      // 实体对象
      img.src = src// 加载完成后显示原有图片
    }
  }
})()

proxyImage.setSrc('http://loaded.jpg')

const mult = function() {
  let a = 1
  for (let i = 0, l; l = arguments[i++];) {
    a = a * l
  }
  return a
}

const proxyMult = (function() {
  //  记忆函数，第一次计算出参数和记录下来，第二次从缓存中拿，不再进行计算
  const cache = {}
  return function() {
    const tag = Array.prototype.join.call(arguments, ',')
    if (cache[tag]) {
      return cache[tag]
    }
    cache[tag] = mult.apply(this, arguments)
    return cache[tag]
  }
})()

proxyMult(1, 2, 3, 4) // 24

<ul id="ul">
  <li>1</li>
  <li>2</li>
  <li>3</li>
  <li>4</li>
  <li>5</li>
</ul>
<script>
  let ul = document.querySelector('#ul');
  ul.addEventListener('click', event => {
    console.log(event.target);
  });
</script>

AO = {
    arguments: {
        length: 0
    }
}

ECStack = [
    checkscopeContext,
    globalContext
];

    fContext = {
        AO: {
            arguments: {
                length: 0
            }
        },
        Scope: [AO, checkscopeContext.AO, globalContext.VO],
        this: undefined
    }

    ECStack = [
        checkscopeContext,
        globalContext
    ];

    ECStack = [
        globalContext
    ];

ExecutionContext = {
  ThisBinding = <this value>,
  LexicalEnvironment = { ... },
  VariableEnvironment = { ... },
}

GlobalExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Object",
      // 在这里绑定标识符
    }
    outer: <null>
  }
}

FunctionExectionContext = {
  LexicalEnvironment: {
    EnvironmentRecord: {
      Type: "Declarative",
      // 在这里绑定标识符
    }
    outer: <Global or outer function environment reference>
  }
}

var obj = {
  value: 0
}

Object.defineProperty(obj, 'list', {
  get() {
    return this.value
  },
  set(val) {
    console.log('值被更改了')
    this.value = val
  }
})
obj.value = 1 //  console.log('值被更改了')

var obj = {
  value: 0
}

var proxy = new Proxy(obj, {
  set: function(target, key, value, receiver) { // {value: 0}  "value"  1  Proxy {value: 0}
    console.log('调用相应函数')
    Reflect.set(target, key, value, receiver)
  }
})

proxy.value = 1 // 调用相应函数

const sinon = {
  analyze: {},
  spy: function(obj, fnName) {
    const that = this
    const oldFn = Object.getOwnPropertyDescriptor(obj, fnName).value
    Object.defineProperty(obj, fnName, {
      value: function() {
        oldFn()
        if (that.analyze[fnName]) {
          that.analyze[fnName].count = ++that.analyze[fnName].count
        } else {
          that.analyze[fnName] = {}
          that.analyze[fnName].count = 1
        }
        console.log(`${fnName} 被调用了 ${that.analyze[fnName].count} 次`)
      }
    })
  }
}

const obj = {
  someFn: function() {
    console.log('my name is someFn')
  }
}

sinon.spy(obj, 'someFn')

obj.someFn()
// my name is someFn
// someFn 被调用了 1 次
obj.someFn()
// my name is someFn
// someFn 被调用了 2 次

const player = function(name) {
  this.name = name
  playerMiddle.add(name)
}

player.prototype.win = function() {
  playerMiddle.win(this.name)
}

player.prototype.lose = function() {
  playerMiddle.lose(this.name)
}

const playerMiddle = (function() { // 将就用下这个 demo, 这个函数当成中介者
  const players = []
  const winArr = []
  const loseArr = []
  return {
    add: function(name) {
      players.push(name)
    },
    win: function(name) {
      winArr.push(name)
      if (winArr.length + loseArr.length === players.length) {
        this.show()
      }
    },
    lose: function(name) {
      loseArr.push(name)
      if (winArr.length + loseArr.length === players.length) {
        this.show()
      }
    },
    show: function() {
      for (let winner of winArr) {
        console.log(winner + '挑战成功;')
      }
      for (let loser of loseArr) {
        console.log(loser + '挑战失败;')
      }
    },
  }
}())

const a = new player('A 选手')
const b = new player('B 选手')
const c = new player('C 选手')

a.win()
b.win()
c.lose()

// A 选手挑战成功;
// B 选手挑战成功;
// C 选手挑战失败;

class EventHub{
  constructor(){
    this.obj = {}
  }
  on(eventType,fn){
    if(!this.obj[eventType]){
      this.obj[eventType] = []
    }
    this.obj[eventType].push(fn)
  }
  emit(eventType,...arguments){
    let arr = this.obj[eventType]
    for (let i = 0; i < arr.length; i++) {
      arr[i].apply(arr[i], arguments)
    }
  }
}

let hub = new EventHub()

hub.on('click', (a) => { // 订阅函数
  console.log(a) // 1
})

hub.emit('click', 1)  

var hub = new Event()
hub.emit('click', 1)

hub.on('click', function(a) {
  console.log(a) // 1
})

class EventHub {
  constructor() {
    this.obj = {}
    this.cacheList = []
  }
  on(eventType, fn) {
    if (!this.obj[eventType]) {
      this.obj[eventType] = []
    }
    this.obj[eventType].push(fn)
    // 先调用缓存队列的方法
    for (let i = 0; i < this.cacheList.length; i++) {
      this.cacheList[i]()
    }
  }
  emit(eventType, ...arguments) {
    const that = this
      cache = () => {
      let arr = that.obj[eventType]
      for (let i = 0; i < arr.length; i++) {
        arr[i].apply(arr[i], arguments)
      }
    }
    // 订阅之前将发布函数都存在缓存队列中
    this.cacheList.push(cache)
  }
}

HTTP/1.0 200 OK
Content-type: text/html
Set-Cookie: yummy_cookie=choco
Set-Cookie: tasty_cookie=strawberry

[page content]

GET /sample_page.html HTTP/1.1
Host: www.example.org
Cookie: yummy_cookie=choco; tasty_cookie=strawberry

Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT;

document.cookie = "yummy_cookie=choco";
document.cookie = "tasty_cookie=strawberry";
console.log(document.cookie);

Set-Cookie: id=a3fWa; Expires=Wed, 21 Oct 2015 07:28:00 GMT; Secure; HttpOnly

<html>
    <head>
        <meta charset="utf-8" />
        <title>cache-control</title>
    </head>
    <body>
        <script src="/script.js"></script>
    </body>
</html>

const http = require('http');
const fs = require('fs');
const port = 3010;

http.createServer((request, response) => {
    console.log('request url: ', request.url);

    if (request.url === '/') {
        const html = fs.readFileSync('./example/cache/cache-control.html', 'utf-8');
    
        response.writeHead(200, {
            'Content-Type': 'text/html',
        });

        response.end(html);
    } else if (request.url === '/script.js') {
        response.writeHead(200, {
            'Content-Type': 'text/javascript',
            'Cache-Control': 'max-age=200'
        });

        response.end("console.log('script load')");
    }

}).listen(port);

console.log('server listening on port ', port);

...
response.writeHead(200, {
    'Content-Type': 'text/javascript',
    'Cache-Control': 'max-age=200'
});

response.end("console.log('script load ！！！')");
...

Vary: Accept-Language

GET /z4d4kWk.jpg HTTP/1.1
Host: i.imgur.com
Range: bytes=0-1023

HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/146515
Content-Length: 1024
...
(binary content)

Accept-Ranges: bytes

GET /test/demo_form.asp?name1=value1&name2=value2 HTTP/1.1
POST /test/demo_form.asp HTTP/1.1
Host: w3schools.com
name1=value1&name2=value2

GET /pageX HTTP/1.1
GET /pageX HTTP/1.1
GET /pageX HTTP/1.1
GET /pageX HTTP/1.1

POST /add_row HTTP/1.1   -> Adds a 1nd row
POST /add_row HTTP/1.1   -> Adds a 2nd row
POST /add_row HTTP/1.1   -> Adds a 3rd row

DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
DELETE /idX/delete HTTP/1.1   -> Returns 404

//数组
var array = ['name', 'age', 'sex'];

//类数组
var arrayLike = {
    0: 'name',
    1: 'age',
    2: 'sex',
    length: 3
}
Aarry.isAarry(arrLike) //false

console.log(array[0]); // name
console.log(arrayLike[0]); // name

array[0] = 'new name';
arrayLike[0] = 'new name';

console.log(array.length); // 3
console.log(arrayLike.length); // 3

for(var i = 0, len = array.length; i < len; i++) {
   ……
}
for(var i = 0, len = arrayLike.length; i < len; i++) {
    ……
}

arrayLike.push('4');// arrayLike.push is not a function

var arrayLike = {0: 'name', 1: 'age', 2: 'sex', length: 3 }

Array.prototype.join.call(arrayLike, '&'); // name&age&sex

Array.prototype.map.call(arrayLike, function(item){
    return item.toUpperCase();
}); 
// ["NAME", "AGE", "SEX"]

var arrayLike = {0: 'name', 1: 'age', 2: 'sex', length: 3 }
// 1. slice
Array.prototype.slice.call(arrayLike); // ["name", "age", "sex"] 
// 2. splice
Array.prototype.splice.call(arrayLike, 0); // ["name", "age", "sex"] 
// 3. ES6 Array.from
Array.from(arrayLike); // ["name", "age", "sex"] 
// 4. apply
Array.prototype.concat.apply([], arrayLike)

function foo(name, age, sex) {
    console.log(arguments);
}

foo('name', 'age', 'sex')

function foo(b, c, d){
    console.log("实参的长度为：" + arguments.length)
}

console.log("形参的长度为：" + foo.length)

foo(1)

// 形参的长度为：3
// 实参的长度为：1

var data = [];

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

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

// 0
// 1
// 2

function foo(name, age, sex, hobbit) {

    console.log(name, arguments[0]); // name name

    // 改变形参
    name = 'new name';

    console.log(name, arguments[0]); // new name new name

    // 改变arguments
    arguments[1] = 'new age';

    console.log(age, arguments[1]); // new age new age

    // 测试未传入的是否会绑定
    console.log(sex); // undefined

    sex = 'new sex';

    console.log(sex, arguments[2]); // new sex undefined

    arguments[3] = 'new hobbit';

    console.log(hobbit, arguments[3]); // undefined new hobbit

}

foo('name', 'age')

function foo(name) {
	name = arguments[0]
}

//ES5
// 使用 apply 将 foo 的参数传递给 bar\
function bar(a, b, c) {
   console.log(a, b, c);
}

function foo() {
    bar.apply(this, arguments);//1,2,3
}

foo(1, 2, 3)

//ES6
class bar{
	constructor(a,b,c){
		this.a = a
		this.b = b
		this.c = c
	}
}

class foo extends bar{
	constructor(d){
		super(...arguments)//继承参数a,b,c
		this.d = d
	}
}

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

function fun2() {
    fun3();
}

function fun1() {
    fun2();
}

fun1();

// orderType: 表示订单类型, 1: 500 元定金用户；2: 200 元定金用户；3: 普通购买用户
// pay: 表示用户是否已经支付定金, true: 已支付；false: 未支付
// stock: 表示当前用于普通购买的手机库存数量, 已支付过定金的用户不受此限制

const order = function( orderType, pay, stock ) {
  if ( orderType === 1 ) {
    if ( pay === true ) {
      console.log('500 元定金预购, 得到 100 元优惠券')
    } else {
      if (stock > 0) {
        console.log('普通购买, 无优惠券')
      } else {
        console.log('库存不够, 无法购买')
      }
    }
  } else if ( orderType === 2 ) {
    if ( pay === true ) {
      console.log('200 元定金预购, 得到 50 元优惠券')
    } else {
      if (stock > 0) {
        console.log('普通购买, 无优惠券')
      } else {
        console.log('库存不够, 无法购买')
      }
    }
  } else if ( orderType === 3 ) {
    if (stock > 0) {
        console.log('普通购买, 无优惠券')
    } else {
      console.log('库存不够, 无法购买')
    }
  }
}

order( 3, true, 500 ) // 普通购买, 无优惠券

const order500 = function(orderType, pay, stock) {
  if ( orderType === 1 && pay === true ) {
    console.log('500 元定金预购, 得到 100 元优惠券')
  } else {
    order200(orderType, pay, stock)
  }
}

const order200 = function(orderType, pay, stock) {
  if ( orderType === 2 && pay === true ) {
    console.log('200 元定金预购, 得到 50 元优惠券')
  } else {
    orderCommon(orderType, pay, stock)
  }
}

const orderCommon = function(orderType, pay, stock) {
  if (orderType === 3 && stock > 0) {
    console.log('普通购买, 无优惠券')
  } else {
    console.log('库存不够, 无法购买')
  }
}

order500( 3, true, 500 ) // 普通购买, 无优惠券

// 业务代码
const order500 = function(orderType, pay, stock) {
  if ( orderType === 1 && pay === true ) {
    console.log('500 元定金预购, 得到 100 元优惠券')
  } else {
    return 'nextSuccess'
  }
}

const order200 = function(orderType, pay, stock) {
  if ( orderType === 2 && pay === true ) {
    console.log('200 元定金预购, 得到 50 元优惠券')
  } else {
    return 'nextSuccess'
  }
}

const orderCommon = function(orderType, pay, stock) {
  if (orderType === 3 && stock > 0) {
    console.log('普通购买, 无优惠券')
  } else {
    console.log('库存不够, 无法购买')
  }
}

// 链式调用
const chain = function(fn) {
  this.fn = fn
  this.sucessor = null
}

chain.prototype.setNext = function(sucessor) {
  this.sucessor = sucessor
}

chain.prototype.init = function() {
  const result = this.fn.apply(this, arguments)
  if (result === 'nextSuccess') {
    this.sucessor.init.apply(this.sucessor, arguments)
  }
}

const order500New = new chain(order500)
const order200New = new chain(order200)
const orderCommonNew = new chain(orderCommon)

order500New.setNext(order200New)
order200New.setNext(orderCommonNew)

order500New.init( 3, true, 500 ) // 普通购买, 无优惠券

// 业务代码
const order500 = function(orderType, pay, stock) {
  if ( orderType === 1 && pay === true ) {
    console.log('500 元定金预购, 得到 100 元优惠券')
  } else {
    return 'nextSuccess'
  }
}

const order200 = function(orderType, pay, stock) {
  if ( orderType === 2 && pay === true ) {
    console.log('200 元定金预购, 得到 50 元优惠券')
  } else {
    return 'nextSuccess'
  }
}

const orderCommon = function(orderType, pay, stock) {
  if (orderType === 3 && stock > 0) {
    console.log('普通购买, 无优惠券')
  } else {
    console.log('库存不够, 无法购买')
  }
}

// 链路代码
Function.prototype.after = function(fn) {
  const self = this
  return function() {
    const result = self.apply(self, arguments)
    if (result === 'nextSuccess') {
      return fn.apply(self, arguments) // 这里 return 别忘记了~
    }
  }
}

const order = order500.after(order200).after(orderCommon)

order( 3, true, 500 ) // 普通购买, 无优惠券

1. 煮咖啡
2. 打开电视、打开音响
3. 打开空调、打开电脑

const MacroCommand = function() {
  return {
    lists: [],
    // 消息队列
    add: function(task) {
      this.lists.push(task)
    },
    // 执行队列
    excute: function() { // 组合对象调用这里的 excute,
      for (let i = 0; i < this.lists.length; i++) {
        this.lists[i].excute()
      }
    },
  }
}

const command1 = MacroCommand() // 基本对象

command1.add({
  excute: () => console.log('煮咖啡') // 基本对象调用这里的 excute,
})

const command2 = MacroCommand() // 组合对象

command2.add({
  excute: () => console.log('打开电视')
})

command2.add({
  excute: () => console.log('打开音响')
})

const command3 = MacroCommand()

command3.add({
  excute: () => console.log('打开空调')
})

command3.add({
  excute: () => console.log('打开电脑')
})

const macroCommand = MacroCommand()
macroCommand.add(command1)
macroCommand.add(command2)
macroCommand.add(command3)

macroCommand.excute()

// 煮咖啡

// 打开电视
// 打开音响

// 打开空调
// 打开电脑

const Folder = function(folder) {
  this.folder = folder
  this.lists = []
}

Folder.prototype.add = function(resource) {
  this.lists.push(resource)
}

Folder.prototype.scan = function() {
  console.log('开始扫描文件夹: ', this.folder)
  for (let i = 0, folder; folder = this.lists[i++];) {
    folder.scan()
  }
}

const File = function(file) {
  this.file = file
}

File.prototype.add = function() {
  throw Error('文件下不能添加其它文件夹或文件')
}

File.prototype.scan = function() {
  console.log('开始扫描文件: ', this.file)
}

const folder = new Folder('根文件夹')
const folder1 = new Folder('JS')
const folder2 = new Folder('life')

const file1 = new File('深入React技术栈.pdf')
const file2 = new File('JavaScript权威指南.pdf')
const file3 = new File('小王子.pdf')

folder1.add(file1)
folder1.add(file2)

folder2.add(file3)

folder.add(folder1)
folder.add(folder2)

folder.scan()

// 开始扫描文件夹:  根文件夹
// 开始扫描文件夹:  JS

// 开始扫描文件:  深入React技术栈.pdf
// 开始扫描文件:  JavaScript权威指南.pdf
// 开始扫描文件夹:  life
// 开始扫描文件:  小王子.pdf

var a = 0; //自由变量

function foo() {
    console.log(a);//访问自由变量，此时这个变量并不是函数参数或者函数的局部变量
}

foo();

// 代码1
for (var i = 0; i < 5; i++) {
    setTimeout(() => {
        console.log(i) // 输出5次5
    }, 0)
}

// 代码2
for (let i = 0; i < 5; i++) {
    setTimeout(() => {
        console.log(i) // 输出 0,1,2,3,4
    }, 0)
}

function test(a){
    setTimeout(function timer(){
        console.log(a)
    },0)
}
test('hello')

// 代码3
for (var i = 0; i < 5; i++) {
    ((i) => {
        setTimeout(function timer() {
            console.log(i) // 输出 0,1,2,3,4
        }, 0)
    })(i)
}

// 代码4
for (var i = 0; i < 5; i++) {
    (() => {
        setTimeout(function timer() {
            console.log(i) // 输出 5个5
        }, 0)
    })()
}

for(var i=1; i <= 5; i++){
    setTimeout(function(){
        console.log(i);//6
    },0)
}

for(var i=1; i <= 5; i++){
    (function(j){
        setTimeout(function(){
            console.log(j);
        })
    },0)(i)
}

for(let i=1; i <= 5; i++){
    setTimeout(function(){
        console.log(i);
    },0)
}

输入: 
nums = [1, 7, 3, 6, 5, 6]
输出: 3
解释: 
索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
同时, 3 也是第一个符合要求的中心索引。

/**
 * @param {number[]} nums
 * @return {number}
 */
var pivotIndex = function(nums) {
    if(!nums) return -1
    let sum = 0
    let sumLeft = 0
    let sumRight = 0
    for(let j = 0;j<nums.length;j++){
        sum = sum + nums[j]
    }
    for(let i =0;i<nums.length;i++){
        if(i == 0){
            sumLeft = 0
        }else{
            sumLeft = sumLeft + nums[i-1]
        }
        sumRight = sum - sumLeft - nums[i]
        if(sumLeft == sumRight){
            return i
        }
    }
    return -1
    
};

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    var i;
    for(i=digits.length-1;i>=0;i--){
        if(digits[i]==9){
            digits[i]=0;
        }else{
            digits[i]++;
            return digits;
        }
    }
    if(i == -1){
        digits.unshift(1);
    }
    return digits;
};

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]

输出:  [1,2,4,7,5,3,6,8,9]
/**
 * @param {number[][]} matrix
 * @return {number[]}
 */
var findDiagonalOrder = function(matrix) {
    if (matrix.length == 0) return [];
    let col = matrix.length // 列数
    let row = matrix[0].length // 行数
    let res = []
    let r = 0
    let c= 0
    for(let i = 0;i<lens*row;i++){
        res[i] = matrix[r][c];
            if ((r + c) % 2 == 0) {
                if (c == row - 1) { // 元素在最后一列，往下走
                    r++;
                } else if (r == 0) { // 元素在第一行，往右走
                    c++;
                } else { // 其他情况，往右上走
                    r--;
                    c++;
                }
            } else {
                if (r == col - 1) { //元素在最后一行，往右走
                    c++;
                } else if (c == 0) { // //元素在第一列，往下走
                    r++;
                } else { //其他情况，往左下走
                    r++;
                    c--;
                }
            }
    }
    return res;
    
};

输入: ["flower","flow","flight"]
输出: "fl"
/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
    var len = strs.length
    if(len===0){
        return ""
    }
    if(len===1){
        return strs[0]
    }
    var index = 0
    for(var j = 0;j < strs[0].length;j++){
        for(var i = 0;i<len;i++){
            if(j >= strs[i].length || strs[0][j] != strs[i][j]){
				return strs[0].substring(0,index);
			}
        }
        index++
    }
    return strs[0].substring(0 ,index);
};

function each(arr, fn) {
  for (let i = 0; i < arr.length; i++) {
    fn(i, arr[i])
  }
}

each([1, 2, 3], function(i, n) {
  console.log(i) // 0 1 2
  console.log(n) // 1 2 3
})

const compare = function(arr1, arr2) {
  each(arr1, function(i, n) {
    if (arr2[i] !== n) {
      console.log('两数组不等')
      return
    }
  })
  console.log('两数组相等')
}

const arr1 = [1, 2, 3]
const arr2 = [1, 2, 3]
compare(arr1, arr2) // true

const iterator = function(arr) {
  let current = 0
  const next = function() {
    current = current + 1
  }
  const done = function() {
    return current >= arr.length
  }
  const value = function() {
    return arr[current]
  }
  return {
    next,
    done,
    value,
  }
}

const arr1 = [1, 2 ,3]
const arr2 = [1, 2, 3]
const iterator1 = iterator(arr1)
const iterator2 = iterator(arr2)

const compare = function(iterator1, iterator2) {
  while (!iterator1.done() && !iterator2.done()) {
    if (iterator1.value() !== iterator2.value()) {
      console.log('两数组不等')
      return
    }
    iterator1.next() // 外部迭代器将遍历的权利转移到外部
    iterator2.next()
  }
  console.log('两数组相等')
}

compare(iterator1, iterator2)

// entry section
// critical section;
// exit section

typedef int semaphore;
semaphore mutex = 1;
void P1() {
    down(&mutex);
    // 临界区
    up(&mutex);
}

void P2() {
    down(&mutex);
    // 临界区
    up(&mutex);
}

#define N 100
typedef int semaphore;
semaphore mutex = 1;
semaphore empty = N;
semaphore full = 0;

void producer() {
    while(TRUE) {
        int item = produce_item();
        down(&empty);
        down(&mutex);
        insert_item(item);
        up(&mutex);
        up(&full);
    }
}

void consumer() {
    while(TRUE) {
        down(&full);
        down(&mutex);
        int item = remove_item();
        consume_item(item);
        up(&mutex);
        up(&empty);
    }
}

#include <unistd.h>
int pipe(int fd[2]);

var x = y ? 1 : 'a';

'4' - '3' // 1

// 数值：转换后还是原来的值
Number(324) // 324

// 字符串：如果可以被解析为数值，则转换为相应的数值
Number('324') // 324

// 字符串：如果不可以被解析为数值，返回 NaN
Number('324abc') // NaN

// 空字符串转为0
Number('') // 0

// 布尔值：true 转成 1，false 转成 0
Number(true) // 1
Number(false) // 0

// undefined：转成 NaN
Number(undefined) // NaN

// null：转成0
Number(null) // 0

parseInt('42 cats') // 42
Number('42 cats') // NaN

parseInt('\t\v\r12.34\n') // 12
Number('\t\v\r12.34\n') // 12.34

Number({a: 1}) // NaN
Number([1, 2, 3]) // NaN
Number([5]) // 5

var obj = {x: 1};
Number(obj) // NaN

// 等同于
if (typeof obj.valueOf() === 'object') {
	Number(obj.toString());
  } else {
	Number(obj.valueOf());
}

Number({}) // NaN

var obj = {
valueOf: function () {
	return {};
	},
toString: function () {
	return {};
	}
};
Number(obj)// TypeError: Cannot convert object to primitive value

Number({
	valueOf: function () {
		return 2;
	}
})// 2

Number({
	toString: function () {
		return 3;
	}
})// 3

Number({
	valueOf: function () {
		return 2;
	},
	toString: function () {
		return 3;
	}
})// 2

String(123) // "123"
String('abc') // "abc"
String(true) // "true"
String(undefined) // "undefined"
String(null) // "null"

String({a: 1}) // "[object Object]"
String([1, 2, 3]) // "1,2,3"

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean(NaN) // false
Boolean('') // false

Boolean({}) // true
Boolean([]) // true

123+'abc'  //"123abc"

if ('abc') { console.log('hello') }  // "hello"

+ {foo: 'bar'} // NaN
- [1, 2, 3] // NaN

if (!undefined&& !null&& !0&& !NaN&& !'') {	console.log('true')	} // true

// 写法一
expression ? true : false

// 写法二
!! expression

'5' + 1 // '51'
'5' + true // "5true"
'5' + false // "5false"
'5' + {} // "5[object Object]"
'5' + [] // "5"
'5' + function (){} // "5function (){}"
'5' + undefined // "5undefined"
'5' + null // "5null"

'5' - '2' // 3
'5' * '2' // 10
true - 1  // 0
false - 1 // -1
'1' - 1   // 0
'5' * []    // 0
false / '5' // 0
'abc' - 1   // NaN
null + 1 // 1
undefined + 1 // NaN

+'abc' // NaN
-'abc' // NaN
+true // 1
-false // 0

if ( a && b || c) {console.log('1') } // a和b同时存在或者只在c返回true
if ( !a ) { consoel.log('1')} // 不存在a的话返回true
if ( a === b) { console.log('1') } // a和比相等返回true
if ( a > b ) { console.log('1') } // a大于b返回true

if ('') { console.log('true'); }// 没有任何输出

if ( [] ) { console.log('true'); }// true

if ( {} ) { console.log('true'); }// true