一组JavaScript试题(包含一些容易混淆的知识点)

ゝ一世哀愁。 2022-08-20 13:23 206阅读 0赞

今天刷知乎的时候无意间发现的一组JavaScript试题，做了一下...共35道，对14，错17，十分惨痛，在这里整理一下这些题目，梳理一下其中的知识点

[JavaScript专业八级测试，你能做对几道？][JavaScript]

> ["1", "2", "3"].map(parseInt)
    [ 1, NaN, NaN ]

这里涉及到的知识点是parseInt函数

parseInt函数接受两个参数分别为String和radix

第一个参数代表被解析的字符串，第二个参数表示的是要解析的数字的基数，是一个2~36之间的数

注意 如果radix写作0或者省略的话，js解释器会把他当做10来处理，若参数小于2或者大于36，则返回NaN

再来看这个题目，map传递过来的是三个参数(element, index, array)，然而parseInt是只能接受两个参数的

这也就意味着代码执行了这几个步骤

> parseInt("3", 2)
    NaN
    > parseInt("1", 0)
    1
    > parseInt("2",1)
    NaN
    > parseInt("3", 2)
    NaN

> [typeof null, null instanceof Object]
    [ 'object', false ]

typeof对原生非可调用对象会始终返回Object，这里null被认为是一个空的对象引用

[ [3,2,1].reduce(Math.pow), [].reduce(Math.pow)] ]

在一个空数组上执行reduce函数会跑出初始化错误的异常TypeError

> var val = 'smtg';console.log('Value is ' + (val === 'smtg') ? 'Something' : 'Nothing');
    Something

这里涉及到js的运算符优先级，考虑括号中的表达式，得出运算顺序为() , + , ?:

>     (function () {
    ...       if (typeof name === 'undefined') {
    .....         var name = 'Jack';
    .....         console.log('Goodbye ' + name);
    .....       } else {
    .....         console.log('Hello ' + name);
    .....       }
    ...     })();
    Goodbye Jack

变量提升，js解释器会在执行时自动将name的声明提升到if语句之前，此时name并未初始化

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中最大的数，i怎么样也不会比这个数还大，无法跳出循环

>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 ]

检测一下

> 0.8 - 0.6
    0.20000000000000007

JavaScript中没有精准的数字，浮点数值的最高精度是17位小数，但在进行算数运算时精度远远不及整数，因此，永远不要测试某个特定的浮点数值

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'));

output: Do not know!

首先要清楚的是switch是用===来枚举的，而new String('A')实际上是调用String构造函数创建了一个对象

10.

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!');
          }
        }
        showCase(String('A'));

output：Case A

11.

> 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 ]

\-9 / 2 = -1; Infinity % 2 = NaN

12.

>     parseInt(3, 8)
    3
    >     parseInt(3, 2)
    NaN
    >     parseInt(3, 0)
    3

0会被当做10来处理

13.

> Array.isArray( Array.prototype )
    true

14.

var a = [0];
        if ([0]) { 
          console.log(a == true);
        } else { 
          console.log("wut");
        }
    false

首先可以看一下下面两个语句

> Boolean([0])
    true
    > [0] == true
    false

可见，\[0\]被当做true却又不等同于true

15.

> [] == []
    false

这两个\[\]代表不同的对象

16.

> '5' + 3
    '53'
    > '5' - 3
    2

String会处理加法，这里将3转化为字符串

遇到减法的话则把字符串转化为数字

可以结合一下两个语句理解一下

> 1 + 2 + 3 + '1234567'
    '61234567'
    > '5' + 3 + 4 + '222'
    '534222'

17.

> 1 + - + + + - + 1
    2

1+后面的运算符全部被当做后面的1的正负号来处理

修改一下 出现以下的现象

> 1 + - + + + - - 1
    0

18.

var ary = Array(3);
    ary[0]=2
    ary.map(function(elem) { return '1'; });
        
    ["1", undefined × 2]

map只对初始化过的数组成员调用

19.

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

arguments为\[1，1，10\]

20.

bar(1,1,1)
    21
    var a = 111111111111111110000,
    b = 1111;
    a + b;
        
    111111111111111110000

不精确的JavaScript会影响小数，也会影响大数

21.

> Number.MIN_VALUE > 0
    true

MIN\_VALUE表示的是最小的比零大的数

22.

> [1 < 2 < 3, 3 < 2 < 1]
    [ true, true ]

隐式转换 true < 3    false < 1

23.

> 2 == [[[2]]]
    true

对象都被转换为String，最后变为‘2’

24.

> 3..toString()
    '3'

相当于3.0.toString()

25.

(function(){
          var x = y = 1;
        })();
    console.log(y);
    console.log(x);
    1, error

(function()\{\})()模仿了块级作用域，所以x是访问不到的

26.

var a = /123/, b = /123/;
        a == b
        a === b
    false

每个正则表达式都是唯一的

27.

> var a = [1, 2, 3],
    ...      b = [1, 2, 3],
    ...      c = [1, 2, 4]
    
    >     a ==  b
    false
    >     a === b
    false
    >     a > c
    false
    >     a < c
    true

数组通过> <按顺序比较但是== ===不会

28.

var a = {}, b = Object.prototype;
    [a.prototype === b, Object.getPrototypeOf(a) === b]
    [false, true]

Object.prototype = \{\} 而a.prototype = undefined

29.

function f() {}
    var a = f.prototype, b = Object.getPrototypeOf(f);
    a === b
    false

30.

function foo() { }
    var oldName = foo.name;
    foo.name = "bar";
    [oldName, foo.name]
    ["foo", "foo"]

31.

</pre><pre name="code" class="javascript">"1 2 3".replace(/\d/g, parseInt)
    "1 NaN 3"

考虑parseInt的参数，见第一道题目

32.

> function f() {}
    undefined
    >     var parent = Object.getPrototypeOf(f);
    undefined
    >     f.name // ?
    'f'
    >     parent.name // ?
    ''
    >     typeof eval(f.name) // ?
    'function'
    >     typeof eval(parent.name) //  ?
    'undefined'

33.

var lowerCaseOnly =  /^[a-z]+$/;
    [lowerCaseOnly.test(null), lowerCaseOnly.test()]
    [true, true]

test()中的参数会被 转化为字符串

34.

> [,,,].join(", ")
    ', , '

实际上原数组相当于存了三个undefined，最后多了一个逗号，可能这样比较容易理解 var sss = \[1,,2,3,,\];最后一个逗号不影响数组元素

35.

var a = {class: "Animal", name: 'Fido'};
     a.class

有的浏览器中class是保留字，不可作为属性名出现

[JavaScript]: http://ourjs.com/detail/52fb82e13bd19c4814000001