Re：从壹开始的Js淦原理

Array.prototype.adFlat = function(deep) {
	return deep > 0 ? this.reduce((total, item, index) => {
		return total.concat(Array.isArray(item) ? item.adFlat(deep - 1) : item)
	}, []) : this.slice()
}

//call\apply
Function.prototype.adCall = function() {
	//如果是apply，将 [pointer, ...args] 改为 [pointer, args]
	let [pointer, ...args] = [...arguments], //将传入参数解析成指针和其他参数
	fn = Symbol(); //创建独立名称
	pointer = Object(pointer) || window; //将传入指针转换成实例对象
	pointer[fn] = this; //向创建对象添加fn独立方法
	let rel = pointer[fn](...args); //将执行结果赋值
	delete pointer[fn]; //删除之前添加进指针对象的方法
	return rel; //返回执行结果
}
//bind
Function.prototype.adBind = function(pointer, ...args) {
	return (...newagrs) => this.call(pointer, ...args, ...newagrs) //方法返回一个方法，传入两次传入的参数
}

function _new(fn, ...args) {
	let obj = {}; // 创建一个空对象
	obj.__proto__ = fn.prototype; // 空对象原型指向构造函数原型
	fn.call(obj, ...args); // 改变指向并执行构造函数
	return obj; // 返回新对象
}

function instanceOf(leftVal, rightVal) {
	if (typeof leftVal != 'object' || leftVal === null) return false;
	let leftPro = leftVal.__proto__, // 获取实例化内容的原型
		rightPro = rightVal.prototype; // 获取原型
	while (true) { // 深度向上寻找原型，直到顶层Object.prototype
		if (leftPro === null) return false;
		if (leftPro === rightPro) return true;
		leftPro = leftPro.__proto__
	}
}

function parse (json) {
    // 此处的括号是为了表明内部执行内容为一个整体，就像箭头函数简写返回一个对象也需要括号包裹一样
    return eval("(" + json + ")"); 
}

// 此处伪代码并未考虑抛错，如需了解请看下一个代码块
function generatorToAsync(generatorFn) {
	return function() {
		return new Promise((resolve, reject) => {
			const g = generatorFn()
			const handler = (res) => {
				const cb = g.next(res).value
				if (typeof cb.then === 'function') {
					cb.then(res => handler(res))
				} else {
					resolve(res)
				}
			}
			g.next().value.then(handler)
		})
	}
}
 
function fn(nums) {
	return new Promise(resolve => {
		setTimeout(() => {
			resolve(nums * 2)
		}, 1000)
	})
}
 
const asyncFn = generatorToAsync(function*() {
	const num1 = yield fn(1)
	console.log('1 end');
	const num2 = yield fn(num1)
	console.log('2 end');
	const num3 = yield fn(num2)
	console.log('3 end');
	return num3
})
asyncFn().then(res => console.log(res)) // 3秒后输出 8

function generatorToAsync(generatorFn) {
	return function() {
		const gen = generatorFn.apply(this, arguments) // gen有可能传参
		// 返回一个Promise
		return new Promise((resolve, reject) => {
			function go(key, arg) {
				let res
				try {
					res = gen[key](arg) // 这里有可能会执行返回reject状态的Promise
				} catch (error) {
					return reject(error) // 报错的话会走catch，直接reject
				}
				// 解构获得value和done
				console.log(res);
				const {
					value,
					done
				} = res
				if (done) {
					// 如果done为true，说明走完了，进行resolve(value)
					return resolve(value)
				} else {
					// 如果done为false，说明没走完，还得继续走
					// value有可能是：常量，Promise，Promise有可能是成功或者失败
					return Promise.resolve(value).then(val => go('next', val), err => go('throw', err))
				}
			}
			go("next") // 第一次执行
		})
	}
}

function is(x, y) {
	if (x === y) {
		// 防止 -0 和 +0
		return x !== 0 || 1 / x === 1 / y
	}
	// 防止NaN
	return x !== x && y !== y
}
console.log(is(0, -0)); // false