// bad
let a = undefined

// good
let a

// Number.MAX_VALUE
expect((2 - Math.pow(2, -52)) * Math.pow(2, 1023)).toBe(Number.MAX_VALUE)
// Number.MIN_VALUE
expect(Math.pow(2, -52) * Math.pow(2, -1022)).toBe(Number.MIN_VALUE)

// Number.MAX_SAFE_INTEGER
expect((2 - Math.pow(2, -52)) * Math.pow(2, 52)).toBe(Number.MAX_SAFE_INTEGER)
// Number.MIN_SAFE_INTEGER
expect((-1) * (2 - Math.pow(2, -52)) * Math.pow(2, 52)).toBe(Number.MIN_SAFE_INTEGER)

// Number.EPSILON
expect((1 + Math.pow(2, -52)) - 1).toBe(Number.EPSILON)

const symbol1 = Symbol()
const symbol2 = Symbol('foo')

const globalSym = Symbol.for('foo')
expect(Symbol.keyFor(globalSym)).toBe('foo')

const localeSym = Symbol('bar')
expect(Symbol.keyFor(localeSym)).toBeUndefined()

expect(() => new Symbol('foo')).toThrowError(new TypeError('Symbol is not a constructor'))

expect(() => Symbol('foo')).not.toThrow()

const sym = Symbol('foo')

expect(typeof sym).toBe('symbol')
expect(sym instanceof Symbol).toBe(false)

const symObj = Object(sym)
expect(symObj instanceof Symbol).toBe(true)

const sym = Symbol('foo')
expect(String(sym)).toBe('Symbol(foo)')
expect(Boolean(sym)).toBe(true)
expect(() => Number(sym))
  .toThrowError(new TypeError('Cannot convert a Symbol value to a number'))

const obj = {
  [Symbol('foo')]: 'foo',
  bar: 'bar'
}
const isSymbol = s => typeof s === 'symbol'
const hasSymbol = arr => arr.some(isSymbol)

let canGetSymbolByForIn = false
for (k in obj) {
  if (isSymbol(k)) {
    canGetSymbolByForIn = true
    break
  }
}
expect(canGetSymbolByForIn).toBe(false)

expect(hasSymbol(Object.keys(obj))).toBe(false)
expect(hasSymbol(Object.getOwnPropertyNames(obj))).toBe(false)
expect(Object.getOwnPropertySymbols(obj).map(String)).toEqual(['Symbol(foo)'])
expect(Reflect.ownKeys(obj).map(String)).toEqual(['bar', 'Symbol(foo)'])

const META_PROP = Symbol('meta')
const obj = {
  [META_PROP]: '次要信息',
  name: 'logan',
  age: 18,
}

expect(Object.keys(obj)).toEqual(['name', 'age'])

// before
const TYPE_AUDIO = 'AUDIO'
const TYPE_VIDEO = 'VIDEO'

// after
const TYPE_AUDIO = Symbol()
const TYPE_VIDEO = Symbol()

// lady.js
const AGE = Symbol('age')
const GET_AGE = Symbol('getAge')
export class Lady {
  constructor(username, age) {
    this.username = username
    this[AGE] = age
  }

  [GET_AGE]() {
    return this[AGE]
  }
}

// foo.js
import { Lady } from './lady'
const lady = new Lady('lucy', 18)

expect(lady[Symbol('age')]).toBeUndefined()
expect(() => lady[Symbol('getAge')]()).toThrowError('is not a function')

const ladyAgeKey = Object.getOwnPropertySymbols(lady)[0]
const ladyAge = lady[ladyAgeKey]
expect(ladyAge).toBe(18)

const myIterable = {
  *[Symbol.iterator]() {
    yield 1
    yield 2
    yield 3

  }
}
expect([...myIterable]).toEqual([1, 2, 3])

class MyArray {  
  static [Symbol.hasInstance](instance) {
    return Array.isArray(instance)
  }
}

expect([] instanceof MyArray).toBe(true)

const obj = {
  [Symbol.toPrimitive](hint) {
    console.log(hint)
    return hint === 'number'
      ? 10
      : `hint is ${hint}`
  }
}

expect(+obj).toBe(10)
expect(`${obj}`).toBe('hint is string')
expect(obj + '').toBe('hint is default')

class Person {
  get [Symbol.toStringTag]() {
    return 'Person'
  }
}

expect(Object.prototype.toString.call(new Person)).toBe('[object Person]')

// 自定义symbol对象的原型
const symbolProto = {}

// 设置对象属性时会调用toString，返回__name__属性
Object.defineProperties(symbolProto, {
  toString: generatePrivateDescriptor(function() { return this.__name__ }),
})

export default function SymbolPolyfill(description) {
  // 实现禁止使用new操作符生成Symbol
  if (this instanceof SymbolPolyfill) throw new TypeError('Symbol is not a constructor')
  // symbol描述为undefined时为空，其他情况均强制转换为字符串
  description = description === undefined ? '' : String(description)
  symbol = Object.create(symbolProto)
  return Object.defineProperties(symbol, {
    __name__: generatePrivateDescriptor(generateName(description)),
  })
}

// 生成唯一的字符串
const nameRecorder = {}
function generateName(desc) {
  let postfix = 0
  while (nameRecorder[desc + postfix]) postfix++
  nameRecorder[desc + postfix] = true
  return '@@' + desc + postfix
}

// 生成Object.defineProperty的描述对象
function generatePrivateDescriptor(value) {
  return {
    value,
    configruable: false,
    enumerable: false,
    writable: false
  }
}

// 测试
import SymbolPolyfill from './SymbolPolyfill'

const sym1 = SymbolPolyfill('foo')
const sym2 = SymbolPolyfill('foo')

const obj = {}
obj[sym1] = 1
obj[sym2] = 2

expect(sym1 in obj).toBe(true)
expect(sym2 in obj).toBe(true)
expect(obj[sym1]).not.toBe(true)

// 求总分
const sum = arr => arr.reduce((total, { score }) => total + score, 0)
// 求平均分
const average = arr => arr.reduce((total, { score }, i, array) => {
  // 第n项之前均求和、第n项求和后除以数组长度得出平均分
  const isLastElement = i === array.length - 1
  return isLastElement
    ? (total + score) / array.length 
    : total + score
}, 0)
const arr = [
  { name: 'Logan', score: 89 },
  { name: 'Emma', score: 93 },
]
expect(sum(arr)).toBe(182)
expect(average(arr)).toBe(91)

const arr = [
  { name: 'Logan', score: 89 },
  { name: 'Emma', score: 93 },
]
const initialValue = 0
let total = initialValue
for (let i = 0; i < arr.length; i++) {
  const { score } = arr[i]
  total += score
}
expect(total).toBe(182)

const getIntro = arr => arr.reduce((str, {
  name,
  score,
}) => `${str}${name}'s score is ${score};`, '')

const arr = [
  { name: 'Logan', score: 89 },
  { name: 'Emma', score: 93 },
]
expect(getIntro(arr))
  .toBe('Logan\'s score is 89;Emma\'s score is 93;')

const scoreToNameList = arr => arr.reduce((map, { name, score }) => {
  (map[score] || (map[score] = [])).push(name)
  return map
}, {})

const arr = [
  { name: 'Logan', score: 89 },
  { name: 'Emma', score: 93 },
  { name: 'Jason', score: 89 },
]
expect(scoreToNameList(arr)).toEqual({
  89: ['Logan', 'Jason'],
  93: ['Emma'],
})

const arr = [1]

// 未传入初始值，将数组第一项作为初始值
expect(arr.reduce(initialVal => initialVal)).toBe(1)
// 传入 undefined 作为初始值，将 undefined 作为初始值
expect(arr.reduce(initialVal => initialVal, undefined)).toBeUndefined()
// 传入 null 作为初始值，将 null 作为初始值
expect(arr.reduce(initialVal => initialVal, null)).toBeNull()

const arr1 = new Array(3)
console.log(arr1) // [empty × 3]
arr1[2] = 0
console.log(arr1) // [empty × 2, 0]
// 第一、第二项为空项，取第三项作为初始值
expect(arr1.reduce(initialVal => initialVal)).toBe(0)

const arr2 = [ , , true]
console.log(arr2) // [empty × 2, true]
// 第一、第二项为空项，取第三项作为初始值
expect(arr2.reduce(initialVal => initialVal)).toBe(true)

const arr3 = []
arr3.length = 3 // 修改length属性，产生空
console.log(arr3) // [empty × 3]
arr3[2] = 'string'
console.log(arr3) // [empty × 2, "string"]
// 第一、第二项为空项，取第三项作为初始值
expect(arr3.reduce(initialVal => initialVal)).toBe('string')

const arr = new Array(4)
arr[2] = 'Logan'
arr[3] = 'Emma'

let count = 0 // 记录传入reduce的回调的执行次数
const initialVal = arr.reduce((initialValue, cur) => {
  count++
  return initialValue
})
// 未传入初始值，跳过数组空项，取数组第一个非空项作为初始值
expect(initialVal).toBe('Logan')
// 被跳过的空项及第一个非空项均不参与迭代，只有第四项'Emma'进行迭代，故count为1
expect(count).toBe(1)

const arr = [1, 2, 3]
arr.length = 10
console.log(arr) // [1, 2, 3, empty × 7]

let count = 0 // 记录传入reduce的回调的执行次数
arr.reduce((acc, cur) => {
  count++
  return acc + cur
}, 0)

// arr中第三项之后项均为空项，跳过迭代，故count为3
expect(count).toBe(3)

Array.prototype._reduce = function(callback) {
  // 省略参数校验，如this是否是数组等
  const len = this.length
  let i = 0
  let accumulator

  // 传入初始值则使用
  if (arguments.length >= 2) {
    accumulator = arguments[1]
  } else {
    // 未传入初始值则从数组中获取
    // 寻找数组中第一个非空项
    while (i < len && !(i in this)) {
      i++
    }
    
    // 未传入初始值，且数组无非空项，报错
    if (i >= len) {
      throw new TypeError( 'Reduce of empty array with no initial value' )
    }
    // 此处 i++ ，先返回i，即将数组第一个非空项作为初始值
    // 再+1，即数组第一个非空项跳过迭代
    accumulator = this[i++]
  }

  while (i < len) {
    // 数组中空项不参与迭代
    if (i in this) {
      accumulator = callback(accumulator, this[i], i, this)
    }

    i++
  }
  return accumulator
}

Array.prototype._flat = function(depth = 1) {
  const flatBase = (arr, curDepth = 1) => {
    return arr.reduce((acc, cur) => {
      // 当前项为数组，且当前扁平化深度小于指定扁平化深度时，递归扁平化
      if (Array.isArray(cur) && curDepth < depth) {
        return acc.concat(flatBase(cur, ++curDepth))
      }
      return acc.concat(cur)
    }, [])
  }
  return flatBase(this)
}

function test(arr) {
  return arr
    .map(x => x ** 2)
    .filter(x => x > 10)
}

function test(arr) {
  return arr.reduce((arr, cur) => {
    const square = cur ** 2
    return square > 10 ? [...arr, square] : arr
  }, [])
}

function runPromisesSerially(tasks) {
  return tasks.reduce((p, cur) => p.then(cur), Promise.resolve())
}

function compose(...fns) {
  // 初始值args => args，兼容未传入参数的情况
  return fns.reduce((a, b) => (...args) => a(b(...args)), args => args)
}

/* ----- Export Syntax ---------- */
// default exports
export default 42
export default {}
export default []
export default (1 + 2)
export default foo
export default function () {}
export default class {}
export default function foo () {}
export default class foo {}

// variables exports
export var foo = 1
export var foo = function () {}
export var bar
export let foo = 2
export let bar
export const foo = 3
export function foo () {}
export class foo {}

// named exports
export {}
export {foo}
export {foo, bar}
export {foo as bar}
export {foo as default}
export {foo as default, bar}

// exports from
export * from 'foo'
export {} from 'foo'
export {foo} from 'foo'
export {foo, bar} from 'foo'
export {foo as bar} from 'foo'
export {foo as default} from 'foo'
export {foo as default, bar} from 'foo'
export {default} from 'foo'
export {default as foo} from 'foo'

/* ----- Import Syntax ---------- */

// default imports
import foo from 'foo'
import {default as foo} from 'foo'

// named imports
import {} from 'foo'
import {bar} from 'foo'
import {bar, baz} from 'foo'
import {bar as baz} from 'foo'
import {bar as baz, xyz} from 'foo'

// glob imports
import * as foo from 'foo'

// mixing imports
import foo, {baz as xyz} from 'foo'
import foo, * as bar from 'foo'

// just import
import 'foo'

/* ----- Export Syntax ---------- */
// default exports
module.exports = function() {}
module.exports = {}

// named exports
exports.foo = function() {}
exports.bar = 1
exports.baz = class Baz {}

/* ----- Import Syntax ---------- */

// default imports
const foo = require('./foo')

// named imports
const { bar, baz } = require('./foo')
const { bar, baz: xyz } = require('./foo')

// AMD
define(['./a','./b'], function (moduleA, moduleB) {
  // 依赖前置
  moduleA.mehodA();
  console.log(moduleB.dataB);
  // 导出数据
  return {};
});
 
// CMD
define(function (requie, exports, module) {
  // 依赖就近
  var moduleA = require('./a');
  moduleA.mehodA();     

  // 按需载入
  if (needModuleB) {
    var moduleB = requie('./b');
    moduleB.methodB();
  }
  // 导出数据
  exports = {};
});

var moduleA = (function ($, doc) {
  var methodA = function() {};
  var dataA = {};
  return {
    methodA: methodA,
    dataA: dataA
  };
})(jQuery, document);

function SupClass() {...}
function SubClass() {...}
SubClass.prototype = new SupClass()

function SupClass() {...}
function SubClass() {
  SupClass.call(this, arguments)
}

function SupClass() {...}
function SubClass() {
  SupClass.call(this, arguments)
}
SubClass.prototype = new SupClass()

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

function createObj(o) {
  const obj = Object.create(o)
  obj.name = 'Logan'
  return obj
}

function inherit(child, parent) {
  const p = Object.create(parent.prototype)
  child.prototype = p
  p.constructor = child
  return child
}

function SupClass() {...}
function SubClass() {
  SupClass.call(this)
}

SubClass = inherit(SubClass, SupClass)

Promise.all(tasks.map(task => task()))
  .then(() => doSomethingAfter())

// 也可结合 async/await使用
;(async () => {
  await Promise.all(tasks.map(task => task()))
  doSomethingAfter()
})()

let finishedNum = 0
let taskNum = tasks.length
tasks.forEach((task, i) => {
  task(() => {
    // 完成任务个数记录
    finishedNum++

    // 检测是否全部完成
    if (finishedNum === taskNum) {
      doSomethingAfter()
    }
  })
})

let taskPromise = Promise.resolve()
tasks.forEach((task, i) => {
  taskPromise = taskPromise.then(() => task())
})

// 完成所有任务后
taskPromise.then(() => doSomethingAfter())

const taskPromise = tasks
  .reduce((promise, task) => {
    promise = promise.then(() => task)
    return promise
  }, Promise.resolve())
  .then(() => doSomethingAfter())

const runTasksSerially = tasks => {
  if (tasks.length <= 0) {
    return doSomethingAfter()
  }
  const taskToRun = tasks.shift() // 取出首个任务
  // 执行完成后，回调内将剩余任务传入runTasksSerially执行，实现串行
  taskToRun(() => runTasksSerially(tasks))
}

runTasksSerially(tasks)

// Promise.all并行执行
const runTasksConcurrently = tasks => Promise.all(tasks.map(task => task()))

// Promise.then串行执行
const runTasksSerially = tasks => tasks.reduce((p, task) => p.then(() => task()), Promise.resolve())

const runTasks = (tasks, concurrency) => {
  // 分割任务组，组个数为 Math.ceil(tasks.length / concurrency)，组内任务个数为concurrency
  const dividedTasks = Array.from({ length: Math.ceil(tasks.length / concurrency) }, (_, i) => {
    return tasks.slice(i * concurrency, i * concurrency + concurrency)
  })

  // 生成组内并行执行，组间串行执行的任务组
  const serialTasks = dividedTasks.map(concurrentTasks => {
    return () => runTasksConcurrently(concurrentTasks)
  })

  // 串行执行生成的任务组（注：单个组内的各个任务并行执行）
  return runTasksSerially(serialTasks)
}

runTasks(tasks, 3).then(() => doSomethingAfter())

expect(new Boolean(true)).toBeInstanceOf(Boolean)
expect(new Number(1)).toBeInstanceOf(Number)
expect(new String('Logan')).toBeInstanceOf(String)
expect(Object(Symbol('foo'))).toBeInstanceOf(Symbol)
expect(Object(BigInt(30))).toBeInstanceOf(BigInt)

expect(() => (undefined).x).toThrowError()
expect(() => (null).x).toThrowError()

expect(() => (true).toString()).toBe('true')
expect(() => (1).toFixed(1)).toBe('1.0')
expect(() => ('abc').substr(1)).toBe('bc')
expect(() => (Symbol('foo')).description).toBe('foo')

const obj1 = {}
const obj2 = {
  [Symbol.toPrimitive](hint) {
    if (hint === 'number') return 10
    if (hint === 'string') return 'Logan'
    return 'default'
  }
}

expect(+obj1).toBeNaN()
expect(+obj2).toBe(10)

expect(`${obj1}`).toBe('[object Object]')
expect(`${obj2}`).toBe('Logan')

expect('' + obj1).toBe('[object Object]')
expect('' + obj2).toBe('default')

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError('Cannot call a class as a function')
  }
}

function _createClass(Constructor, protoProps = [], staticProps = []) {
  // 在构造函数的原型上定义实例属性方法
  _defineProperties(Constructor.prototype, protoProps)
  // 在构造函数本身定义静态属性方法
  _defineProperties(Constructor, staticProps)
}

// 实现公用的批量给对象添加属性方法的方法
function _defineProperties(target, props) {
  props.forEach(prop => {
    Object.defineProperty(target, prop.key, prop)
  })
}

function _inherits(subClass, superClass) {
  // 子类实例继承父类的实例属性方法
  subClass.prototype = Object.create(superClass.prototype)
  // 修正constructor属性
  subClass.prototype.constructor = subClass

  // 子类继承父类的静态属性方法
  Object.setPrototypeOf(subClass, superClass)
}

class Person {
  constructor(options) {
    this.name = options.name
    this.age = options.age
  }
  eat() {
    return 'eating'
  }
  static isPerson(instance) {
    return instance instanceof Person
  }
}

class Student extends Person {
  constructor(options) {
    super(options)
    this.grade = options.grade
  }
  study() {
    return 'studying'
  }
  static isStudent(instance) {
    return instance instanceof Student
  }
}

var Person = (function() {
  function Person(options) {
    // 确保使用new调用
    _classCallCheck(this, Person)
    this.name = options.name
    this.age = options.age
  }

  _createClass(
    Person,
    // 实例属性方法
    [{
      key: 'eat',
      value: function eat() {
        return 'eating'
      }
    }],
    // 静态属性方法
    [{
      key: 'isPerson',
      value: function isPerson(instance) {
        return instance instanceof Person
      }
    }]
  )
  return Person
})();
var Student = (function (_Person) {
  // 继承父类实例属性方法和静态属性方法
  _inherits(Student, _Person)

  function Student(options) {
    // 确保使用new调用
    _classCallCheck(this, Student)

    // 执行父类构造函数
    _Person.call(this, options)

    this.grade = options.grade
  }

  _createClass(Student,
    // 实例属性方法
    [{
      key: 'study',
      value: function study() {
        return 'studying'
      }
    }],
    // 静态属性方法
    [{
      key: 'isStudent',
      value: function isStudent(instance) {
        return instance instanceof Student
      }
    }]
  )

  return Student
})(Person);

const person = new Person({ name: 'Logan', age: 18 })
const student = new Student({ name: 'Logan', age: 18, grade: 9 })

expect(person.eat()).toBe('eating')
expect(student.eat()).toBe('eating') // 继承实例方法
expect(student.study()).toBe('studying')

expect(Student.isStudent(student)).toBe(true)
expect(Person.isPerson(person)).toBe(true)
expect(Student.isStudent(person)).toBe(false)
expect(Student.isPerson(student)).toBe(true) // 继承静态方法

class ClassWithStaticField {
  static staticField1 = 'static field' // 设定初始值
  static staticField2 // 不设定初始值
}

function ClassWithStaticField() {}
// @babel/plugin-proposal-class-properties 中使用Object.defineProperty实现，此处简便起见直接赋值
ClassWithStaticField.staticField1 = 'static field' // 设定初始值
ClassWithStaticField.staticField2 = undefined // 不设定初始值

class ClassWithInstanceField {
  instanceField1 = 'instance field' // 设定初始值
  instanceField2 // 不设定初始值
}

function ClassWithInstanceField() {
  // @babel/plugin-proposal-class-properties 中使用Object.defineProperty实现，此处简便起见直接赋值
  this.instanceField1 = 'instance field' // 设定初始值
  this.instanceField2 = undefined // 不设定初始值
}

class ClassWithPrivateStaticField {
  static #PRIVATE_STATIC_FIELD

  static publicStaticMethod() {
    ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD = 42
    return ClassWithPrivateStaticField.#PRIVATE_STATIC_FIELD
  }
}

var ClassWithPrivateStaticField = (function() {
  var _PRIVATE_STATIC_FIELD
  function ClassWithPrivateStaticField() {}

  ClassWithPrivateStaticField.publicStaticMethod = function() {
    _PRIVATE_STATIC_FIELD = 42
    return _PRIVATE_STATIC_FIELD
  }
  return ClassWithPrivateStaticField
})();

class ClassWithPrivateField {
  #privateField;
  
  constructor() {
    this.#privateField = 42;
    console.log(this.$privateField)
  }
}

var ClassWithPrivateField = (function() {
  var _privateField = new WeakMap()
  function ClassWithPrivateField() {
    _privateField.set(this, undefined)
    _privateField.set(this, 42)
    console.log(_privateField.get(this))
  }
})();

setTimeout(()=>{
  console.log('timer1')
  Promise.resolve().then(() => console.log('promise1'))
}, 0)
setTimeout(()=>{
  console.log('timer2')
  Promise.resolve().then(() => console.log('promise2'))
}, 0)

function foo() {
    console.log(this.a)
}

/* -------显式指定this------- */
foo.call({a: 1})
foo.apply({a: 1})
foo.bind({a: 1})()
// 内部均执行
foo[[Call]]({a: 1})

/* -------函数构造调用------- */
new foo()
// 内部执行
let obj = {}
obj.__proto__ = foo.prototype
foo[[Call]](obj)
// 最后将这个obj返回，关于构造函数的详细内容可翻阅我之前关于原型和原型链的文章

/* -------作为对象方法调用------- */
let obj = {
    a: 4,
    foo: function() {
        console.log(this.a)
    }
}
obj.foo()
// 内部执行
foo[[Call]]({
    a: 1,
    foo: Function foo
})

window.a = 10
function foo() {
    console.log(this.a)
}
foo() // 输出： 10
foo.call(undefined) // 输出： 10
// 内部均执行
foo[[Call]](undefined) // 非严格模式，this指向全局对象

foo.call(null) // 输出： 10
// 内部执行
foo[[Call]](null) // 非严格模式，this指向全局对象

function foo() {
    'use strict'
    console.log(this)
}
foo() // 输出：undefined
foo.call(null) // 输出：null

window.a = 10
function foo() {
    console.log(this.a)
}
function bar() {
    'use strict'
    foo()
}
bar() // 输出：10

function foo() {
    return () => {
        console.log(this)
    }
}
const arrowFn1 = foo()
arrowFn1() // 输出：window
           // 箭头函数没有this绑定，往外层词法环境寻找
           // 在foo的词法环境上找到this绑定，指向全局对象window
           // 在foo的词法环境上找到，并非是在全局找到的
const arrowFn2 = foo.call({a: 1})
arrowFn2() // 输出 {a: 1}

window.a = 10
const foo = () => {
    console.log(this.a)
}
foo.call({a: 20}) // 输出： 10

let obj = {
    a: 20,
    foo: foo
}
obj.foo() // 输出： 10

function bar() {
    foo()
}
bar.call({a: 20}) // 输出： 10

window.a = 10
let obj = {
    a: 20,
    foo: function() {
        console.log(this.a)
    }
}

setTimeout(obj.foo, 0) // 输出： 10

setTimeout(obj.foo, 0)
//等同于，先将传入回调函数记录下来
let callback = obj.foo
// 达到触发条件后执行回调
callback()
// 所以foo函数并非作为对象方法调用，而是作为函数普通调用

setTimeout(obj.foo.bind({a: 20}), 0) // 输出： 20

let _this = this
let self = this
let me = this

window.a = 10
function foo() {
    return () => {
        console.log(this.a)
    }
}
const arrowFn = foo.call({a: 20})
arrowFn() // 输出：20
setTimeout(arrowFn, 0) // 输出：20

// 例1
var name = 'window'

var person1 = {
  name: 'person1',
  show1: function () {
    console.log(this.name)
  },
  show2: () => console.log(this.name),
  show3: function () {
    return function () {
      console.log(this.name)
    }
  },
  show4: function () {
    return () => console.log(this.name)
  }
}
var person2 = { name: 'person2' }

person1.show1()  // ？
person1.show1.call(person2)  // ？

person1.show2()  // ？
person1.show2.call(person2)  // ？

person1.show3()()  // ？
person1.show3().call(person2)  // ？
person1.show3.call(person2)()  // ？

person1.show4()()  // ？
person1.show4().call(person2)  // ？
person1.show4.call(person2)()  // ？

const scope = 'global scope'

function checkscope1(){
    const scope = 'local scope 1'
    function f(){
        return scope
    }
    return f()
}
checkscope1()
// <- 'local scope 1'

function checkscope2(){
    const scope = 'local scope 2'
    function f(){
        return scope
    }
    return f
}
checkscope2()()
// <- 'local scope 2'

var jQuery = function(selector, context) {
  return new jQuery.fn.init(selector, context)
}

jQuery.fn = jQuery.prototype = {
	constructor: jQuery,
  ... // 各种原型方法
}

jQuery.fn.init = function(selector, context, root) { ... }
jQuery.fn.init.prototype = jQuery.fn // 校正实例的原型

function Vue(options) {
  this._init(options)
}

// initMixin
Vue.prototype._init = function (options) { ... }

// stateMixin
Object.defineProperty(Vue.prototype, '$data', {...})
Object.defineProperty(Vue.prototype, '$props', {...})
Vue.prototype.$set = function() {...}
Vue.prototype.$delete = function() {...}
Vue.prototype.$watch = function() {...}

// eventMixin
Vue.prototype.$on = function() {...}
Vue.prototype.$once = function() {...}
Vue.prototype.$off = function() {...}
Vue.prototype.$emit = function() {...}

// lifecycleMixin
Vue.prototype._update = function() {...}
Vue.prototype.$forceUpdate = function() {...}
Vue.prototype.$destory = function() {...}

// renderMixin
Vue.prototype.$nextTick = function() {...}
Vue.prototype._render = function() {...}

Array.prototype._push = function(...args) {
  const len = Number(this.length) || 0
  this.length = len
  for (arg of args) {
    this[this.length++] = arg
  }
  return this.length
}

Array.prototype._reduceRight = function(callback) {
  const len = this.length
  if (arguments.length >= 2) {
    return [...this].reverse().reduce((acc, cur, i) => {
      return callback(acc, cur, len - 1 - i, this)
    }, arguments[1])
  } else {
    return [...this].reverse().reduce((acc, cur, i) => {
      return callback(acc, cur, len - 1 - i, this)
    })
  }
}

Array.prototype._reverse = function() {
  const len = this.length
  for (let i = 0; i < Math.floor(len / 2); i++) {
    const correspondIndex = len - 1 - i;
    [this[i], this[correspondIndex]] = [this[correspondIndex], this[i]]
  }
  return this
}

Array.prototype._shift = function() {
  if (!this.length) return undefined
  // 记录第一项并删除
  const valToDel = this[0]
  delete this[0]
  // 之后项依次左移
  for (let i = 0; i < this.length - 1; i++) {
    this[i] = this[i + 1]
  }
  // 删除最后一项
  delete this[this.length - 1]
  // 修正数组长度
  this.length--
  return valToDel
}

Array.prototype._slice = function(beginIndex = 0, endIndex = this.length) {
  const begin = beginIndex < 0 ?
    Math.max(this.length + beginIndex, 0) :
    Math.min(beginIndex, this.length)
  const end = endIndex < 0 ?
    Math.max(this.length + endIndex, 0) :
    Math.min(endIndex, this.length)
  
  const count = end - begin
  if (count <= 0) return []
  
  const result = new Array(count)
  for (let i = 0; i < count; i++) {
    if (i in this) {
      result[i] = this[begin + i]
    }
  }
  return result
}

Array.prototype._some = function(callback, thisArg) {
  for (let i = 0; i < this.length; i++) {
    if (i in this && callback.call(thisArg, this[i], i, this)) {
      return true
    }
  }
  return false
}

Array.prototype._splice = function(startIndex, deleteCount = this.length - startIndex, ...items) {
  const len = this.length
  const start = startIndex < 0 ?
    Math.max(len + startIndex, 0) :
    Math.min(len, startIndex)
  
  const realDeleteCount = deleteCount <= 0 ?
    0 :
    Math.min(len - start, deleteCount)
  
  const deleteVals = this.slice(start, start + realDeleteCount)
  const right = [...items, ...this.slice(start + realDeleteCount)]

  for (let i = 0; i < right.length; i++) {
    this[start + i] = right[i]
  }
  // 修正length属性，自动删除多余项
  this.length = start + right.length
  return deleteVals
}

Array.prototype._unshift = function(...items) {
  const addCount = items.length
  if (addCount === 0) return this.length
  this.length += items.length
  for (let i = this.length - 1; i >= 0; i--) {
    if (i >= addCount) {
      this[i] = this[i - addCount]
    } else {
      this[i] = items[i]
    }
  }
  return this.length
}

Array.prototype._values = function(...items) {
  function *gen() {
    for (let i = 0; i < this.length; i++) {
      yield this[i]
    }
  }
  return gen.call(this)
}

function newOperator(Ctor, ...args) {
  if (typeof Ctor !== 'function') {
    throw new TypeError('First argument is not a constructor')
  }
  // 1. 创建一个全新对象，并将该对象原型指向构造函数的原型对象
  const obj = Object.create(Ctor.prototype)

  // 2. 将构造函数调用的this指向这个新对象，并执行构造函数；
  const result = Ctor.apply(obj, args)

  // 3. 如果构造函数执行结果为对象类型，则返回执行结果，否则返回创建的新对象
  return (result instanceof Object) ? result : obj
}

const PENDING = 'pending'
const FULFILLED = 'fulfilled'
const REJECTED = 'rejected'

const queueMicrotask = typeof window !== 'undefined' ? window.queueMicrotask : process.nextTick

class Promise {
  constructor(excutor) {
    this.state = PENDING
    this.onFulfilledCallbacks = []
    this.onRejectedCallbacks = []
    excutor(this._resolve.bind(this), this._reject.bind(this))
  }

  then(onFulfilled, onRejected) {
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : v => v
    onRejected = typeof onRejected === 'function' ? onRejected : e => { throw e }
    const promise2 = new Promise((resolve, reject) => {
      const next = () => queueMicrotask(() => {
        try {
          const x = this.state === FULFILLED ?
            onFulfilled(this.value) :
            onRejected(this.reason)
          resolvePromise(promise2, x, resolve, reject)
        } catch (e) {
          reject(e)
        }
      })

      if (this.state !== PENDING) return next()
      
      this.onFulfilledCallbacks.push(next)
      this.onRejectedCallbacks.push(next)
    })
    return promise2
  }

  static resolve(value) {
    return new Promise(resolve => resolve(value))
  }

  static reject(reason) {
    return new Promise((_, reject) => reject(reason))
  }

  static race(promises) {
    return new Promise((resolve, reject) => {
      promises.forEach(p => p.then(resolve, reject))
    })
  }

  static all(promises) {
    return new Promise((resolve, reject) => {
      const count = promises.length
      let resultArr = new Array(count)
      let fulfilledCount = 0
      const check = (result, i) => {
        resultArr[i] = result
        fulfilledCount++
        if (fulfilledCount === promises.length) {
          resolve(resultArr)
        }
      }
      promises.forEach((p, i) => {
        p.then(result => check(result, i), reject)
      })
    })
  }

  catch(handler) {
    return this.then(v => v, e => handler(e))
  }

  finally(handler) {
    return this.then(() => handler(), () => handler())
  }

  _resolve(value) {
    if (this.state !== PENDING) return
    this.state = FULFILLED
    this.value = value
    this.onFulfilledCallbacks.forEach(cb => cb(this.value))
  }

  _reject(reason) {
    if (this.state !== PENDING) return
    this.state = REJECTED
    this.reason = reason
    this.onRejectedCallbacks.forEach(cb => cb(this.reason))
  }
}

function resolvePromise(promise2, x, resolve, reject){
  if(x === promise2){
    return reject(new TypeError('Chaining cycle detected for promise'))
  }
  let called
  if (x != null && (typeof x === 'object' || typeof x === 'function')) {
    try {
      let then = x.then
      if (typeof then === 'function') { 
        then.call(x, y => {
          if (called) return
          called = true
          resolvePromise(promise2, y, resolve, reject)
        }, err => {
          if (called) return
          called = true
          reject(err)
        })
      } else {
        resolve(x)
      }
    } catch (e) {
      if (called) return
      called = true
      reject(e)
    }
  } else {
    resolve(x)
  }
}