1 手写instanceof

function _instanceof(A, B) {
    var O = B.prototype;// 取B的显现原型
    A = A.__proto__;// 取A的隐式原型
    while (true) {
        //Object.prototype.__proto__ === null
        if (A === null)
            return false;
        if (O === A)// 这里重点：当 O 严厉即是 A 时，返回 true
            return true;
        A = A.__proto__;
    }
}

2 深拷贝

   function deepClone(data) {
        if(typeof data === "object" && data !== null){
            var type = data.constructor;
            var result = new type();
            for (var key in data) {
                if (data.hasOwnProperty(key)) {
                    result[key] = deepClone(data[key]);
                }
            }
            return result;
        }
        return data;
    }

3 数组降维

var arr = [1, 2, [3]];
var res = Array.prototype.concat.apply([], arr);
console.log(res);
var arr2 = [1];
console.log(111);
console.log(arr2.concat(11));

// es6 
let flatten = arr => arr.reduce((begin,current)=>{
        Array.isArray(current)?
        begin.push(...flatten(current)):
        begin.push(current);
        return begin
    },[])

4 tofixed返回string

let aa = 10937843.44;
console.log(typeof aa.toFixed(3));

5 函数声明和函数表达式

let test = function aa(){} //  这是一个表达式，表达式疏忽名字的 
let test1 = function(){}
console.log(test) 
console.log(test.name) // aa 
console.log(test1.name) //test1 
console.log(aa)

6 函数形参和实参

function tmp(a,b){
  console.log(tmp.length) // 2 示意函数形参的个数 
}
tmp(1)
function sum(a,b,c){
  a = 11;
  console.log(arguments[0]) // 形参和实参映照关联(两个都存在才映照)
  c = 2;
  console.log(arguments[2]) // undefined  
}
sum(1,2)

7 js 实行递次

• 1 语法分析
• 2 预编译 发生在函数实行的前一刻

函数声明团体提拔，变量只是声明提拔
预编译的历程(主如果读变量声明)

// 1. 建立AO对象（Active Object） 
// 2. 查找函数形参及函数内变量声明，形参名及变量名作为AO对象的属性，值为undefined 
// 3. 实参形参相统一，实参值赋给形参 
// 4. 查找函数声明，函数名作为AO对象的属性，值为函数援用
全局的就是GO 就是window 
function test(){
  console.log(b)
  if(a){
    var b = 10; // 不要管if ，预编译看到声明就处置惩罚 
   }
}

• 3 诠释实行