工具类知识点虾写前端

二十分钟学会Javascript高级进阶

2016-06-05  本文已影响3870人  一只老辣鸡
二十分钟学会Javascript高级进阶(图片来自网络)

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

进阶一:能不能实现同方法名重载?

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

    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;i<length;i++){
                result += arguments[i];
            }
            return result;
        }
    };

    var demo = new Demo();             //声明一个对象
    var isGt = demo.gt(3,2);           //3>2 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<length;i++){ 
                    result += arguments[i];
               } 
               return result;
         }
         return {
                gt : gt,                       //返回方法的映射
                add : add
         }
   }(); 

   //或者,直接在function中定义原型方法
   function Demo(){
         this.add = function(a,b){return a+b;};
   }            

值得注意的是,如果同时在函数内和方法的prototype属性同时声明了同一个方法,那么Javascript会从下往上寻找最顶层的那个方法作为有效方法,如下:

    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

进阶七: 等于与绝对等于问题

在Javascript中,有两种数据类型,一种是基本数据类型,一种是引用数据类型,即常说的对象类型。而基本数据类型中又包含有string、boolean、number、null和undefined五种基本数据类型。如下:

类型 取值范围
String 字符串,具有无限个值
Boolean 布尔值,具有ture或者false
Number 数字,具有无限个值
Null 空类型,具有一个值null
Undefined 未定义类型,具有一个值undefined

需要注意的是,typeof null == object,而typeof undefined == undefined。举个例子:

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

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

好了,由于时间关系,本篇关于对Javascript高级进阶的总结比较仓促,还有很多额外的知识点还没有添加进来。其他的高阶内容将会在日后陆续更新进来,欢迎大家阅读。

还有,就是,你在这二十分钟内学会了吗?

附录 文章更新日志

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

猜你喜欢

热点阅读