bind()中的第一个参数：调用绑定函数时作为 this 参数传递给目标函数的值。
如果使用new运算符构造绑定函数，则忽略该值

function func (name) {
     console.log(this);
     this.name = name
}
func.prototype.hello = function () {
    console.log(this.name);
}
let obj = {
    a: 1,
    say: function () {
        console.log('say');
    }
}
let newObj = func.bind(obj)
newObj()
//{a:1, say:f} 此时this指向obj

function func (name) {
    console.log(this);
    // func{}
    this.name = name
}
func.prototype.hello = function () {
    console.log(this.name);
}
let obj = {
    a: 1,
    say: function () {
        console.log('say');
    }
}
let newObj = func.bind(obj)
// 若将返回的函数作为构造函数
let o = new newObj('seven')
//this的指向发生了改变，指向原函数，并且可以访问原函数的原型
console.log('o', o);
// func{name:'seven'}
o.hello() // seven

function.bind(thisArg[, arg1[, arg2[, ...]]])

if (!Function.prototype.bind) {
     //防止Function.prototype.bind.call(obj,param)这种调用改变this
   Function.prototype.bind = function(oThis) {
     if (typeof this !== 'function') {
       throw new TypeError('Function.prototype.bind - what is trying to be bound is not 			callable');
     }
     var aArgs   = Array.prototype.slice.call(arguments, 1),
         fToBind = this,
         fNOP    = function() {},
         fBound  = function() {
           // this instanceof fBound === true时,说明返回的fBound被当做new的构造函数调用
           return fToBind.apply(this instanceof fBound
                  ? this
                  : oThis,
                  // 获取调用时(fBound)的传参.bind 返回的函数入参往往是这么传递的
                  aArgs.concat(Array.prototype.slice.call(arguments)));
         };
     // 维护原型关系
     if (this.prototype) {
       // 当执行Function.prototype.bind()时, this为Function.prototype 
       // this.prototype(即Function.prototype.prototype)为undefined
       fNOP.prototype = this.prototype; 
     }
     // 下行的代码使fBound.prototype是fNOP的实例,因此
     // 返回的fBound若作为new的构造函数,new生成的新对象作为this传入fBound,新对象的__proto__就是fNOP的		实例
     fBound.prototype = new fNOP();
     return fBound;
  };}

// 赋值式函数
var foo = function () {
     console.log('foo1');
 }
 foo();  // foo1
 var foo = function () {
     console.log('foo2');
 }
 foo(); // foo2

// 声明式函数
function foo() {
     console.log('foo1');
 }
 foo();  // foo2
 function foo() {
     console.log('foo2');
 }
 foo(); // foo2

//例子1
<script type="text/javascript">
   Fn(); //执行了定义式函数
   function Fn(){
    alert("执行了定义式函数");
   }
</script>

// 例子2
<script type="text/javascript">
   Fn(); //报错，提示函数未定义
  var Fun= function(){
    alert("执行了赋值式函数");
   }
</script>

// 例子3
//因为在js中重名的函数，后定义的会覆盖前面定义的函数，这种策略和js的顺序执行也是有关系的
<script type="text/javascript">
   Fn(); //它执行的结果是：弹出"执行了函数2"
   function Fn(){
    alert("执行了函数1");
   }
   function Fn(){
    alert("执行了函数2");
   }
</script>

//单个函数执行的时候有执行机上下文，多个函数执行的时候有执行上下文栈 
function fun3() {
    console.log('fun3')
 }
 function fun2() {
     fun3();
 }
 function fun1() {
     fun2();
 }
 fun1();
// 伪代码
// fun1()ECStack.push(<fun1> functionContext); -- fun1进栈
// fun1中竟然调用了fun2，还要创建fun2的执行上下文ECStack.push(<fun2> functionContext); -- fun2进栈
// 擦，fun2还调用了fun3！ECStack.push(<fun3> functionContext); -- fun3进栈
// fun3执行完毕ECStack.pop(); -- fun3出栈
// fun2执行完毕ECStack.pop(); -- 。。
// fun1执行完毕ECStack.pop(); -- 。。
// javascript接着执行下面的代码，但是ECStack底层永远有个globalContext

AO = {
    arguments: {
        0: 1,
        length: 1
    },
    a: 1,
    b: undefined,
    c: reference to function c(){}, // 函数提升
    d: undefined
}

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

function foo() {
    function bar() {
        ...
    }
}

//scope可以理解为函数在创建时的一个属性
foo.[[scope]] = [
    globalContext.VO // -- globalContext位于栈底，Vo里存放变量，这就是所有函数为什么能够拿到window变量的原因
];

bar.[[scope]] = [
    fooContext.AO,// bar套在foo中，所以能拿到foo的AO，(定义bar的时候,foo已经执行了)
    globalContext.VO // window的AO与VO相同，不需要激活
];

function foo() {
    var a = 10
    function bar() {
        var b = 20
        console.dir(bar)
    }
    bar()
}
foo()
console.dir(foo)

ScopeChain = [AO].concat([[Scope]]);

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

ECStack = [
   globalContext
];

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

checkscope.[[scope]] = [
    globalContext.VO
];

ECStack = [
      checkscopeContext,
      globalContext
];

复制函数 [[scope]] 属性创建作用域链，
用 arguments 创建活动对象，
初始化活动对象，即加入形参、函数声明、变量声明，
将活动对象压入 checkscope 作用域链顶端。
同时 f 函数被创建，保存作用域链到 f 函数的内部属性[[scope]]

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

ECStack = [
       fContext,
       checkscopeContext,
       globalContext
];

复制函数 [[scope]] 属性创建作用域链
用 arguments 创建活动对象
初始化活动对象，即加入形参、函数声明、变量声明
将活动对象压入 f 作用域链顶端

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

ECStack = [
        globalContext
];

var scope = "global scope";
function checkscope(){
     var scope = "local scope";
     function f(){
         return scope;
     }
     return f;
}
var foo = checkscope();
foo();

fContext = {
     Scope: [AO, checkscopeContext.AO, globalContext.VO],
}

Function.prototype.call2 = function (context) {
     var context = context || window;
     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;
}

Function.prototype.apply = function (context, arr) {
     var context = Object(context) || window;
     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;
}

function objectFactory() {
    var obj = new Object(),
    Constructor = [].shift.call(arguments);
    obj.__proto__ = Constructor.prototype;
    var ret = Constructor.apply(obj, arguments);
    return typeof ret === 'object' ? ret : obj;
};
function Otaku (name, age) {
    this.name = name;
     this.age = age;
 
     this.habit = 'Games';
 }
 Otaku.prototype.strength = 60;
 Otaku.prototype.sayYourName = function () {
     console.log('I am ' + this.name);
}
var person = objectFactory(Otaku, 'Kevin', '18')
console.log(person.name) // Kevin
console.log(person.habit) // Games
console.log(person.strength) // 60
console.log(person.age) // 18
console.log(person.sayYourName())//I am Kevin

//乞丐版：完整版很深
var curry = function (fn) {
     var args = [].slice.call(arguments, 1);
     return function() {
         var newArgs = args.concat([].slice.call(arguments));
        return fn.apply(this, newArgs);
    };
};
function add(a, b) {
    return a + b;
}
var addCurry = curry(add, 1, 2);
addCurry() // 3//或者var addCurry = curry(add, 1);addCurry(2) // 3//或者var addCurry = curry(add);addCurry(1, 2) // 3

function Rectangle(length,width){
    this.l = length
    this.w = width
}
Rectangle.prototype.getArea = function(){
     return this.l*this.w
}
function Square(length){
    Rectangle.call(this,length,length)
}
Square.prototype = Object.create(Rectangle.prototype,{
     constructor:{
     	value:Square
    }
}) // 相当于Rectangle.prototype.constructor = Square
var square = new Square(3)
console.log(square.getArea())
console.log(square instanceof Square)
console.log(square instanceof Rectangle)

/**
 * 防抖函数的自定义实现
 * @param func 执行的函数
 * @param wait 等待的时间
 * @param immediate 是否立即执行
 */
function debounce (func, wait, immediate) {
  // result -- 返回值
  let timeout, result;
  let debounced = function () {
    let self = this
    let args = arguments
    if(timeout) clearTimeout(timeout)
    if (immediate) {
      // callNow是立即执行的变量
      let callNow = !timeout
      timeout = setTimeout(() => {
        timeout = null
      }, wait)
      // 由于最开始timeout为undefined,取反为true,故立即执行
      if (callNow) result = func.apply(self, args)
    } else {
      // 不会立即执行
      timeout = setTimeout(function() {
        //解决执行函数内部this指向问题以及event指向问题
        result = func.apply(self, args)
      }, wait)
    }
    return result
  }
  // 取消
  debounced.cancel = function () {
    clearTimeout(timeout)
    timeout = null // 防止内存泄露
  }
  return debounced
}

/**
 * 节流函数 -- 初步实现 -- 第一次会触发，最后一次不会触发
 * @param func 执行的函数
 * @param wait 等待的时间
 */
function trottle (func, wait) {
  let context, args
  // 之前的时间戳
  let old = 0 // 默认为0
  return function () {
    context = this
    args = arguments
    // 获取当前的时间戳
    let now = new Date().valueOf()
    if (now-old > wait) {
      // 立即执行
      func.apply(context, args)
      old = now
    }
  }
}

/**
 * 节流函数 -- 第一次不会触发，最后一次会触发
 */
function trottle (func, wait) {
  let context, args, timeout
  return function () {
    context = this
    args = arguments
    if (!timeout) {
      timeout = setTimeout(() => {
        timeout = null
        func.apply(context, args)
      }, wait)
    }
  }
}

/**
 * 节流函数
 * 第一次会触发，最后一次会触发
 */
function trottle (func, wait) {
  let context, args, timeout
  let old = 0 // 时间戳
  let later = function () {
    old = new Date().valueOf()
    timeout = null
    func.apply(context, args)
  }
  return function () {
    context = this
    args = arguments
    let now = new Date().valueOf()
    if (now - old > wait) {
      if (timeout) {
        clearTimeout(timeout)
        timeout = null 
      }
      func.apply(context, args)
      old = now
    }

    if (!timeout) {
      timeout = setTimeout(later, wait)
    }
  }
}

/**
 * 节流函数
 * 最终版本
 * 第一次不会触发，最后一次会调用 leading:false, trailing:true
 * 第一次会触发，最后一次不会触发 leading:true, trailing:false
 */
function trottle (func, wait, options) {
  let context, args, timeout, result
  let old = 0 // 时间戳
  if (!options) options = {} 
  let later = function () {
    old = new Date().valueOf()
    timeout = null
    result = func.apply(context, args)
  }
  let trottled = function () {
    context = this
    args = arguments
    let now = new Date().valueOf()
    if (options.leading === false  && !old) {
      old = now;
    }
    if (now - old > wait) {
      if (timeout) {
        clearTimeout(timeout)
        timeout = null 
      }
      result = func.apply(context, args)
      old = now
    }

    if (!timeout && options.trailing !== false) {
      timeout = setTimeout(later, wait)
    }
    return result
  }
  trottled.cancel = function () {
    clearTimeout(timeout)
    timeout = null
  }
  return trottled
}

Object.assign(target, ...sources)
let target = {}
Object.assign(target, source)
target.a === source.a // true

typeof x; // ReferenceError -- 声明在后导致出错
let x;

typeof undeclared_variable // "undefined"  -- 若一个变量根本没有声明，倒不会报错

// 考烂了的面试题
typeof null === 'object' // true

String instanceof String // false
Function instanceof Function // true
Object instanceof Object // true
Function instanceof Object // true

let d = JSON.parse(JSON.stringify(x)) // 将x深拷贝给d

function deepCopy( obj ){
    if (typeof obj === 'object') {
        if (obj.constructor === Array) {
            var newArr = []
            for (var i = 0; i < obj.length; i++) {
                newArr.push(obj[i])
            }
        } else {
            var newObj = {}
            for (var key in obj) {
                newObj[key] = this.deepCopy(obj[key])
            }
            return newObj
        }
    } else {
        return obj
    }
}

// 面试版本
// 判断是不是一个复杂类型
const isComplexDataType = obj => (typeof obj === 'object' || typeof obj === 'function') && 				(obj !== null)
const deepCopy = function (obj, hash= new WeakMap()) {
     if (hash.has(obj)) return hash.get(obj);
     let type = [Date, RegExp, Set, Map, WeakMap, WeakSet];
     if (type.includes(obj.constructor)) return new obj.constructor(obj);
     // 如果成环了，参数obj = obj.loop = 最初的obj 会在WeakMap中找到第一次放入的obj提前返回第一次放入		WeakMap的cloneObj
     let allDesc = Object.getOwnPropertyDescriptors(obj) // 遍历传入参数所有键的特性
     let cloneObj = Object.create(Object.getPrototypeOf(obj), allDesc) // 继承原型
     hash.set(obj, cloneObj)
     for (let key of Reflect.ownKeys(obj)) { //Reflect.ownKeys可以拷贝不可枚举属性和符号类型
     // 如果值是引用类型则递归调用deepClone
     cloneObj[key] = 
          (isComplexDataType(obj[key]) && typeof obj[key] !== 'function') ? 							deepCopy(obj[key], hash) : obj[key];
     }
     return cloneObj
}

// 测试用例
let obj = {
    bigInt: BigInt(12312),
    set: new Set([2]),
    map: new Map([['a', 222], ['b', 33]]),
    num: 0,
    str: '',
    boolean: true,
    unf: undefined,
    nul: null,
    obj: {
        name: '我是一个对象',
        id: 1
    },
    arr: [1,2,3],
    func: function() {
        console.log('我是一个函数');
    },
    date: new Date(0),
    reg: new RegExp('/我是一个正则/ig'),
    [Symbol('1')] : 1
}
Object.defineProperty(obj, 'innumerable', {
    enumerable: false,
    value: '不可枚举属性'
})
obj = Object.create(obj, Object.getOwnPropertyDescriptors(obj)) 
obj.loop = obj
console.log(obj);
let cloneObj = deepCopy(obj)
console.log('cloneObj', cloneObj);
for (let key of Object.keys(cloneObj)) {
    if (typeof cloneObj[key] === 'object' || typeof cloneObj[key] === 'function') {
        console.log(`${key}相同吗?`, cloneObj[key] === obj[key]);
    }
}