二十分钟学会Javascript高级进阶

二十分钟学会Javascript高级进阶(图片来自网络)

Javascript是一种动态脚本语言，而且还是弱类型的语言。如果大家在之前学习过Java或者c#等面向对象的高级语言，然后再来学习Javascript，那么你们肯定会觉得很多地方都是与高级语言一致的，于是觉得只要花个半天时间就能“学完”所谓的Javascript了。但是，这样也遗留下了很多大家容易忽略的知识点，而这些知识点，个人觉得是Javascript的高级进阶知识点。本篇文章从小白的角度总结了一些在Javascript中容易掉下的坑。

进阶一：能不能实现同方法名重载？

在高级语言中，方法的重载时很普遍的。那什么是重载？重载就是方法名相同，返回值和参数列表不完全相同的多个方法。以Java为例，如下：

    public void demo(int a, int b);
    public void demo(int a, int b, int c);
    public int demo(int a, int b);
    public int demo(int a, int b, int c);

上面这些方法的重载是没有任何问题的，但是，在Javascript中，是不是也可以呢？比如下面这个例子：

    function demo(a,b){    console.log(a+b);}
    function demo(a,b,c){ console.log(a+b+c);}

    demo(1,2);
    demo(1,2,3);

首先，Javascript的编译引擎是不会报错的。对于类似于函数重载的方法声明，Javascript会认为所有的方法名都是唯一的，每个方法名是每个方法的唯一标识，所以对于类似上面代码的这种重载是无效的，但是，编译器不会报错，而是会进行覆盖，先声明的方法会被后声明的同名方法所替代，也就是说，所有的demo方法都会指向demo(a,b,c)这个方法。所以输出结果，显而易见：

    NaN                  //demo(1,2)的执行结果，因为 c == undefined
    6                    //demo(1,2,3)的执行结果，1+2+3 = 6

所以，结论就是，Javascript中是无法实现类似于高级语言的方法重载的。但是，可以通过方法中的属性arguments来判断有多少个参数，从而实现方法的调用上重载，形式上非重载，如下：

    function demo(){
        var length = arguments.length;  //判断参数个数
        if(length==2){
            console.log(arguments[0] + argument[1]);
            return false;
        }
        if(length==3){
            console.log(arguments[0] + argument[1] + arguments[2]);
        }
    }

    demo(1,2);
    demo(1,2,3);

则其输出结果如下：

    3
    6

进阶二： this指向问题

在Javascript中，一个隐藏着的比较大的坑莫过于this的指向问题了。如果没有仔细了解其中的原理，那么肯定会被指来指去的this所困扰，接下来主要通过一些小例子来阐述this的作用机制。

指向浏览器全局对象:Window

   console.log(this);

那么，上述这段代码的结果是什么呢?很明显，这里的this指向的是当前的窗体本身，打印出来的结果是object Window。所以，在这种情况下指向的就是当前浏览器窗体本身。

    demo();
    function demo(){
          console.log(this);
    }

上述代码的结果，仍然是object Window,所以还是指向当前窗体本身。所以，我们可以通过this关键字来访问所有的全局变量，如下：

    var a = 1;
    function demo(){
        console.log(this.a);
    }

上述代码的结果为 1

指向创建的对象本身:Object

    function demo(a,b,c){
        this.a = a;
        this.b = b;
        this.c = c;
    }

    var obj = new demo(1,2,3);
    alert(obj.a+\" \"+obj.b+\" \"+obj.c);

在方法demo内部的this则指向了自己本身，这里的输出结果为1 2 3,在Javascript中，一个方法也是一个对象。
所以，总的来说，this关键字总的来说可以指向以下两种对象：
要么指向全局对象，要么指向对象自己本身。

进阶三： 作用域问题

   a = 0;                            //a 具有全局作用域
   var b = 0;                        //b 也具有全局作用域

   function demo(){
       var a = 1;                    //这里的a和b只能在demo()内访问了，具有局域作用域
       var b = 1;
       alert(a+\" \"+b);
       alert(this.a + \" \"+ this.b);  //this指向的是全局对象Window
   }

   demo();

1.未使用var关键字声明在全局作用域下不具备变量提升的性质。本质上，没有使用var声明的不是一个变量，只是不使用 var 关键字创建的只是全局对象的属性(全局执行上下文中的变量对象使用全局对象自身实现)，它并不是一个变量。

alert(a);  //undefined
alert(b);  //Can\'t find variable: b

var a = 1;
b = 1;

//此处修改由简友ssbunny提出，非常感谢（2016-07-05）

2.在方法中使用var关键字声明的变量是局部变量
3.在全局区域使用var关键字声明的变量是全局变量
4.虽然作用域问题谈不上高级知识，但是很容易被理解错，所以让在这里复习以下

进阶四： 闭包问题

在Javascript中，什么是闭包？
通俗一点地讲，闭包就是在函数内部声明函数，并且该函数中访问了方法内的局部变量的语法结构，这种语法结构和面向对象的思想其实本质上是一致的 (类似于将一个方法理解成一个类)

    function demo(){
        var a = 0;
        return function(){
              a++;            
        }
    }

这种结构称之为闭包，那为什么要使用闭包?

1. 由于变量的作用域不同，外部无法访问内部区域的变量，而内部区域的变量可以访问外部区域的变量。如果要在方法外部访问方法的内部变量，就必须通过函数内部定义函数的方法来返回函数内部的变量。
2. 理解起来和OO思想的对象是一致的。一般，我们无法直接访问类中的私有成员，但是，我们可以通过定义一些成员方法来访问。所以个人觉得闭包的思想其实和面向对象的思想是差不多的。
3. 那好，为什么要使用闭包？首先，使用闭包可以减少不必要的全局变量，比如一个计数器变量，在脚本中有多个地方需要使用到，那么如果不想使用全局变量进行声明，则可以使用闭包。
4. 闭包也是有不好的地方滴！如果使用了闭包，那么该方法内的局部变量（闭包中访问到的那些）会一直驻留在内存中，如果闭包使用不当，会降低整个应用程序的性能。

请大家阅读以下的例子加以理解：

    function demo(){
        var count = 0;
        return function(){            
            return ++count;           // 注意：count 变量一直驻留在内存中
        }
    }

    var cal = demo();
    var count1 = cal();                    //count == 1
    var count2 = cal();                    //count == 2

那么，如何释放在闭包中使用到的变量的内存呢？其实Javascript中支持直接通过赋空值来释放垃圾的，就上述代码，只需要将方法的引用赋值为空就可以了:cal=null

进阶五： 如何复制一个对象

在Javascript中，有一种可以遍历对象属性的方法，那就是for...in...结构，同时我们可以借助这种结构来实现一个对象的复制，这里指的是深度复制，不是浅复制！

    function copy(o){
          var newObject = {};                                //创建一个新的空对象
          for(var attribute in o){
                newObject[attribute] = o[attribute];          //拷贝对象中的每一个属性
          }
          return newObject;
    }

   var copyObject = copy(oldObject);

进阶六： 原型问题

在需要访问对象的内部属性，或者说是方法的局部变量的时候，我们可以通过闭包的形式来访问。如果我们需要在对象内定义一些方法供外部调用，就需要使用到原型和原型链。
在Javascript中，是不支持继承的，但是可以通过原型实现一些继承的功能。

    function Demo(){};          //声明一个对象类型(类似于高级语言中的类)

    Demo.prototype = {          //定义对象类型中的方法，使用到的是原型模型
        gt : function(a,b){     //定义一个比较a和b的值得方法，如果a>b返回true
            return (a>b);
        },
        add : function(){       //定义一个不限定参数个数的加法运算
            var length = arguments.length;
            alert(length);
            var result = 0;
            for(var i=0;i2 true
    var add1 = demo.add(1,3,4);        //1+3+4 = 8
    var add2 = demo.add(1,3,4,5);      //1+3+4+5 = 13

个人感觉这个原型模式与高级语言中的类的成员方法是很类似的。通过定义Javascript中的原型方法，从而实现一个对象中的多个方法的效果。除了上面这种定义方式之外，还有下面的这种定义方式。

    function Demo(){}

    Demo.prototype = function(){
          gt = function(a,b){
                return a + b;
          };
          add = function(){
               var length = arguments.length; 
               var result = 0; 
               for(var i=0;i

    function Demo(){
        add = function(a+b){return a+b;};                //直接在方法内定义add方法，在最顶层定义
    }

   Demo.prototype = {                                    //通过prototype属性定义add方法
      add = function(a,b,c){
          return a+b+c;
      };
   }

  var demo = new Demo();  //最顶层的方法add(a,b)是有效的，而add(a,b,c)是无效的
  demo.add(1,2);          //1+2 = 3
  demo.add(1,2,3);        //1+2+undefined = NaN

var a = \"123\";
var b = 123;

console.log(a==b);    //返回true
console.log(a===b);   //返回false，因为类型不同

2016-06-05 首次发布，初稿内容
2016-06-06 添加章节《原型问题》
2016-07-04 修正文章中的一处歧义
2016-07-05 修正解释错误：未使用var创建的变量全是全局变量
2016-07-23 添加章节《等于与绝对等于问题》