fn2.bind(fn1.bind(this, a1)(argu1))(argu2)   // 恶心不？很恶心

this::fn1(argu1)::fn2(argu2)  // OK，链式调用。

function getBlock(array, i, j) {
  if (array[i][j] === 0) return 0
  let sum = 0
  array[i][j] = 0
  sum++

  if (array[i] && array[i][j - 1] === 1) {
    sum += getBlock(array, i, j - 1)
  }

  if (array[i] && array[i][j + 1] === 1) {
    sum += getBlock(array, i, j + 1)
  }

  if (array[i + 1] && array[i + 1][j] === 1) {
    sum += getBlock(array, i + 1, j)
  }

  if (array[i - 1] && array[i - 1][j] === 1) {
    sum += getBlock(array, i - 1, j)
  }

  return sum
}



function getMaxBlocks(bytesArray) {
  const blocks = []
  for (let i = 0; i < bytesArray.length; i++) {
    for (let j = 0; j < bytesArray[i].length; j++) {
      let block = getBlock(bytesArray, i, j)
      if (block > 0) {
        blocks.push(block)
      }
    }
  }
  return Math.max(...blocks)
}

const a = getMaxBlocks(
  [
    [1, 1, 1, 0, 1],
    [1, 1, 0, 1, 1],
    [0, 1, 0, 0, 1],
    [0, 1, 1, 0, 0],
    [0, 1, 0, 0, 0],
  ]
)

console.log(a)

function getMount(array) {
  let lIndex = 0
  let rIndex = array.length - 1
  let lMaxIndex = 0
  let rMaxIndex = array.length - 1
  let result = 0
  while (lIndex < rIndex) {
    if (array[lMaxIndex] < array[rMaxIndex]) {
      lIndex++
      if (array[lIndex] > array[lMaxIndex]) {
        lMaxIndex = lIndex
      }
      result += array[lMaxIndex] - array[lIndex]
    } else {
      rIndex--
      if (array[rIndex] > array[rMaxIndex]) {
        rMaxIndex = rIndex
      }
      result += array[rMaxIndex] - array[rIndex]
    }
  }
  return result
}

const a = [2, 8, 6, 4, 7, 9, 1, 5]

console.log(getMount(a))

function callNext(promize, callback, action, value) {
  if (typeof callback === 'function') {
    let result
    try {
      result = callback(value)
    } catch (e) {
      reject(promize, e)
      return
    }
    if (result === promize) {
      const err = new Error('cycle error')
      reject(promize, err)
    }
    else if (result instanceof Promize) {
      result.then(function(data) {
        resolve(promize, data)
      }, function (err) {
        reject(promize, err)
      })
    } else {
      resolve(promize, result)
    }
  }
  else {
    action === 'resolve' ? resolve(promize, value) : reject(promize, value)
  }
}


function runCallback(promize) {
  if (promize.state === 'pending') return
  
  const value = promize.value
  const callbacks = promize.state === 'resolved' ? promize._doneCallbacks.slice() : promize._failCallbacks.slice()
  setTimeout(function() {
    for (var i = 0, len = callbacks.length; i < len; i++) {
      callbacks[i](value)
    }
  })

  promize._doneCallbacks = []
  promize._failCallbacks = []
}


function resolve(promize, data) {
  if (promize.state !== 'pending') return
  promize.state = 'resolved'
  promize.value = data
  runCallback(promize)
}

function reject(promize, reason) {
  if (promize.state !== 'pending') return
  promize.state = 'rejected'
  promize.value = reason
  runCallback(promize)
}


function Promize (resolver) {
  this.state = 'pending'
  this.value = undefined
  this._doneCallbacks = []
  this._failCallbacks = []
  resolver(resolve.bind(this, this), reject.bind(this, this))
}

Promize.prototype.then = function (resolve, reject = function(err) { throw err } ) {
  const promize = new Promize(function() {})

  this._doneCallbacks.push(callNext.bind(promize, promize, resolve, 'resolve'))
  this._failCallbacks.push(callNext.bind(promize, promize, reject, 'reject'))

  runCallback(this)

  return promize
}

Promize.prototype.catch = function (errHandler) {
  return this.then(null, errHandler)
}

var a = new Promize(function(resolve, reject) {
  reject(111)
})
.then(function(res) {
  console.log(res)
  return 333
}, function(reason) {
  console.log(reason)
  throw 1
})
.then(function(res) {
  console.log(res)
})
.then(function(res) {
  console.log(res)
})
.then(function(res) {
  console.log(res)
}).catch(err => {
  console.log('catch', err)
});

class Scheduler {

  add(promiseCreator) {
  }
  // todo
}


const scdu = new Scheduler()
const timeout = time => {
  return new Promise(resolve => {
    setTimeout(resolve, time)
  })
}

function addTask(time, order) {
  scdu.add(() => timeout(time)).then(() => console.log(order))
}


addTask(1000, 1)
addTask(500, 2)
addTask(300, 3)
addTask(400, 4)

// 2 3 1 4

var obj = {
    name: 'mi',
    age: 30
}
obj = null

class Singleton {
  static instance = null
  static getInstance() {
    if (!Singleton.instance) {
      lock (anyObject) { // 伪代码，表示同一时间只有一个读写操作，防止多次实例化。
        Singleton.instance = new Singleton()
      }
    }
    return Singleton.instance
  }
  constructor() {

  }
}

// 在涉及到多个类似的流程代码的时候，会抽象出公有代码。
// 比如js设计模式所提到的冲泡咖啡和泡茶的过程

// 1、烧开水
// 2、放入咖啡/茶叶
// 3、倒水
// 4、加入辅料

// 其中烧开水和倒水是公共方法可以抽象出来。
// 抽象出一个抽象类或者接口，作用就是让子类实现，本身不实现，抽象类方法执行报错
class DoDrink {
  boil() {
    throw new Error(`禁止调用抽象类烧水方法`)
  }
  pure() {
    throw new Error(`禁止调用抽象类倒水方法`)
  }
  init() {
    // 这是一个共有模板方法入口，必须实现。所以我们这个类并不是纯粹的抽象类
    this.boil()
    this.putIn()
    this.pure()
    this.putOther()
  }
} 

class DoTea extends DoDrink {
  putIn() {
     console.log(`把茶叶放进杯子`)
  }
  putOther() {
     console.log(`放入柚子`)
  }
}

class DoCoffee extends DoDrink {
  putIn() {
     console.log(`把咖啡放进杯子`)
  }
  putOther() {
     console.log(`放入牛奶`)
  }
}

var dotea = new DoDrink()
dotea.init()
var docoffee = new DoCoffee()
docoffee.init()

sendAsync (id, actions) {
    if (actions) {
      this.list = this.list.concat(actions)
    }
    if (this._sendTick) return
    const fn = () => {
      const list = this.list.splice(0)
      list.length && this.call(id, list)
      this._sendTick = null
    }
    this._sendTick = this._stragegy(fn)
  }

// polyf has Px2y attribute
const polyf = require('xxxx');
let Px2y = Symbol('Px2y');
polyf[Px2y] = function () {
	// your implement
};

module.exports.Px2y = Px2y;
module.exports = polyf;


// import 
const polyf = require('./xx');
const Px2y = require('./xx').Px2y;

let Px2y = Symbol('Px2y');
class A {
	constructor() {
		this.name = 'A';
		this.age = '1000';
		this[Px2y] = 'Not Cheap';
	}
}

let obj = new A();
for (let i in obj) {
	console.log(obj[i])
}
console.log(Object.getOwnPropertySymbols(obj))

  /// mod2t2.ts
  export function isEven(x:number): boolean {
    return x % 2 === 0
  }

  export default function isOdd(x: number): boolean {
    return !isEven(x)
  }

  /// mod2t1.ts
  import isOdd, { isEven } from './mod2t2'

  const a = isEven(5)
  const b = isOdd(5)

  console.log(a, b)

  ///源文件 modj1.js
  function isEven(x) {
    return x % 2 === 0
  }

  function isOdd(x) {
    return !isEven(x)
  }

  module.exports = isOdd

  exports = module.exports // 常见问题，重新引用一下
  exports.isEven = isEven

  /// modj1.d.ts  声明文件
  export default function isOdd(x: number):boolean
  export function isEven(x: number):boolean


  /// modt1.ts
  import isOdd, { isEven } from './modj1'

  const a = isEven(5)
  const b = isOdd(5)

  console.log(a, b)

  /// 编译之后的mod2.js
  "use strict";
  exports.__esModule = true;
  var mod1_1 = require("./mod1");
  var a = mod1_1.isEven(5);
  var b = mod1_1["default"](5);  // error
  console.log(a, b);

  /// modj1.js
  function isEven(x) {
    return x % 2 === 0
  }

  function isOdd(x) {
    return !isEven(x)
  }

  module.exports = isOdd

  exports = module.exports
  exports.isEven = isEven

  /// modj1.d.ts
  declare function isOdd(x:number):boolean

  declare namespace isOdd {
    export function isEven(x:number):boolean
  }

  export = isOdd

  /// modt1.ts
  import isOdd = require('./modj1')

  import { isEven } from './modj1'

  const b:boolean = isEven(2)

  const c:boolean = isOdd(4)

  console.log(b, c)

  /// modt1.js
  "use strict";
  exports.__esModule = true;
  var isOdd = require("./modj1");
  var modj1_1 = require("./modj1");
  var b = modj1_1.isEven(2);
  var c = isOdd(4);
  console.log(b, c);

let target = {
    age: 30
};

let p = new Proxy(target, {
    get(target, name) {
        if (!target.hasOwnProperty(name)) {
            throw Error('target don\'t has this property');
        }
        console.log('get success');
        return target[name];
    },
    set(target, name, value) {
        if (!target.hasOwnProperty(name)) {
            throw Error('target don\'t has this property, can\'t set property');
        }
        console.log('set success');
        return target[name] = value;
    }
});

p.age // success
p.age = 12 // success
p.name // throw Error
p.name = 12 // throw Error

// patch.js => updateChildren

  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
    let oldStartIdx = 0
    let newStartIdx = 0
    let oldEndIdx = oldCh.length - 1
    let oldStartVnode = oldCh[0]
    let oldEndVnode = oldCh[oldEndIdx]
    let newEndIdx = newCh.length - 1
    let newStartVnode = newCh[0]
    let newEndVnode = newCh[newEndIdx]
    let oldKeyToIdx, idxInOld, vnodeToMove, refElm

    // removeOnly is a special flag used only by <transition-group>
    // to ensure removed elements stay in correct relative positions
    // during leaving transitions
    const canMove = !removeOnly

    if (process.env.NODE_ENV !== 'production') {
      checkDuplicateKeys(newCh)
    }

    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
      if (isUndef(oldStartVnode)) {
        oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left
      } else if (isUndef(oldEndVnode)) {
        oldEndVnode = oldCh[--oldEndIdx]
      } else if (sameVnode(oldStartVnode, newStartVnode)) {
        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
        oldStartVnode = oldCh[++oldStartIdx]
        newStartVnode = newCh[++newStartIdx]
      } else if (sameVnode(oldEndVnode, newEndVnode)) {
        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
        oldEndVnode = oldCh[--oldEndIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
        oldStartVnode = oldCh[++oldStartIdx]
        newEndVnode = newCh[--newEndIdx]
      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
        oldEndVnode = oldCh[--oldEndIdx]
        newStartVnode = newCh[++newStartIdx]
      } else {
        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
        idxInOld = isDef(newStartVnode.key)
          ? oldKeyToIdx[newStartVnode.key]
          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)
        if (isUndef(idxInOld)) { // New element
          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
        } else {
          vnodeToMove = oldCh[idxInOld]
          if (sameVnode(vnodeToMove, newStartVnode)) {
            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue)
            oldCh[idxInOld] = undefined
            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)
          } else {
            // same key but different element. treat as new element
            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx)
          }
        }
        newStartVnode = newCh[++newStartIdx]
      }
    }
    if (oldStartIdx > oldEndIdx) {
      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm
      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue)
    } else if (newStartIdx > newEndIdx) {
      removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx)
    }
  }

const list1 = [{
  name: '111',
  key: '111',
  show: false
}, {
  name: '222',
  key: '222',
  show: false
}, {
  name: '333',
  key: '333',
  show: true
}, {
  name: '444',
  key: '444',
  show: true
}, {
  name: '555',
  key: '555',
  show: true
}, {
  name: '666',
  key: '666',
  show: false
}]

const list2 = [{
  name: '222',
  key: '222',
  show: true
}, {
  name: '444',
  key: '444',
  show: false
}, {
  name: '333',
  key: '333',
  show: true
}, {
  name: '111',
  key: '111',
  show: true
}, {
  name: '555',
  key: '555',
  show: false
}, {
  name: '777',
  key: '777',
  show: true
}]

/* start */

const v3 = new Vue({
  template: `
    <div>
      <div v-for="(item, index) in list" :key="item.key" v-if="item.show">
        {{item.name}}
      </div>
    </div>
  `,
  data () {
    return {
      list: list1
    }
  },
  mounted () {
    setTimeout(() => {
      /* 这里可以打断点，源码里patch.js patchVnode和 updateChildren 方法内打上断点 */
      this.list = list2
    }, 1000)
  }
})

v3.$mount(`#app3`)