您的位置:68399皇家赌场 > 服务器租用 > JS特出标题解析

JS特出标题解析

发布时间:2019-05-07 21:55编辑:服务器租用浏览(89)

    本次列举出一些感到有趣的JS标题(来源于出了名的4四题),相信有相当多关于这么些主题素材的博客,写那篇博客的意在加强一些知识点,希望能和读者共同进步。

    原题来自:
    http://javascript-puzzlers.herokuapp.com/

      最近在钻探Javascript发掘了其中壹部分比较灵异的作业。有一点令人认为无语举例:

    原来的文章作者:justjavac

    原稿地址:http://justjavac.com/javascript/2014/02/18/javascript-puzzlers-why-1-2-3-map-parseint-returns-1-NaN-NaN-in-javascript.html

    一. map函数实施进度

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

    答案: [1, NaN, NaN]

    剖析: map(function callback(current, index, array)), map 回掉提供多少个参数,current value, index of current value, array.

    parseInt(value, radix), parseInt 提供四个参数,value 代表须要转移的string,radix代表string原本的进制单位,从二到3陆.

     

    为此那道题的实施进度是那般的:

    array.map(parseInt(value(current), radix(index) )); 回掉会自动按序分配参数

    current => value, index => radix;

     

    忠实推行进度

    array.map(parseInt(1, 0)) => parseInt(一, 0), 0 暗中认可代表十进制。

    parseInt(2, 一), 未有壹进制,所以回来NaN,

    parseInt(三,②), 二进制唯有0,一, 所以同样再次回到NaN

     

    读者能够先去做一下感触感受. 当初小编的成绩是 21/44...

     

    JavaScript Puzzlers!被誉为 javascript 界的行业内部捌级检测,感兴趣的 jser 能够去试试。

    2.[typeof null, null instanceof Object]

    答案: [object, false]

    分析: typeof 再次来到3个代表项目标字符串, typeof null == object.

    instanceof 用来测试叁个对象在其原型链中是还是不是存在1个构造函数的 prototype 属性, 综上可得,null 没有构造函数,所以回来的是false

     

    那时候小编做那套题的时候不仅仅思疑智力商数, 连人生都起来思疑了....

    var arr = [],
        arr2 = {};
    
    console.log(typeof(arr) === typeof(arr2)); // true
    

    本人试了一下, 3六 道题只做对了 1九 道, 算下来正确率为 53%,还尚未合格。

    叁. 运算符优先级

    var val = 'smtg';

    console.log('Value is ' (val === 'smtg') ? 'Something' : 'Nothing')

    答案:Something

    解析: 运算符优先级高于 > ,所以没有括号的情况下, 会先执行字符串连接操作。

    所以等价于 ‘Value is true'? 'Something' : 'Nothing'

    如果搞不清运算符优先级的时候,可以加上括号

     

    可是, 对于基础知识的理解是尖锐编程的前提. 让大家壹道来探视那么些变态题到底变态不改变态吧!

      上方使用typeof比较数组和目的,因为typeof获取NULL、数组、对象的连串都为object,所以console为true。

    第2题为["1", "2", "3"].map(parseInt)的再次来到值。

    4. 稀疏数组与Array.filter

    var ary = [0,1,2];
    ary[10] = 10;
    ary.filter(function(x) { return x === undefined;});
    

    答案:[]

    分析: 那边的ary 是1个疏散数组,index从叁到玖都并未有概念,所以ary[3~9]的值是undefined(可以在chrome tool里通过ary[index]来查阅),那么乍1看那些题的答案应该是回来九个undefined组成的数组。

    不过这里再次回到的是[],原因在于filter函数的功用。

    if (!Array.prototype.filter){
      Array.prototype.filter = function(func, thisArg) {
        'use strict';
        if ( ! ((typeof func === 'Function' || typeof func === 'function') && this) )
            throw new TypeError();
    
        var len = this.length >>> 0,
            res = new Array(len), // preallocate array
            t = this, c = 0, i = -1;
        if (thisArg === undefined){
          while (  i !== len){
            // checks to see if the key was set
            //看这里 看这里
            if (i in this){
              if (func(t[i], i, t)){
                res[c  ] = t[i];
              }
            }
          }
        }
        else{
          while (  i !== len){
            // checks to see if the key was set
            if (i in this){
              if (func.call(thisArg, t[i], i, t)){
                res[c  ] = t[i];
              }
            }
          }
        }
    
        res.length = c; // shrink down array to proper size
        return res;
      };
    }
    

    能够看青古铜色文字下方的代码,filter函数会先决断当前index是还是不是在数组中被安装,就是或不是有ary[index] = value的进程,不然会跳过这几个index。

    故此对于稀疏数组,未定义的index会被跳过,从而致使这道题的答案是[]。 如果有ary[index] = undefined, 那么结果就能是重返由undefined 组成的数组。

    array.filter

    第1题

    var arr = [],
        arr2 = [];
    
    console.log(arr === arr2); // false
    

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

        [1, NaN, NaN]

    5. String('A') 和 new String('A') 的区别

    以下七个代码段的出口结果是?

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

     

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

    答案:‘Do not know!' ; 'Case A'

    剖析:为何五个代码段的输出不平等呢?

    七个原因:一.switch进展比较的时候用的是全等符“===”,所以不会做类型转变,即“十”不会等于十;

    1. new String() 和 String 再次回到的门类差别,前者重回的是object,后者重返的是string,所以在做全等比较的时候,再次来到的结果是false。

    从而假设有亟待用到switch对于字符串做相比较的时候,必要小心传入的参数类型。

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

    下面四个1律的数组相比,因为多少个单身的数组永不相等,所以console为false。

    在javascript中["1", "2", "3"].map(parseInt)为啥重临不是[1,2,3]却是[1,NaN,NaN]?

    陆. 你实在精通"=="吗?

    上面七个代码段的输出是?

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

    答案:false, false

    分析:假使仅仅的把[0]转移成boolean类型的话,结果会是true,所以if判定语句的结果是true。 

    看了多数任何的博客,都有谈到“==”会做类型调换,相比较其值,作者以为这一个答案依然不知道该如何是好详细表明上述代码的结果。

    查看了更多质地后,找到了有的“==“的规则:

    一、要是四个值类型一样,实行 === 比较,相比较规则同上 
    贰、假诺四个值类型不一样,他们大概约等于。依照上边规则实行类型调换再比较: 
    a、借使3个是null、贰个是undefined,那么[相等]。 
    b、如若3个是字符串,四个是数值,把字符串转变来数值再实行相比较。 
    c、假设任一值是 true,把它转换成 1再比较;假如任壹值是 false,把它转变来 0 再比较。 
    d、假诺八个是目的,另二个是数值或字符串,把指标转变到基础项目标值再相比较。对象调换来基础项目,利用它的toString可能valueOf方法。js核心内置类,会尝试valueOf先于toString;例外的是Date,Date利用的是toString转变。非js核心的靶子,令说(比较费心,小编也相当小懂) 
    e、任何其余组成(array数组等),都不对等。

    从而实际”==“的调换规则,并不曾设想的那么轻易,不问可见[0] == true, 应该运用的是规则c, 而[] == [] 应该使用的是平整e.

    最后附上一张”==“相比较的结果图

    www.68399.com 1

     

    知识点:

    var arr = [];
    
    console.log(arr instanceof Object); // true
    console.log(arr instanceof Array); // true
    

    我们第贰回顾一下parseInt()个map()多少个函数的用法:

    7.  Arguments of methods

    function sidEffecting(ary) {
      ary[0] = ary[2];
    }
    function bar(a,b,c) {
      c = 10
      sidEffecting(arguments);
      return a   b   c;
    }
    bar(1,1,1)
    
    function sidEffecting(ary) {
      ary[0] = ary[2];
    }
    function bar(a,b,c=3) {
      c = 10
      sidEffecting(arguments);
      return a   b   c;
    }
    bar(1,1,1)
    

    答案:21, 12

    浅析:第叁个代码段的答案,作者深信很轻易得出。难点是第一个代码段,乍一看结果应该和率先个代码段同样,实则否则,那么是干吗吧?

    骨子里那边分歧的结果是由arguments 这几个指标(arguments 不是数组)产生的,借使函数的参数有暗中认可值的时候,那么arguments那个指标不会追踪参数值的改换,并且只记录传递过来的值。

    故此第四个代码段中,arguments的结果是(壹,1,一),sideEffecting函数得到的结果是ary[0] =1, ary[2] =一; 所以回到a b c = 一 一 十 ==》 1二。越来越多实际情况能够点击下方链接。

    Arguments

    Array/map

    上边使用instanceof推断二个变量是还是不是属于有些对象的实例,因为在JavaScript中数组也是指标的一种,所以七个console都为true。

    parseInt() 函数


    8. 妙趣横生的可比符又来了

    Number/parseInt

     

    概念和用法

    parseInt()函数可分析3个字符串,并赶回多个整数。

    [1 < 2 < 3, 3 < 2 < 1]

    答案: true, true

    解析:1<2<3 等价于1<2=> true; true<3 => 1<3=> true;

    3<2=> false; false<1 => 0<1=> true.

    JavaScript parseInt

    闭包难点

    语法

    parseInt(string, radix)

    参数        描述

    string    必需。要被分析的字符串。

    radix     可选:表示要分析的数字的基数。该值介于 二 ~ 36 之间。

    要是省略该参数或其值为 `0`,则数字将以 拾 为根基来分析。如若它以 `"0x"` 或 `"0X"` 开头,将以 16 为基数。

    要是该参数小于 二 要么高于 36,则 `parseInt()` 将返回 `NaN`。

    玖.变量荣升

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

    答案: 1, error

    解析:那道难题涉及到变量进步的范围,以及赋值语法。

    var x=y=1 也就是于 var x=1; y=一; 这里的y会被升高至全局域,所以的除上述答案。

    var x=一,y=一 约等于var x=1; var y=一, 那样写的话,x,y都以某些变量,不会被提高。

     

    先总结这么几道,之后境遇觉得风趣儿的难点,会不断更新。

    首先, map接受四个参数, 八个回调函数 callback, 1个回调函数的this值

    var elem = document.getElementsByTagName('div'); // 如果页面上有5个div

    for(var i = 0; i < elem.length; i  ) {
        elem[i].onclick = function () {
            alert(i); // 总是5
        };
    }
    

    上面是二个很常见闭包难题,点击任何div弹出的值总是5,因为当您触发点击事件的时候i的值已经是伍,能够用上边格局消除:

    var elem = document.getElementsByTagName('div'); // 如果页面上有5个div
    
    for(var i = 0; i < elem.length; i  ) {
        (function (w) {
            elem[w].onclick = function () {
                alert(w); // 依次为0,1,2,3,4
            };
        })(i);
    }
    

    在绑确定地点击事件外部封装三个立刻推行函数,并将i传入该函数就能够。

    文/劳卜(简书小编)
    初稿链接:
    小说权归我全部,转发请联系我得到授权,并标明“简书小编”。

     

    ["1","2", "3"].map(parseInt) 答案是稍微?

     

    parseInt() 函数能分析多个字符串,并再次回到一个平头,要求五个参数 (val, radix),

    里面 radix 表示要分析的数字的基数。【该值介于 2 ~ 3六之间,并且字符串中的数字不能大于radix才干科学再次回到数字结果值】;

    但这里 map 传了 三 个 (element, index, array),大家重写parseInt函数测试一下是还是不是符合地点的平整。

     

    function parseInt(str, radix) {

       return str '-' radix;

    };

    var a=["1", "2","3"];

    a.map(parseInt);  // ["1-0", "2-1","3-2"] 不可能大于radix

     

    因为二进制里面,未有数字三,导致出现超范围的radix赋值和非法的进制解析,才会回来NaN

    所以["1", "2", "3"].map(parseInt) 答案约等于:[1,NaN, NaN]

     

     

      alert(typeof( NaN == NaN));//结果为假。

      var undefined;

      undefined == null; // true

      [] == false; // true

      [] == ![];   // true

          0 == '';     // true

      2 == true;   // false

         1 == true;   // true

    • undefined与null相等,但不恒等(===)
    •  null的连串是指标,undified的种类是undified.
    • null是二个代表"无"的指标,转为数值时为0;undefined是二个意味着"无"的原始值,转为数值时为NaN
    • null的施用:    (一) 作为函数的参数,表示该函数的参数不是目的。    (贰) 作为靶子原型链的终端。
    • (一)变量被声称了,但尚无赋值时,就等于undefined。 (二) 调用函数时,应该提供的参数未有提供,该参数等于undefined。   

       (3)对象未有赋值的性质,该属性的值为undefined。      (四)函数未有重回值时,默许重返undefined。

    www.68399.com,  把null转变为数字,结果为0。而把undefined转变为数字结果为NaN。

         

    返回值

    回来解析后的数字。

    说明

    当参数radix的值为0,或从不安装该参数时,parseInt()会基于string来判别数字的基数。

    举例:

       壹.壹旦string以"0x"起始,parseInt()会把string的其余部分解析为十6进制的平头。

       二.假若string以0先河,那么 ECMAScript v3允许parseInt()的三个达成把今后的字符解析为8进制或十陆进制的数字。

       3.如果string以 1 ~ 玖的数字开始,parseInt()将把它解析为拾进制的平头。

    晋升和注释

    批注:唯有字符串中的第三个数字会被重临。

    注解:初始和尾声的空格是允许的。

    升迁:如若字符串的第三个字符不能够被转移为数字,那么parseInt()会重回NaN。

    实例

    在本例中,我们将使用parseInt()来分析差异的字符串:

    parseInt("10");// 重临 10 (暗许10进制)

    parseInt("19",10);// 返回 19 (十进制: 10 9)

    parseInt("11",2);// 返回 3 (二进制: 2 1)

    parseInt("17",8);// 返回 15 (八进制: 8 7)

    parseInt("一f",1⑥);// 重临 31 (十陆进制: 1陆 壹伍)

    parseInt("010");// 未定:返回 10 或 8

    其间回调函数接受几个参数 currentValue, index, arrary;

        JS 精度不能纯粹到 0.一 所以  。。。。同时存在于值和差值中

      NaN:当某类型转化为数字退步时,再次来到NaN,表示不是三个数字;NaN不等于任何值,包罗它协和,推断时必要采取isNaN(arg)函数

      reverse();那么些函数是用来张开倒序,那么些从未怎么可说的,所谓倒序正是大的在头里,小的在末端。

      sort();这么些函数是用来对数组进行正序排列的

         <script>标签的defer="defer"属性  defer 属性规定是不是对剧本实行举办延期,直到页面加载结束。

         <script>标签的async="async"属性async的概念和用法(是HTML伍的属性)async 属性规定若是脚本可用,则会异步实行。

      

     

      

      

    console.log(1  "2" "2");//1 "2"先转化为“12”然后进行字符串的相加结果是“122”
    console.log(1   "2" "2");//由于一元运算符“ ”的优先级更高,因此 “2”转换为数值2,然后1 2=3,最后数值和字符串相加,转换为字符串的拼接,结果“32”
    console.log(1  -"1" "2");//先执行取反,变成1-1=0,然后0 “2”,结果“02”
    console.log( "1"   "1" "2");//先执行数值转换,相当于执行1 “1” “2”,结果“112”
    console.log("A"- "B" "2");//先执行"A"- "B"返回NaN,再执行NaN "2"=>"NaN2"
    console.log("A"- "B" 2);//先执行"A"- "B"返回NaN 2,NaN执行加减法均返回NaN
    

     

      【以下那段出自于《javascript权威指南》】总体说来,加法操作符的一言一行表现为:

      (一)假诺内部三个操作数是目标,对象会遵守对象到原始值的调换规则调换为原始类值:日期对象通过toString()方法实行转换,别的对象则透过valueOf()方法推行调换(即使valueOf()方法重临3个原始值的话)。由于一大半目的都不有所可用的valueOf()方法,因此他们会因而toString()方法来进行转换。

      (二)在举办了目的到原始值的转换后,假若内部八个操作数是字符串的话,另三个操作数也会调换为字符串,然后开始展览字符串的连接。

      (三)不然,多少个操作数都将转移为数字(大概NaN),然后进行加法操作。

       三个相比尤其的

    1 {}//{}=>"[object Object]",执行数值和字符串的相加,结果"1[object Object]"
    true true//2,布尔值转换为数字后讲加
    1 undefined//数值转换undefined=>NaN,结果NaN
    1 null//数值转换null=>0,结果1
    

      不过我们要专注undefined、null那两当中央类型是从未别的性质和办法的。所以她们不会调用valueOf()和toString()

    "1" undefined//=>"1undefined"相当于执行字符串拼接
    "1" null//=>"1null"相当于执行字符串拼接
    

     

    /* 例2.2 */
    setTimeout(function() {
        console.log('taskA, asynchronous');
    }, 0);
    console.log('taskB, synchronize');
    //while(true);
    
    -------ouput-------
    taskB, synchronize
    taskA, asynchronous
    

         大家可以看来,放大计时器延时的时刻显明为0,但taskA依旧晚于taskB推行。那是干什么呢?由于电火花计时器是异步的, 异步职责会在时下剧本的富有联合职责实施完才会试行。假若同步代码中带有死循环,就要上例的评释去掉,那么这一个异步任务就不会实施,因为一齐任务阻塞了经过。

    setTimeout 就是大面积的异步回调,此外常见的异步回调即ajax请求

     

    function request(url, param, successFun, errorFun) {
        $.ajax({
            type: 'GET',
            url: url,
            param: param,
            async: true,    //默认为true,即异步请求;false为同步请求
            success: successFun,
            error: errorFun
        });
    }
    request('test.html', '', function(data) {
        //请求成功后的回调函数,通常是对请求回来的数据进行处理
        console.log('请求成功啦, 这是返回的数据:', data);
    },function(error) {
        console.log('sorry, 请求失败了, 这是失败信息:', error);
    });
    

     

     

     

     -->函数重载

      

    一js中尚无重载的概念,当遇到多少个重名的法子后,最终一个艺术定义会覆盖后面的兼具办法定义

    2利用arguments达成js函数重载:通过arguments对象足以决断用户在调用函数时,是不是传递了参数,以及传递了多少个参数,也便是C#中的params,它是用起来像数组的叁个目的,但arguments对象自己并不是数组对象。

    ③ 例子

    function add(){
        var sum = 0;
        for(var i =0; i < arguments.length; i  ){
            sum  = arguments[i];
        }
    }
    

    map 方法


    对数组的各样成分调用定义的回调函数并赶回包括结果的数组。

    array1.map(callbackfn[, thisArg])

    参数                      定义

    array一              必需。八个数组对象。

    callbackfn           必需。一个承受**最多**多个参数的函数。对于数组中的每种成分,`map` 方法都会调用 `callbackfn` 函数1遍。

    thisArg             可选:可在 `callbackfn` 函数中为其引用 `this` 关键字的靶子。假若省略 `thisArg`,则 `undefined` 将用作 `this` 值。

    而难点中, map只传入了回调函数--parseInt.

    返回值

    当中的种种成分均为关联的原始数组元素的回调函数再次回到值的新数组。

    异常

    一旦callbackfn参数不是函数对象,则将掀起TypeError十分。

    支持, parseInt 只接受四个八个参数 string, radix(基数).

    备注

    对此数组中的各类成分,map方法都会调用callbackfn函数一回(采取升序索引顺序)。 不为数组中缺点和失误的成分调用该回调函数。

    除开数组对象之外,map方法可由全体length属性且具有已按数字编写制定索引的属性名的任何对象使用。

    可选。表示要分析的数字的基数。该值介于 二 ~ 36 之间。
    借使省略该参数或其值为 0,则数字将以 十 为底蕴来分析。若是它以 “0x” 或 “0X” 初叶,将以 1陆 为基数。
    假定该参数小于 2 可能超越 3陆,则 parseInt() 将赶回 NaN。

    回调函数语法

    回调函数的语法如下所示:

    function callbackfn(value, index, array1)

    可应用最多多个参数来声称回调函数。

    下表列出了回调函数参数。

    回调参数     定义

    value      数组成分的值。

    index      数组成分的数字索引。

    array壹       包括该因素的数组对象。

    所以本题即问

    修改数组对象

    数组对象可由回调函数修改。

    下表描述了在map方法运营后修改数组对象所获得的结果。

    `map` 方法运维后的规则         元素是还是不是传递给回调函数

    在数组的本来面目长度之外添英镑素。     否。

    添欧成分以填充数组中贫乏的成分。    是,如果该索引尚未传递给回调函数。

    要素被改成。              是,假设该因素尚未传递给回调函数。

    从数组中去除元素。           否,除非该因素已传递给回调函数。

    示例

    上面包车型客车示范阐释了map方法的用法。

    // 定义回调函数

    // 计算圆的面积

    function AreaOfCircle(radius){

      var area = Math.PI * (radius * radius);

      return area.toFixed(0); 

    }

    // 定义1个数组,保养两个成分

    var radii = [10, 20, 30];

    // 计算 radii 的面积.

    var areas = radii.map(AreaOfCircle);

    document.write(areas);// 输出:

    // 314,1257,2827

    上边包车型地铁亲自过问阐释thisArg参数的用法,该参数钦命对其引用this关键字的对象。

    // 定义3个目的 object,爱护 divisor 属性和 remainder 方法

    // remainder 函数求每一种传入的值的个位数。(即除以 十 取余数)

    var obj = {   

       divisor:10,   

       remainder: function(value){

        returnvalue %this.divisor;    

      } 

    }

    // 定义三个涵盖 肆 个因素的数组

    var numbers = [6,12,25,30];

    // 对 numbers 数组的各种成分调用 obj 对象的 remainder 函数。

    // map 函数的第 二 个参数字传送入 ogj。

    var result = numbers.map(obj.remainder, obj);

    document.write(result);

    // 输出:

    // 6,2,5,0

    在底下的演示中,内置 JavaScript 方法用作回调函数。

    // 对数组中的每一种成分调用 Math.sqrt(value) (求平方根)

    var numbers = [9,16];

    var result = numbers.map(Math.sqrt);

    document.write(result);

    // 输出: 3,4

    [9, 16].map(Math.sqrt)回调函数,输出的结果是[3, 4]。

    只是为何["1", "2", "3"].map(parseInt)却返回[1,NaN,NaN]?

    网址提交的提醒是:

    what you actually get is[1, NaN, NaN]becauseparseInttakes two parameters(val, radix)andmappasses 3(element, index, array)

    简轻松单翻译一下便是

    parseInt需要 2 个参数(val, radix), 而map传递了 3 个参数(element, index, array)」。

    由此地点的疏解,大家得以见到,假如想让parseInt(string, radix)返回NaN,有三种情况:

      1.先是个参数无法转换来数字。

      二.次之个参数不在 贰 到 3陆 之间。

    我们传入的参数都能调换到数字,所以只能是第3种恐怕。

    毕竟是否吧?我们再度定义parseInt(string, radix)函数:

    var parseInt = function(string, radix){

      return string "-" radix;

    };

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

    出口结果为:

    ["1-0", "2-1", "3-2"]

    映爱护帘,map函数将数组的值value传递给了parseInt的率先个参数,将数组的目录传递给了第3个参数。

    其多少个参数呢?大家再加一个参数

    var parseInt = function(string, radix, obj){

      return string "-" radix "-" obj;

    };

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

    出口结果:

    ["1-0-1,2,3", "2-1-1,2,3", "3-2-1,2,3"]

    我们再持续追加参数:

    var parseInt = function(string, radix, obj, other){

      return string "-" radix "-" obj "-" other;

    };

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

    输出结果:

    ["1-0-1,2,3-undefined", "2-1-1,2,3-undefined", "3-2-1,2,3-undefined"]

    第4个参数为undefined,看见map确实为parseInt传递了四个参数。就如小编写道的:

    (element, index, array)

      壹.数组的值

      二.数组的目录

      3.数组

    UPDATE 原来的作品修正:(多谢米粽粽提醒)

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

    有道是相应的是:

    [parseInt("1", 0),  parseInt("2", 1),  parseInt("3", 2)]

    parseInt("叁", 二)的第贰个参数是界于 2-3陆 之间的,之所以重回NaN是因为 字符串"三"里面没有合法的二进制数,所以NaN。

    我们还是能够承继试验:

    > ["1","1","1","1","1","1","1","1","1","1","1","1","1","1","1","1"].map(parseInt)

       [1,NaN,1,1,1,1,1,1,1,1,1,1,1,1,1,1]

    唯有当第二个参数是一的时候回来NaN,其余情形都回去一。

    > ["1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16"].map(parseInt)        

       [1,NaN,NaN,NaN,NaN,NaN,NaN,NaN,NaN,9,11,13,15,17,19,21]

    回顾列举一下:

    parseInt("1",0); // 十进制 1

    parseInt("二",1); // 第三个参数不在 2-3陆 直接

    parseInt("3",2); // 二进制 NaN

    parseInt("4",3); // 三进制

    parseInt("5",4);

    parseInt("6",5);

    parseInt("7",6);

    parseInt("8",7);

    parseInt("9",8);

    parseInt("10",9); // 九进制 (1*9 0 = 9)

    parseInt("11",10); // 十进制 (1*10 1 = 11)

    parseInt("12",11);

    parseInt("13",12);

    parseInt("14",13);

    parseInt("15",14);

    parseInt("16",15);

    (全文完)

    parseInt('1', 0);
    parseInt('2', 1);
    parseInt('3', 2);

    先是后两者参数非法.

    所以答案是 [1, NaN, NaN]

    第2题

    [typeof null, null instanceof Object]

    多个知识点:

    Operators/typeof

    Operators/instanceof

    Operators/instanceof(中)

    typeof 再次回到三个意味项目标字符串.

    instanceof 运算符用来检查实验 constructor.prototype 是还是不是存在于参数 object 的原型链上.

    以此题能够一贯看链接... 因为 typeof null === 'object' 自语言之初就是这般....

    typeof 的结果请看下表:

    type result
    Undefined "undefined"
    Null "object"
    Boolean "boolean"
    Number "number"
    String "string"
    Symbol "symbol"
    Host object Implementation-dependent
    Function "function"
    Object "object"

    故此答案 [object, false]

    第3题

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

    知识点:
    Array/Reduce

    arr.reduce(callback[, initialValue])

    reduce接受八个参数, 一个回调, 二个上马值.

    回调函数接受八个参数 previousValue, currentValue, currentIndex, array

    亟待专注的是 If the array is empty and no initialValue was provided, TypeError would be thrown.

    故此第四个表明式会报至极. 第3个表达式等价于 Math.pow(3, 二) => 玖; Math.pow(九, 一) =>玖

    答案 an error

    第4题

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

    三个知识点:

    本文由68399皇家赌场发布于服务器租用,转载请注明出处:JS特出标题解析

    关键词: 68399皇家赌场 W IT图文在线课程

上一篇:html学习笔记二

下一篇:没有了