Answer 1

基数为1（1进制）的时候，返回的结果都是NaN，所以parseInt('2', 1)返回结果是NaN
基数为2（2进制）的时候，字符串的值要求是0和1，所以parseInt('3', 2)返回结果是NaN

Answer 2

// o 是对象webSite的引用
function changeObjProperty(o) {
     // 给webSite的属性siteUrl赋值
     o.siteUrl = "http://www.baidu.com"
     // 创建新对象，新引用并赋值给o，下o非上o
     o = new Object()
     // 给新引用添加属性siteUrl并赋值，和webSite无关
     o.siteUrl = "http://www.google.com"
} 
let webSite = new Object();
// webSite 是个对象，以形参传递，传递的是webSite的引用
changeObjProperty(webSite);
console.log(webSite.siteUrl)

Answer 3

jQuery中$.extend没有办法深拷贝存在自身引用的对象，一旦出现自身引用会爆栈的。$.extend对于循环引用的处理并不彻底。
这是我自己的实现方式，比$.extend简单，但是加入了对象自环的处理。

/**
 * obj: 待拷贝的对象
 * target: 目标对象
 * parent: target的各个父级
 * _target: 用来分解target，如果有值，必有_target.target[_target.key] === target，主要用来while赋值用。（出现自引用）
 **/
function deepCopy(obj, target, parent = null, _target = null) {
    target = target || {};

    let _parent = parent;
    while (_parent) {
        if (_parent.parentObj === obj) {
            _target.target[_target.key] = obj;
            // 不能直接给target赋值，否则引用的指针丢失，只能给target的属性赋值
            // target = obj （错！！！）
            // 所以才要把target[key]拆分成target和key
            return;
        }
        _parent = _parent.parent;
    }

    Object.keys(obj).forEach(function(key) {
        let currentCopy = obj[key];
        if (typeof currentCopy === 'object' && currentCopy !== null) {
            target[key] = currentCopy.constructor === Array ? [] : {};
            deepCopy(
                currentCopy,
                target[key],
                {
                    parentObj: obj, // 当前target的直接父级
                    parent: parent // 保存target的所有非直接父级
                },
                {
                    // 把target[key]拆分成target和key，供while赋值，否则对传入的target直接赋值会导致指针丢失
                    target: target,
                    key: key
                }
            );
        } else {
            target[key] = currentCopy;
        }
    });

    return target;
}

Answer 4

5.判断是否为纯净的javascript对象

const isPlainObject = (obj) => (
    obj && typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype
);

isPlainObject({})    // true

isPlainObject(new Date())   // false

6.位运算取整

这是最快的取整方法，位运算取整需要注意的是只是取的整数，如果需要和 Math.floor 结果一致，负数应该再减一

取反操作

const floor = (num) => ((num >= 0) ?  ~~num : (~~num) - 1)

左移运算符

const floor = (num) => (num >= 0) ? (num << 0) : ((num << 0) - 1)

右移运算符

const floor = (num) => (num >= 0) ? (num >> 0) : ((num >> 0) - 1)

异或运算符

const floor = (num) => (num >= 0) ? (num^0) : ((num^0) - 1)

7.使用右移运算符取得整除2的值

右移一位即可

5>>1      // 2

6>>1    // 3

8.将一个字符串重复N次

核心就是使用数组的join方法

方法一

const repeat = (target, n) => (new Array(n + 1)).join(target)

方法二，创建类数组对象

const repeat = (target, n) => (
    Array.prototype.join.call({
        length: n + 1
    }, target)
)

方法三，利用闭包缓存方法与对象

const repeat = (() => {
    const join = Array.prototype.join, obj = {};

    return (target, n) => {
        obj.length = n + 1;
        return join.call(obj, target);
    }
})()

方法四，使用数组的concat方法

function repeat(target, n) {
    return (n <= 0) ? '' : target.concat(repeat(target, --n));
}

方法五，利用算法提高效率，使用二分法

const repeat = (target, n) => {
    let s = target, total = '';
    while(n > 0) {
        if(n % 2 == 1) total += s;
        if(n == 1) break;
        s += s;
        n = n >> 1;
    }
    return total;
}