this 详解 javascript

易错点小结

arguments :实参列表 是个类数组

代码是否能打印出 [1，2，3，4，5] ？

        //arguments 代表实参列表
        function foo(){
            bar.apply(null,arguments);
            //bar(arguments);
        }
        function bar(){
            console.log(arguments);
        }
        foo(1,2,3,4,5);

没有形参，实参依然可以传进去，arguments代表实参列表
下列代码弹出结果是啥？

        function b(x,y,a){
            arguments[2] = 10;
            alert(a);
        }
        b(1,2,3); //结果是  10
        // 如果函数体改成下面，结果又会是什么？
        // a =10;
        // alert(arguments[2])   结果仍然是10

注意：arguments [i] 跟形参的 第 i+1 位（如果这位有值的话）是相互映射的关系，任何一个做出改变，另外一个也会做出相应改变。

parseInt(string,num)

parseInt() 函数可以解析一个字符串，并返回一个整数
num 为可选参数，当num==0 或者没有设置该参数时， parseInt() 会根据 string 来判断数字的基数 。

显然 ，2进制的世界里是不可能出现 数字 3的，另外注意隐式类型转换
只有一个参数时，返回遇到的第一位数字，如

typeof 可能返回的结果

6种结果： Number String Boolean Object undefined function

逗号操作符

返回后面那个

() 操作符

下面代码返回的运行结果是？

        var x=1;
        if(function f() {}){
            x+=typeof f ;
        }
        console.log(x);

解析：一旦函数变成了表达式 ，比如上面的 （function f () {}） 那它就可以变成立即执行函数，比如在最后面再加一对 () ，那么，系统会自动忽略它的引用 ，也就是函数名会被忽略，然后，函数体内的 typeof f ；f 此时是找不到了，所以是 “undefined” 前面再串个 1 结果就是 1undefined

== 和 = = =

= = 两边会进行隐式类型转换，仅需考虑值是否相等

=== 完全相等，值和类型都相等
复杂类型变量名，如对象变量名，存放的是一个地址，指向对象内容所在的地址 ，{} 和 {} 是地址不同的两个空对象，所以不相等，而 obja 和 objb指向同一块空间，显然是相等的

isNaN 函数实现

作用：判断某个数是不是 NaN

        function myisNaN(num){
            var ret = Number(num);
            //错误写法
            // if(ret == NaN){
            //     return true;
            // }
            ret += "";
            if(ret == "NaN"){
                return true;
            }
            else{
                return false;
            }
        }

为什么错误写法是错的 ？ 注意理解 NaN 表示某个东西不是一个 Number ，有万千可能 ，所以 任何东西 跟NaN 之间放等号都是没有意义的，一定返回 false ，如

所以必须先转化成字符串再作比较

this法则

1. 函数预编译过程 this 表示 window
2. 全局作用域里 this 表示 window
3. call / apply 可以改变函数运行时 this 指向
4. obg.func() ; func() 里面的 this 指向 obj ,即谁调用指向谁

例题精解

        var name = "222";
        var a = {
        	//var this = {
        	//
        	//	__proto__ : Object.create(a.prototype)
        	//}
        	
            name : "111",
            say : function(){
                console.log(this.name);
            }
        };
        var fun = a.say;//把 a的属性 say 赋给 fun  也就是那个函数体的引用
        fun(); //222     等于全局下执行函数体，此时 this指的是 window 所以 window下的 name为 222
        a.say(); //111  注意，a调用 say 里面的 this 指向 a 
        		//往执行期上下文里找 name   所以打印 出   111

        var b = {
            name : "333",
            say : function (fun){
                fun();
            }
        };
        b.say(a.say); //把 a中那个函数体作为参数传给 b 的say 方法，然后执行 b的say方法
        			//执行 b 的say方法，也就是执行传进来的参数，参数就是 a的say方法  fun函数，fun仍然没有谁调用fun，所以走预编译
        			//只是单纯的执行 fun() 实质就是换个地方执行 fun函数，所以 fun 里面的window仍然是window  输出  222
        
        b.say = a.say; //等于把 b的 say属性换了一次，换成了 a 的say属性值，也就是那个打印name的函数
        b.say();      //执行b 的say方法  跟上面的 a.say()原理是一样的 this指向  b   输出333

深入理解第3个 b.say(a.say): 代码简化一下

        var name = "222";
        var a = {
            name : "111",
            say : function(){
                console.log(this.name);
            }
        };
        var b = {
            name : "333",
            say : function (fun){
                fun();
            }
        };
        b.say(a.say);

b.say里面的 this 确实指向 b
b.say 的执行就是 把参数执行一下，参数是个函数，里面有个this 仍然没有谁调用，只是单纯的执行函数 fun 所以执行预编译 this.name 就是 window.name 跟 a 没关系,跟 b 也没关系