zoukankan      html  css  js  c++  java
  • ES6的变量声明

    在ES5中,变量声明只有var和function以及隐式声明三种,在ES6中则增加了let,const,import和class四种,以下来介绍着七种变量的声明。

    var


    ES5中最原始的变量声明,用于声明变量,其实JavaScript是弱类型语言,对数据类型变量要求不太严格,所以不必声明每一个变量的类型(这就是下面说的隐式声明,当然这并不是一个好习惯),在使用变量之前先进行声明是一种好的习惯。

    1.作用域

    使用var声明的变量的作用域是函数作用域(在ES5时代,只有函数作用域和全局作用域两种作用域),在一个函数内用var声明的变量,则只在这个函数内有效。

    function test(){
        var a;
        console.log(a);//undefined
    }
    console.log(a);//ReferenceError: a is not defined

    2.变量声明提升

    用var声明变量时,只要在一个函数作用域内,无论在什么地方声明变量,都会把变量的声明提升到函数作用域的最前头,所以无论使用变量在变量声明前还是声明后,都不会报错(当然只是声明提前,赋值并没有提前,所以如果使用在声明之前,会输出undefined,但不会报错)。

    function test(){
        console.log(a);//undefined
        var a=3;
    }

    隐式声明


    当没有声明,直接给变量赋值时,会隐式地给变量声明,此时这个变量作为全局变量存在。

    function test(){
        a=3;
        console.log(a);//3
    }
    test();
    console.log(a);//3

    当然要注意,隐式声明的话就没有变量声明提前的功能了,所以下面的使用是会报错的。

    function test(){
        console.log(a);//ReferenceError: a is not defined
        a=3;
    }

    function


    用function声明的是函数对象,作用域与var一样,是函数作用域。

    function test(){
        function a(){
            console.log('d');
        }
        a();//'d'
    }
    a();//ReferenceError: a is not defined

    同样,function声明也有变量声明提升,下面是两个特殊的例子:

    function hello1(a){
           console.log(a); //[Function: a]
        function a(){}
        console.log(a);//[Function: a]
    }
    hello1('test');   
    
    function hello2(a){
           console.log(a); //test
        var a=3;
        console.log(a);//3
    }
    hello2('test');

    这里有涉及到函数中形参的声明,我们可以将以上两个例子看成:

    function hello1(a){
        var a='test;
           console.log(a); //[Function: a]
        function a(){}
        console.log(a);//[Function: a]
    }
    hello1('test');   
    
    function hello2(a){
        var a='test;
           console.log(a); //test
        var a=3;
        console.log(a);//3
    }
    hello2('test');

    可以看到函数对象的声明也提前了,但是在形参变量声明之后(形参的变量声明在所有声明之前)。

    当函数对象和普通对象同时声明时,函数对象的声明提前在普通对象之后。

    function test(){     
        console.log(a);//[Function: a]
        function a(){}
        var a;
        console.log(a);//[Function: a]
    }

    let


    ES6新增的声明变量的关键字,与var类似。

    当然,与var也有很大区别:

    1.作用域不同

    let声明的变量的作用域是块级作用域(之前的js并没有块级作用域,只有函数作用域和全局作用域),var声明的变量的作用域是函数作用域。

    {
      let a = 10;
      var b = 1;
    }
    
    a // ReferenceError: a is not defined.
    b // 1

    2.不存在变量声明提升

    用var声明变量时,只要在一个函数作用域内,无论在什么地方声明变量,都会把变量的声明提升到函数作用域的最前头,所以无论使用变量在变量声明前还是声明后,都不会报错。而let不一样,与java以及其他语言一样,let声明的变量,在未声明之前变量是不存在的。(js的语法越来越向java靠拢)

    console.log(a); // undefined,但是不报错。
    console.log(b); // ReferenceError: b is not defined.
    
    var a = 2;
    let b = 2;

    注意:在使用babel时可能会遇到这样的情况:

    console.log(b); //undefined
    let b = 2;

    babel在翻译es6时,似乎直接将let变为了var,所以运行时也有变量声明提升了,但是在Chrome下运行时是正确的。

    3.暂时性死区

    所谓暂时性死区,意思是,在一个块级作用域中,变量唯一存在,一旦在块级作用域中用let声明了一个变量,那么这个变量就唯一属于这个块级作用域,不受外部变量的影响,如下面所示。

    无论在块中的任何地方声明了一个变量,那么在这个块级作用域中,任何使用这个名字的变量都是指这个变量,无论外部是否有其他同名的全局变量。

    暂时性死区的本质就是,只要一进入当前作用域,所要使用的变量就已经存在了,但是不可获取,只有等到声明变量的那一行代码出现,才可以获取和使用该变量。

    暂时性死区的意义也是让我们标准化代码,将所有变量的声明放在作用域的最开始。

    var a = 123;  
    {
     console.log(a);//ReferenceError
      let a;
    }

    4.不允许重复声明

    在相同的作用域内,用let声明变量时,只允许声明一遍。 (var是可以多次声明的)

    // 正确
    function () {
      var a = 10;
      var a = 1;
    }
    
    // 报错,Duplicate declaration "a"
    function () {
      let a = 10;
      var a = 1;
    }
    
    // 报错,Duplicate declaration "a"
    function () {
      let a = 10;
      let a = 1;
    }

    const


    const用来声明常量,const声明的常量是不允许改变的,只读属性,这意味常量声明时必须同时赋值, 只声明不赋值,就会报错,通常常量以大写字母命名。

    阮一峰大神的书里说,在严格模式下,重新给常量赋值会报错,普通模式下不报错,但是赋值无效。但是测试了一下,无论是严格还是非严格模式,都会报错。

    const A = 1;
    A = 3;// TypeError: "A" is read-only

    const和let类似,也是支持块级作用域,不支持变量提升,有暂时性死区.

    注意:如果声明的常量是一个对象,那么对于对象本身是不允许重新赋值的,但是对于对象的属性是可以赋值的。

    const foo = {};
    foo.prop = 123;
    
    foo.prop// 123
    
    foo = {} // TypeError: "foo" is read-only

    import


    ES6采用import来代替node等的require来导入模块。

    import {$} from './jquery.js'

    $对象就是jquery中export暴露的对象。

    import命令接受一个对象(用大括号表示),里面指定要从其他模块导入的变量名。注意:大括号里面的变量名,必须与被导入模块对外接口的名称相同。

    如果想为输入的变量重新取一个名字,import命令要使用as关键字,将输入的变量重命名。

    import { New as $ } from './jquery.js';

    注意,import命令具有提升效果,会提升到整个模块的头部,首先执行。

    class


    ES6引入了类的概念,有了class这个关键字,当然,类只是基于原型的面向对象模式的语法糖,为了方便理解和开发而已,类的实质还是函数对象,类中的方法和对象其实都是挂在对应的函数对象的prototype属性下。

    我们定义一个类:

    //定义类
    class Person {
      constructor(name, age) {
            this.name = name;
            this.age = age;
      }    
      setSex(_sex) {
            this.sex=_sex;
      }
    }

    constructor方法,就是构造方法,也就是ES5时代函数对象的主体,而this关键字则代表实例对象,将上述类改写成ES5格式就是:

    function Person(name, age){
              this.name = name;
            this.age = age;
    }
    
    Person.prototype. setSex = function (_sex) {
              this.sex=_sex;
    }

    所以说,类不算什么新玩意,大多数类的特性都可以通过之前的函数对象与原型来推导。

    1.所有类都有constructor函数,如果没有显式定义,一个空的constructor方法会被默认添加(有点类似java了)。当然所有函数对象都必须有个主体。

    2.生成类的实例对象的写法,与ES5通过构造函数生成对象完全一样,也是使用new命令。

    class B {}
    let b = new B();

    3.在类的实例上面调用方法,其实就是调用原型上的方法,因为类上的方法其实都是添加在原型上。

    b.constructor === B.prototype.constructor // true

    4.与函数对象一样,Class也可以使用表达式的形式定义。

    let Person = class Me {
          getClassName() {
            return Me.name;
          }
    };

    相当于

    var Person = function test(){}

    5.Class其实就是一个function,但是有一点不同,Class不存在变量提升,也就是说Class声明定义必须在使用之前。

    全局变量


    全局对象是最顶层的对象,在浏览器环境指的是window对象,在Node.js指的是global对象。

    ES5之中,全局对象的属性与全局变量是等价的,隐式声明或者在全局环境下声明的变量是挂在全局对象上的。

    ES6规定,var命令,function命令以及隐式声明的全局变量,依旧是全局对象的属性;而let命令、const命令、class命令声明的全局变量,不属于全局对象的属性。

    var a = 1;
    console.log(window.a) // 1
    
    let b = 1;
    console.log(window.b) // undefined

    函数的形参


    函数的形参,隐藏着在函数一开始声明了这些形参对应的变量。

    function a(x,y){}
    可以看成  
    function a(){
        var x=arguments.length <= 0 || arguments[0] === undefined ? undefined : arguments[0];
        var y=arguments.length <= 1 || arguments[1] === undefined ? undefined : arguments[1];
    }

    当然在ES6下默认声明就是用的let了,所以函数a变成:

    function a(){
        let x=arguments.length <= 0 || arguments[0] === undefined ? undefined : arguments[0];
        let y=arguments.length <= 1 || arguments[1] === undefined ? undefined : arguments[1];
    }

    所以在ES6中会有以下几个问题:

    function a(x = y, y = 2) {
      return [x, y];
    }
    
    a(); // 报错,给X赋值时y还未被let声明。  
    
    
    
    function a(x,y) {
      let x;//相当于重复声明,报错。
    }


    --------本文属于摘要
  • 相关阅读:
    mac上python3安装HTMLTestRunner
    双目深度估计传统算法流程及OpenCV的编译注意事项
    深度学习梯度反向传播出现Nan值的原因归类
    1394. Find Lucky Integer in an Array
    1399. Count Largest Group
    1200. Minimum Absolute Difference
    999. Available Captures for Rook
    509. Fibonacci Number
    1160. Find Words That Can Be Formed by Characters
    1122. Relative Sort Array
  • 原文地址:https://www.cnblogs.com/liangxiaoli/p/7126889.html
Copyright © 2011-2022 走看看