js关于“call方法”百度,阿里超难面试题

 

一、JS数据类型

面试题:
function fn(a,b){
    console.log(this);
    console.log(a);
    console.log(a+b);
}
fn.call(1);
fn.call.call(fn);
fn.call.call.call(fn,1,2);
fn.call.call.call.call(fn,1,2,3);

 

答案:
fn.call(1);  // 1,undefined,NaN
fn.call.call(fn);   // fn,undefined,NaN
fn.call.call.call(fn,1,2);  //  1,2,NaN
fn.call.call.call.call(fn,1,2,3);  //  1,2,5

<script>

深层解题思路:
fn.call(1);call的第一个参数改变call前面函数里的关键字this所以输出1;后面没有参数所以a,b为undefined,相加结果为NaN;
fn.call.call(fn);这一块是个难点,不过也很好理解! fn.call 找到Function.prototype上的call方法(这也是一个函数,也是函数类
                 的一个实例,也可以继续调用call/apply等方法)我们可以把fn.call看成一个函数 A 那么接下就等于A.call(fn),这
                 里执行call方法,把 A 中的关键字this修改为函数 fn ,然后再把函数 A(fn.call) 执行;
fn.call.call.call(fn,1,2);通过上一条的原型链的方法我们可以把 fn.call.call.call 看成 A(fn.call.call).call 执行,此时括
                 里的参数 fn 已经作为函数执行了,所以就成了 A.call(1,2) 执行!1作为第一个参数改变 call 前面函数里的this,
                 后面的参数作为实参传递到函数的形参里!
fn.call.call.call.call(fn,1,2,3); 同上一条原理!

            /*

概括性总结:
不怎么理解的话也可以记住这个概括性诀窍:
碰到两个及两个以上的call都是让第一个参数执行,第一个参数必须是函数;
第二个参数是改变第一个参数中this;
第三个及第三个以后的参数作为实参传给第一个参数。

             * js中的数据类型

 

             *     一、基本(简单)数据类型(有五种)

             *         1、字符串    String

             *             放在一对单引号或者双引号里,由0个或者多个字符组成的串

             *             注意:

             *                 引号是成对出现的

             *                 如果说字符串里面有引号,外在的引号一定要与里面的引号相反

             *                 如果说想要在字符串里输入的引号与外在的引号相同,那就用转义字符(')

             */

                        var s1='a';

                        var s2="kaivon";

                        var s3='';

                        var s4=' ';

                        var s5="It 's me";

                        var s6='It 's me';

                        

                        //var s5='学辉";        //报错

                        console.log(s1);        //a

                        console.log(s2);        //kaivon

                        console.log(s3);        //什么都没有的字符串

                        console.log(s4);        //空格字符串

                        console.log(s5);        //It 's me

                        console.log(s6);        //It 's me

             /*

             *         2、数字        Number

             *             1.由0-9之间的任意数字组合而成,可是整数也可以是小数。数字的范围在正无穷(+Infinity)与负无穷(-Infinity)之间

             *                 数字最大值:Number.MAX_VALUE

             *                 数字最小值:Number.MIN_VALUE

             *             2.NaN

             *                 not a number

             *                 当运算失败的时候会出现

             *                 自己与自己都不相等

             */

            

                            var n1=12;

                            var n2=23.56;

                            var n3=Number.MAX_VALUE;

                            var n4=Number.MIN_VALUE;

                            console.log(n1);        //12

                            console.log(n2);        //23.56

                            console.log(n3);        //1.7976931348623157e+308

                            console.log(n4);        //5e-324

                            console.log(n3*2);    //Infinity

                            console.log('a'-1);    //NaN

                            console.log(NaN==NaN);        //false

            

             /*         3、布尔值    Boolean

             *             true        真

             *             false    假

             */

                        var b1=true;

                        var b2=false;

                        console.log(b1);        //true

                        console.log(b2);        //false

                

             /*         4、未定义    Undefined

             *             有且只有一个值undefined

             */

                        var u1=undefined;

                        var u2;

                        console.log(u1);        //undefined

                        console.log(u2);        //undefined        声明一个变量,但没给它赋值,那它就是undefined,

                                                 //undefinded是有存在,只是没有给值,而Null代表是不存在的意思、

            

             /*         5、空        Null

             *             有且只有一个值null

             */

                        var nul=null;

                        var btn=document.getElementById('btn');

                        console.log(nul);    //null

                        console.log(btn);    //null   因为还没有有写HTML

                        

            

             /*     二、复合(复杂)数据类型

             *         对象        Object

             *         格式:由简单数据类型与复合数据类型任意组合而成的。它的数据是放在一对大括号当中,每个数据由一个键值对组成的,数据可以是0个也可以是多个,每个数据之间用逗号隔开,最后一个数据不能加逗号(如果加了逗号,那就会报错)

             *             键值对:key:value

             *                 key    数据名称,它可以加引号也可以不加引号,当这个名字不符合变量命名规则的时候需要加上引号(数字除外),引号是成对出现的、

             *                 value    数据对应的值,这个值可以是简单数据类型也可以是复杂数据类型

             * 

             *         操作对象用的方法就是属性的方法

             *         

             *         函数、对象、数组都属于复合数据类型。

             */

            

                    //这个就是复合对象数据,可以自己定义这个对象里面的许多东西

                     语法:   大括号{},里面的元素最后一个不需要加逗号,

                                       调用的时候和数组不一样,数组是写对应的下标数,对象写的是对应的key

                    var person={

                        name:'老王',//结束语不是;而是,

                        age:30,

                        height:'180cm',

                        weight:'90kg',

                        drive:true,

                        'girl-firend':null,

                        language:['汉语','日语','英语']

                    };//其实写法是数组一样,最后一个是不需要逗号的

                    

                    

                    console.log(person.name);    //老王

                    console.log(person['girl-firend']);        //null

                    

                    person.age=25;

                    

                    console.dir(person);

 </script>

 

二、检车数据类型的方法---typeof

/*

             * typeof

             *     检测一个数据的类型,返回这个类型对应的字符串(全小写)

             *     返回的结果与系统当中定义的类型是有区别

             *     它是一个运算符

             * 

             * 语法

             *        第一种                typeof 数据        typeof u

             *         第二种            typeof(数据)        typeof(u)

             * 

             * 系统定义的数据类型                typeof返回的数据类型

             *     String                            string

             *     Number                            number

             *     Boolean                            boolean

             *     Undefine                            undefined

             *     Null                                object

             *     Object                            object

             * 

             * 

             */

            var s='kaivon';

            console.log(typeof s);        //string

            

            var n=12;

            console.log(typeof n);        //number

            

            var b=true;

            console.log(typeof b);        //boolean

            

            var u=undefined;

            console.log(typeof u);        //undefined

            

            var nul=null;

            console.log(typeof nul);        //object

            //null的typeof的结果是object,

            

            var o={left:10};

            console.log(typeof o);        //object

            

            var fn=function(){alert(1)}

            console.log(typeof fn);        //function

           函数的typeof结果为function,但是js当中没有给函数定义一个类型

 

三、数据类型转换

             *     把一种数据类型转换成另外一种数据类型

             *  

             * js支持把任意一种数据类型只能转换成以下三种类型

             *         数字

             *         字符串

             *         布尔值

             *     不能转成Undefined 和Null

             *     对象转成这三种数据是没有意义,因为对象里面可以放任意一种数据类型。

       1.各种类型转成数字  

 

               /*

             * 任意类型转数字

             *     Number(要转换的值)    把任意类型都转为数字

             *         1、Undefined    

             *             转数字的结果为NaN

             */

                    var u=undefined;

                    console.log(Number(u));        //NaN        

                    

             /*         2、Null

             *             转数字的结果为0

             */

                    var nul=null;

                    console.log(Number(nul));    //0

                    

             /*         3、Boolean

             *             true        转数字的结果为1

             *             falae    转数字的结果为0

             */

                        var b1=true;

                        var b2=false;

                        console.log(Number(b1),Number(b2));    //1 0

            

             /*         4、String

             *             空字符串,空格字符串转数字的结果为0

             *             字符串里的内容是不是一个纯数字,如果是个纯数字的话,就转成对应的数字

             *             如果说不是一个纯数字,那结果就是NaN

             */

                        var s1='';

                        var s2=' ';

                        var s3='kaivon';

                        var s4='012';

                        var s5='12a';

                        var s6='12*12';

                        console.log(Number(s1));        //0

                        console.log(Number(s2));        //0

                        console.log(Number(s3));        //NaN

                        console.log(Number(s4));        //12

                        console.log(Number(s5));        //NaN

                        console.log(Number(s6));        //NaN

            

             /* 

             *         5、Number

             *             数字转数字的结果还为原来的数字

             *         6、Object

             *             

             */

                    var o1=[];

                    var o2={};

                    console.log(Number(o1));        //0   数组为0

                    console.log(Number(o2));        //NaN   对象为NaN

          2.字符串转数字            

            /*

             * 把字符串转成数字

             *     parseInt()        把字符串转成整数型数字

             *     parseFloat()        把字符串转成浮点型(小数)数字

             *     

             *     传进来的字符串必需是数字或者空格加数字开头,它会从数字开始,一位一位往后找,直到找到的字符不是数字就会停止,会把找到的数字字符转成真正的数字。如果没找到那就返回一个NaN

             */

            

            var s1='100px';

            var s2=' 100px';

            var s3='px100';

            var s4='100.256rem247';

            var s5='0123';

            console.log(parseInt(s1));        //100

            console.log(parseInt(s2));        //100

            console.log(parseInt(s3));        //NaN

            console.log(parseFloat(s4));        //100.256

            console.log(parseInt(s5));        //123

         3.把类型转为字符串--就是在外面加多一个引号

             /*

             * 任意类型转字符串------结果就是给对象加上引号

             *     String(要转换的值)

             *         1、Undefined转字符串

             *             'undefined'

             *         2、Null转字符串

             *             null

             *         3、Number转字符串

             *             把数字加上引号

             *         4、Boolean转字符串

             *             true    转字符串的结果为'true'

             *             false转字符串的结果为'false'

             *         5、String转字符串

             *             结果就是本身

             *         6、Object转字符串

             *             结果也是给对象加上引号

             *             

             */

            var u=undefined;

            console.log(String(u));        //undefined

            

            var nul=null;

            console.log(String(nul));    //null

            

            var num=12;

            console.log(String(num));    //12

            

            var b1=true;

            var b2=false;

            console.log(String(b1));        //true

            console.log(String(b2));        //false

       4.把各类型转为布尔值

            /*

             * 任意类型转布尔值

             *     Boolean(要转换的值)

             *         1、Undefined转布尔值

             *             false

             *         2、Null

             *             false

             *         3、Number

             *             0、NaN转布尔值的结果为false,其它的转布尔值的结果为true

             *         4、Boolean转布尔值

             *             转为对应的值

             *         5、String转布尔值

             *             空字符串转布尔值的结果为false,其它(包括空格字符串)的都转成true       

             */

            var u=undefined;

            console.log(Boolean(u));        //false

            

            var nul=null;

            console.log(Boolean(nul));    //false

            

            var n1=0;

            var n2=NaN;

            var n3=Infinity;

            var n4=12;

            console.log(Boolean(n1));    //false

            console.log(Boolean(n2));    //false

            console.log(Boolean(n3));    //true

            console.log(Boolean(n4));    //true

            

            

            var s1='kaivon';

            var s2='';

            var s3=' ';

            console.log(Boolean(s1));    //true

            console.log(Boolean(s2));    //false

            console.log(Boolean(s3));    //true

四、类型转换分类、

             /*

             * 类型转换分为两种

             *     1、显式类型转换 -----我们自己认为操作的。

             *         通过一些方法,很明确的将某种数据类型转换为另一种数据类型

             *             Number()、parseInt()、parseFloat()        明确将数据转数字类型

             *             String()        明确将数据转成字符串

             *             Boolean()    明确将数据转成布尔值

             *     2、隐式类型转换

             *         在进行一些操作的时候,根本目的不是做类型转换。但是如果要进行操作的话,那数据必需符合某种类型。js会在内部对数据进行一些转换

             *             + - * /

             */

            

            console.log(1+2);        //3

            console.log(1+'a');        //1a

            console.log(true+1);        //2        加号两边没有字符中,那就是数学中的加法运算,会把true转成数字

            console.log(true+'1');    //true1    加号右边是字符串,那就是字符串连接的意思,会把true转成字符串true

            console.log(false-true);    //-1        减号的作用就是数学上的减法运算,会把两边都转成数字

            console.log(''-1);        //-1

五、检查数据是否是NaN ----isNaN

             /*

             * isNaN()

             *     判断一个值是不是NaN,它会先把参数用Number()方法转一下

             *     它具有一个功能是用来检测数字的,但是它的本意并不是用来检测数字的

             * 

             *     如果参数的结果为NaN,那它返回一个true

             *     如果参数的结果不为NaN,那它返回一个false

             * 

             *     isNaN()传进来的值,如果是一个数字的话,那它就返回一个false

             */

            

            var n=NaN;

            var s='kaivon';

            var n1=12;

            console.log(isNaN(n));        //true

            console.log(isNaN(s));        //true

            console.log(isNaN(n1));        //false

六、运算符

             * 运算符优先级

             *     中括号、小括号、点属于同一级别,它们有最高的优先及

             *     如果不确定先算谁,那就给要算的内容加上小括号,提高它的优先级.

             

              //1+2*3=7           (1+2)*3=9     类似于数学运算

                 

      1     * 算术运算符

             *     + 加、- 减、* 乘、/ 除、c 取模(求余数)、++、--

             * 

             *     取模的时候,如果前面的数字比后在的数字小,那得到的结果就是前面的数字

             *     取模的时候,后面的数字不能为0,如果为0的话得到的结果就是NaN

            console.log(3%4);    //3               0%5        0

            console.log(7%12);    //7              1%5        1

            console.log(28%36);    //28            5%5        0

            console.log(5%0);    //NaN             7%5        2

    2递增递减

      * ++    递增

             * --    递减

             * 它俩可以放在操作数的前面,也可以放在操作数的后面

             * 

             * 如果只操作自己

             *     ++放在操作符的前面与后在都是一样的,让自己加1

             *     --放在操作符的前面与后在都是一样的,让自己减1

             */

                   var a=1;

本文由金沙官网线上发布于Web前端,转载请注明出处:js关于“call方法”百度,阿里超难面试题

您可能还会对下面的文章感兴趣: