1 ES6中的map和原生的對(duì)象有什么區(qū)別

JavaScript 的對(duì)象（Object），本質(zhì)上是鍵值對(duì)的集合（Hash 結(jié)構(gòu)），但是傳統(tǒng)上只能用字符串當(dāng)作鍵。這給它的使用帶來(lái)了很大的限制。
ES6 提供了 Map 數(shù)據(jù)結(jié)構(gòu)。它類(lèi)似于對(duì)象，也是鍵值對(duì)的集合，但是“鍵”的范圍不限于字符串，各種類(lèi)型的值（包括對(duì)象）都可以當(dāng)作鍵。也就是說(shuō)，Object 結(jié)構(gòu)提供了“字符串—值”的對(duì)應(yīng)，Map 結(jié)構(gòu)提供了“值—值”的對(duì)應(yīng)，是一種更完善的 Hash 結(jié)構(gòu)實(shí)現(xiàn)。如果你需要“鍵值對(duì)”的數(shù)據(jù)結(jié)構(gòu)，Map 比 Object 更合適。

2 sum(2, 3)實(shí)現(xiàn)sum(2)(3)的效果

function sum(){
    var num = arguments[0];
    if(arguments.length==1){
        return function(sec){
            return num+sec;
        }
    }else{
        var num = 0;
        for(var i = 0;i<arguments.length;i++){
            num = num + arguments[i];
        }
    return num;
    }
}

3 兩個(gè)對(duì)象如何比較

 
function isFunction(obj) {
    return toString.call(obj) === '[object Function]'
}
 
function eq(a, b, aStack, bStack) {
 
    // === 結(jié)果為 true 的區(qū)別出 +0 和 -0
    if (a === b) return a !== 0 || 1 / a === 1 / b;
 
    // typeof null 的結(jié)果為 object ，這里做判斷，是為了讓有 null 的情況盡早退出函數(shù)
    if (a == null || b == null) return false;
 
    // 判斷 NaN
    if (a !== a) return b !== b;
 
    // 判斷參數(shù) a 類(lèi)型，如果是基本類(lèi)型，在這里可以直接返回 false
    var type = typeof a;
    if (type !== 'function' && type !== 'object' && typeof b != 'object') return false;
 
    // 更復(fù)雜的對(duì)象使用 deepEq 函數(shù)進(jìn)行深度比較
    return deepEq(a, b, aStack, bStack);
};
 
function deepEq(a, b, aStack, bStack) {
 
    // a 和 b 的內(nèi)部屬性 [[class]] 相同時(shí) 返回 true
    var className = toString.call(a);
    if (className !== toString.call(b)) return false;
 
    switch (className) {
        case '[object RegExp]':
        case '[object String]':
            return '' + a === '' + b;
        case '[object Number]':
            if (+a !== +a) return +b !== +b;
            return +a === 0 ? 1 / +a === 1 / b : +a === +b;
        case '[object Date]':
        case '[object Boolean]':
            return +a === +b;
    }
 
    var areArrays = className === '[object Array]';
    // 不是數(shù)組
    if (!areArrays) {
        // 過(guò)濾掉兩個(gè)函數(shù)的情況
        if (typeof a != 'object' || typeof b != 'object') return false;
 
        var aCtor = a.constructor,
            bCtor = b.constructor;
        // aCtor 和 bCtor 必須都存在并且都不是 Object 構(gòu)造函數(shù)的情況下，aCtor 不等于 bCtor， 那這兩個(gè)對(duì)象就真的不相等啦
        if (aCtor !== bCtor && !(isFunction(aCtor) && aCtor instanceof aCtor && isFunction(bCtor) && bCtor instanceof bCtor) && ('constructor' in a && 'constructor' in b)) {
            return false;
        }
    }
 
 
    aStack = aStack || [];
    bStack = bStack || [];
    var length = aStack.length;
 
    // 檢查是否有循環(huán)引用的部分
    while (length--) {
        if (aStack[length] === a) {
            return bStack[length] === b;
        }
    }
 
    aStack.push(a);
    bStack.push(b);
 
    // 數(shù)組判斷
    if (areArrays) {
 
        length = a.length;
        if (length !== b.length) return false;
 
        while (length--) {
            if (!eq(a[length], b[length], aStack, bStack)) return false;
        }
    }
    // 對(duì)象判斷
    else {
 
        var keys = Object.keys(a),
            key;
        length = keys.length;
 
        if (Object.keys(b).length !== length) return false;
        while (length--) {
 
            key = keys[length];
            if (!(b.hasOwnProperty(key) && eq(a[key], b[key], aStack, bStack))) return false;
        }
    }
 
    aStack.pop();
    bStack.pop();
    return true;
 
}
 
console.log(eq(0, 0)) // true
console.log(eq(0, -0)) // false
 
console.log(eq(NaN, NaN)); // true
console.log(eq(Number(NaN), Number(NaN))); // true
 
console.log(eq('Curly', new String('Curly'))); // true
 
console.log(eq([1], [1])); // true
console.log(eq({ value: 1 }, { value: 1 })); // true
 
var a, b;
 
a = { foo: { b: { foo: { c: { foo: null } } } } };
b = { foo: { b: { foo: { c: { foo: null } } } } };
a.foo.b.foo.c.foo = a;
b.foo.b.foo.c.foo = b;
 
console.log(eq(a, b)) // true

4 如何設(shè)計(jì)Promise.all()

  return new Promise(function(resolve, reject) {
    if (!isArray(promises)) {
      return reject(new TypeError('arguments must be an array'));
    }
    var resolvedCounter = 0;
    var promiseNum = promises.length;
    var resolvedValues = new Array(promiseNum);
    for (var i = 0; i < promiseNum; i++) {
      (function(i) {
        Promise.resolve(promises[i]).then(function(value) {
          resolvedCounter++
          resolvedValues[i] = value
          if (resolvedCounter == promiseNum) {
            return resolve(resolvedValues)
          }
        }, function(reason) {
          return reject(reason)
        })
      })(i)
    }
  })
}