做题

["1", "2", "3"].map(parseInt);
//结果是什么？
//您实际得到的是 [1, NaN, NaN] ,因为parseInt需要两个参数（val，基数）并map传递3（元素，索引，数组）;

[typeof null, null instanceof Object];
//结果是什么？
//您实际得到的是 ['object', false], typeof 对于本机不可调用的对象，将始终返回“对象”。

[ [3,2,1].reduce(Math.pow), [].reduce(Math.pow) ] 
//结果是什么？
//您实际得到的是 an error ,根据规格：在没有初始值引发的空数组上减少 TypeError;

var val = 'smtg';
console.log('Value is ' + (val === 'smtg') ? 'Something' : 'Nothing'); 
//结果是什么？
//您实际得到的是 Something ,+运算符的优先级高于三元运算符;

var name = 'World!';
(function () {
    if (typeof name === 'undefined') {
        var name = 'Jack';
        console.log('Goodbye ' + name);
    } else {
        console.log('Hello ' + name);
    }
})();
//结果是什么？
//您实际得到的是 Goodbye Jack,因为在函数里面有name这个属性，用var声明提升到功能
//范围，所以此时的name就是undefined;

          
var END = Math.pow(2, 53);
var START = END - 100;
var count = 0;
for (var i = START; i <= END; i++) {
    count++;
}
console.log(count);
//结果是什么？
//它会进入无限循环，2 ^ 53是javascript中可能的最高数字，2 ^ 53 + 1给出2 ^ 53，所以i永远不会变得更大。

var ary = [0,1,2];
ary[10] = 10;
ary.filter(function(x) { return x === undefined;});
//结果是什么？
//您实际得到的是[],Array.prototype.filter 不为缺少的元素调用。

var two   = 0.2
var one   = 0.1
var eight = 0.8
var six   = 0.6
[two - one == one, eight - six == two]
//结果是什么？
//您实际得到的是[true, false],JavaScript没有精确数学，即使有时它可以正确运行。

function showCase(value) {
    switch(value) {
    case 'A':
        console.log('Case A');
        break;
    case 'B':
        console.log('Case B');
        break;
    case undefined:
        console.log('undefined');
        break;
    default:
        console.log('Do not know!');
    }
}
showCase(new String('A'));
//结果是什么？
//您实际得到的是Do not know!,switch===内部使用和new String(x) !== x;

function showCase2(value) {
    switch(value) {
    case 'A':
        console.log('Case A');
        break;
    case 'B':
        console.log('Case B');
        break;
    case undefined:
        console.log('undefined');
        break;
    default:
        console.log('Do not know!');
    }
}
showCase2(String('A'));
//结果是什么？
//您实际得到的是Case A, String(x) 不创建对象，但返回字符串，即 typeof String(1) === "string"

function isOdd(num) {
    return num % 2 == 1;
}
function isEven(num) {
    return num % 2 == 0;
}
function isSane(num) {
    return isEven(num) || isOdd(num);
}
var values = [7, 4, '13', -9, Infinity];
values.map(isSane);
//结果是什么？
//您实际得到的是[true, true, true, false, false], Infinity % 2Gives NaN，-9 % 2Gives -1（模运算符保留符号，因此其结果仅与0相比是可靠的）

parseInt(3, 8)
parseInt(3, 2)
parseInt(3, 0)
//结果是什么？
//3在base中不存在2，所以显然是a NaN，但是那又怎么样0呢？parseInt我会考虑一个假基，并假设你的意思10，所以它返回3

Array.isArray( Array.prototype )
//结果是什么？
//您实际得到的是true，Array.prototype的结果是array；

var a = [0];
if ([0]) {
  console.log(a == true);
} else {
  console.log("wut");
}
//结果是什么？
//您实际得到的是false，[0]作为布尔值被考虑true，在比较中使用它时，它会以不同的方式转换，因此一切都会陷入困境。

[]==[]
//结果是什么？
//您实际得到的是false，== 是撒旦的产物，引用数据类型的都不能直接相等；

1 + - + + + - + 1
//结果是什么？
//您实际得到的是2；

var ary = Array(3);
ary[0]=2
ary.map(function(elem) { return '1'; });
//结果是什么？
//结果为["1", undefined × 2]，map仅针对Array已初始化的元素调用。

function sidEffecting(ary) {
  ary[0] = ary[2];
}
function bar(a,b,c) {
  c = 10
  sidEffecting(arguments);
  return a + b + c;
}
bar(1,1,1)
//结果是什么？
//结果是21，由于javascript中的变量与arguments对象相关联，因此arguments即使变量不在同一范围内，更改变量也会更改，而更改参数也会更改局部变量。

function getArrange(arr, size) {
    const result = []

    function createTree(rootArr, remainArr, sizeCount) {
        if (remainArr.length <= 0 || sizeCount === 0) {
            result.push(rootArr)
            return
        }
        for (let i = 0; i <= remainArr.length - sizeCount; i += 1) {
            const root = remainArr[i]
            const other = remainArr.slice(i + 1)
            createTree(rootArr.concat(root), other, sizeCount - 1)
        }
    }

    createTree([], arr, size)
    return result
}