用法那几个就够了

By admin in 4858美高梅 on 2019年4月11日

let的特性:

注:const的作用域与let命令相同:只在注脚所在的块级成效域内有效。

if(true){

const MAX=5;

}

MAX// Uncaught ReferenceError: MAX is not defined


let和const

ECMAScript与JavaScript的关系

ECMAScriptJavaScript语言的国际标准,JavaScriptECMAScript的实现。

  1. 不存在变量进步气象:即宣称前应用,报ReferenceError。适用于for循环计数器。
  2. 一时半刻死区:即在块级效能域内使用let注脚变量,该变量只幸而该成效域内接纳。
  3. 差异意再度注明:let评释过的变量不能再一次宣示,不然报错。

const声圣元(Synutra)个只读的常量。一旦注明,常量的值就不能够更改。

const PI = 3.1415;

PI // 3.1415

PI = 3;

// TypeError: Assignment to constant variable.

地方代码申明改变常量的值会报错。


let命令

let用法类似var,不过所注解的变凉,只在let命令所在的代码块内有效

{
    let arr = 3
    var arr0 = 9
}
console.log(arr)    //ReferenceError: arr is not defined
console.log(arr0)    //9

for循环的计数器,很适合let命令

for(let i=0; i<10; i++){
    console.log(i)
}
console.log(i)   //ReferenceError: i is not defined

用法那几个就够了。此外,for循环还有叁个尤其之处,正是安装循环变量的那部分是贰个父功效域,而循环体内部是1个独门的子功能域。

for (let i = 0; i < 3; i++) {
  let i = 'abc';
  console.log(i);
}
// abc
// abc
// abc

let 与 const 的用法

let 用来宣称变量,所评释的变量只在let命令所在的 代码块
内有效。

const 用来宣示常量,所谓常量便是物理指针不能改变的变量。

{ let a = 1;}console.log // 报错 a is not defined
  • 只须要用 {} 包起来,这个 {} 和中间代码生成2个代码块;
  • 在块中,letconst声称的变量和常量对外都以不可见的,称之为块级功能域
  • 只有选拔letconst宣称的变量大概常量在块中对外不可知,var评释的变量对外依旧凸现;
  • 能够认为是let和const成立了块级成效域

块级作用域特性

ES陆 允许块级成效域的任性嵌套

{{{{{let insane = 'Hello World'}}}}};

外层成效域不可能读取内层功效域的变量

{{{{ {let insane = 'Hello World'} console.log; // 报错}}}};

内层成效域能够定义外层成效域的同名变量

{{{{ let insane = 'Hello World'; {let insane = 'Hello World'}}}}};
  • let表明的变量只在变量评释时所在的代码块内有效。

{ let a = 10; var b = 1;}a // ReferenceError: a is not defined.b // 1
  • 不设有变量提高气象

var命令会产生”变量升高“现象,即变量能够在证明此前使用,值为undefined;但let所评释的变量一定要在申明后选取,不然报错。

// var 的情况console.log; // 输出undefinedvar foo = 2;// let 的情况console.log; // 报错ReferenceErrorlet bar = 2;
  • 一时死区

在代码块内,使用let一声令下申明变量从前,该变量都以不可用的。那在语法上,称为“暂行死区”。

if  { // TDZ开始 tmp = 'abc'; // ReferenceError console.log; // ReferenceError let tmp; // TDZ结束 console.log; // undefined tmp = 123; console.log; // 123}

暂且死区的本质正是,只要一进入当前效能域,所要使用的变量就曾经存在了,可是不可获取,唯有等到评释变量的那壹行代码现身,才得以获取和动用该变量。

  • let不允许在同样成效域重复申明变量

// 报错function func() { let a = 10; var a = 1;}// 报错function func() { let a = 10; let a = 1;}

并且,也无法在函数内部重新申明参数

function func { let arg; // 报错}function func { { let arg; // 不报错 }}
  • 关于for循环

for巡回的计数器,很合适使用let命令,在for
循环中选拔let概念变量,只在for的巡回周期内足以运用,在循环体外引用就会报错

for (let i = 0; i < 10; i++) { // ...}console.log;// ReferenceError: i is not defined

for循环设置循环变量的那有些是多个父功效域,而循环体内部是一个独门的子效率域

for (let i = 0; i < 3; i++) { let i = 'abc'; console.log;}// abc// abc// abc

const的特性:

const注解的变量不得变动值,那象征,const一旦评释变量,就不能够不立时开首化,不能够留到今后赋值。

const foo;

// SyntaxError: Missing initializer in const declaration

地点代码表示,对于const来说,只评释不赋值,就会报错。


不存在变量升高

var命令会发生”变量进步“现象,即变量能够在注脚在此以前运用,值为undefined。那种气象多有点少是有些奇怪的,根据一般的逻辑,变量应该在宣称语句之后才足以利用。

为了勘误这种现象,let命令改变了语法行为,它所申明的变量一定要在宣称后使用,不然报错。

// var 的情况
console.log(foo); // 输出undefined
var foo = 2;

// let 的情况
console.log(bar); // 报错ReferenceError
let bar = 2;

3、const指令

  • const声称几个只读的常量。壹旦申明,常量的值就无法改变。

const PI = 3.1415;PI // 3.1415PI = 3;// TypeError: Assignment to constant variable.
  • const借使表明变量,就亟须及时开首化,只申明不赋值,就会报错。

const foo;// SyntaxError: Missing initializer in const declaration
  • const的成效域与let命令相同:只在注明所在的块级功效域内有效。

if  { const MAX = 5;}MAX // Uncaught ReferenceError: MAX is not defined
  • const命令注解的常量也是不升官,同样存在临时性死区,只可以在宣称的职位前边使用。

if  { console.log; // ReferenceError const MAX = 5;}
  • const宣称的常量,也与let同壹在相同功效域中不得重复注脚。

var message = "Hello!";let age = 25;// 以下两行都会报错const message = "Goodbye!";const age = 30;
  • const事实上保障的,并不是变量的值不得变动,而是变量指向的丰富内部存款和储蓄器地址不可变更。
    • 对于一言以蔽之类型的多寡(数值、字符串、布尔值),值就封存在变量指向的相当内部存款和储蓄器地址,由此等同常量。
    • 对于复合类型的多少,变量指向的内部存款和储蓄器地址,保存的只是三个针对实际多少的指针,const只得保障这些指针是稳定的(即一而再指向另多个定点的地方),至于它指向的数据结构是或不是可变的,就全盘不可能控制了。

const foo = {};// 为 foo 添加一个属性,可以成功foo.prop = 123;foo.prop // 123// 将 foo 指向另一个对象,就会报错foo = {}; // TypeError: "foo" is read-only

4858美高梅,地点代码中,常量foo仓库储存的是2个地点,这么些地址指向叁个目的。不可变的只是其1地点,即无法把foo针对另1个地点,但指标自作者是可变的,所以依旧能够为其增进新属性

  1. 不存在变量提高气象。
  2. 权且死区。
  3. 不得重复证明。
  4. 宣称的是只读常量,证明时必须开端化。
  5. 精神保存的是内部存款和储蓄器地址,简单类型数据的值就封存在这几个地点中,复合类型数据在这么些地方中保留的是2个指南针,这些指针指向的目的能够改变,单指针不可更改。

    一 cost foo = {};

    三 // 能够转移foo的属性
    肆 foo.prop = 1二3;
    伍 foo.prop //123

    七 // 不得以使foo指向别的对象
    八 foo = {}; //TypeError: “foo” is read-only

const命令表明的常量也是不升级,同样存在权且性死区,只万幸申明的职位后边使用。

if(true){

console.log(MAX);// ReferenceErrorconst

MAX=5;

}


临时死区

设若块级效用域内设有let命令,它所证明的变量就“绑定”(binding)这一个区域,不再受外部的影响。

ES陆明显规定,假诺区块中留存let和const命令,这些区块对这几个命令申明的变量,从一早先就形成了封闭效用域。凡是在证明此前就选取那几个变量,就会报错。

简单的讲,在代码块内,使用let命令评释变量此前,该变量都以不可用的。那在语法上,称为“临时性死区”(temporal
dead zone,简称 TDZ)。

if (true) {
  // TDZ开始
  tmp = 'abc'; // ReferenceError
  console.log(tmp); // ReferenceError

  let tmp; // TDZ结束
  console.log(tmp); // undefined

  tmp = 123;
  console.log(tmp); // 123
}

上面代码中,在let命令注脚变量tmp在此以前,都属于变量tmp的“死区”。

“权且性死区”也象征typeof不再是一个全部康宁的操作。

下边包车型大巴代码也会报错,与var的行事不相同。

// 不报错
var x = x;

// 报错
let x = x;
// ReferenceError: x is not defined

上边代码报错,也是因为一时半刻死区。使用let申明变量时,只要变量在还尚未评释实现前使用,就会报错。上边那行就属于那一个场合,在变量x的宣示语句还尚无执行到位前,就去取x的值,导致报错”x
未定义“。

ES6规定暂且死区和let、const语句不出新变量升高,首假使为着减命宫作时不当,幸免在变量注脚前就选用这几个变量,从而致使预期之外的一坐一起。那样的不当在
ES5 是很常见的,今后有了那种规定,幸免此类错误就很简单了。

同理可得,暂且性死区的精神正是,只要一进入当前成效域,所要使用的变量就早已存在了,但是不得获取,唯有等到注脚变量的那壹行代码出现,才能够获取和行使该变量。

四、ES6 申明变量的五种办法

  • var
  • function
  • let
  • const
  • import
  • class

 

const注脚的常量,也与let一样不可重复申明。

var  message=”Hello!”;

let   age=25;

// 以下两行都会报错

const  message=”Goodbye!”;

const age=30;


不容许再度表明

let不允许在相同效果域内,重复申明同三个变量。

// 报错
function func() {
  let a = 10;
  var a = 1;
}

// 报错
function func() {
  let a = 10;
  let a = 1;
}

 

const实际上保险的,并不是变量的值不得变更,而是变量指向的丰富内部存款和储蓄器地址不得变动。对于简易类型的数目(数值、字符串、布尔值),值就保留在变量指向的那三个内部存款和储蓄器地址,由此等同常量。但对于复合类型的多少(首倘若指标和数组),变量指向的内存地址,保存的只是四个指南针,const只好有限援救那个指针是永恒的,至于它指向的数据结构是或不是可变的,就全盘不能够说了算了。由此,将2个对象注明为常量必须相当小心。

const foo = {};

// 为 foo 添加二特性质,能够成功

foo.prop = 123;

foo.prop // 123

// 将 foo 指向另二个指标,就会报错

foo = {}; // TypeError: “foo” is read-only

地方代码中,常量foo储存的是二个地点,那个地点指向2个对象。不可变的只是其1地址,即不能够把foo指向另二个地点,但指标自小编是可变的,所以依旧得以为其丰裕新属性。

ES陆的块级功效域

let实际上为 JavaScript 新增了块级功效域。

function f1() {
  let n = 5;
  if (true) {
    let n = 10;
  }
  console.log(n); // 5
}

地点的函数有七个代码块,都声称了变量n,运维后输出伍。那表示外层代码块不受内层代码块的震慑。假使两回都利用var定义变量n,最后输出的值才是十。

ES6 允许块级功用域的随意嵌套。

{{{{{let insane = 'Hello World'}}}}};

下边代码应用了贰个五层的块级作用域。外层功能域不或许读取内层效用域的变量。

{{{{
  {let insane = 'Hello World'}
  console.log(insane); // 报错
}}}};

内层功效域能够定义外层作用域的同名变

{{{{
  let insane = 'Hello World';
  {let insane = 'Hello World'}
}}}};

块级功用域的面世,实际上使得获得广泛应用的立刻执行函数表达式(IIFE)不再供给了。

// IIFE 写法
(function () {
  var tmp = ...;
  ...
}());

// 块级作用域写法
{
  let tmp = ...;
  ...
}

凝冻对象:

块级成效域与函数注脚

ES六 引进了块级成效域,分明同目的在于块级作用域之中证明函数。ES陆规定,块级效用域之中,函数注解语句的作为看似于let,在块级功效域之外不可引用。

function f() { console.log('I am outside!'); }

(function () {
  if (false) {
    // 重复声明一次函数f
    function f() { console.log('I am inside!'); }
  }

  f();
}());

 

do表达式

实为上,块级功能域是叁个口舌,将八个操作封装在共同,未有再次来到值。

{
  let t = f();
  t = t * t + 1;
}

地点代码中,块级功用域将五个语句封装在1齐。但是,在块级成效域以外,未有艺术得到t的值,因为块级效率域不再次来到值,除非t是全局变量。

现行反革命有一个提案,使得块级效率域能够变成表明式,相当于说能够重返值,办法正是在块级成效域在此以前增进do,使它成为do表达式。

let x = do {
  let t = f();
  t * t + 1;
};

上边代码中,变量x会获得任何块级成效域的重临值。

// 彻底冻结
var constantize = (obj) => {

   Object.freeze(obj); 

   Object.keys(obj).forEach( (key, i) => {

       if( typeof obj[key] === 'object' ){

         constantize( obj[key] );

       } 

    }); 

}     

const命令

 

核心用法

const证明一(Aptamil)个只读的常量。1旦注明,常量的值就无法改变。

const arr = 3.5
arr // 3.5

arr = 4
// TypeError: Assignment to constant variable.

下面代码申明改变常量的值会报错。

const注解的变量不得变更值,那表示,const1旦申明变量,就非得立刻初阶化,不可能留到将来赋值。

const foo;
// SyntaxError: Missing initializer in const declaration

上边代码表示,对于const来说,只注明不赋值,就会报错。

const的效率域与let命令相同:只在注明所在的块级成效域内一蹴而就。

if (true) {
  const MAX = 5;
}

MAX // Uncaught ReferenceError: MAX is not defined

const命令注解的常量也是不升官,同样存在近来性死区,只幸好宣称的岗位前面使用。

if (true) {
  console.log(MAX); // ReferenceError
  const MAX = 5;
}

上面代码在常量MAX表明以前就调用,结果报错。

const申明的常量,也与let一样不可重复声明。

var message = "Hello!";
let age = 25;

// 以下两行都会报错
const message = "Goodbye!";
const age = 30;

本质

const实际上保险的,并不是变量的值不得更改,而是变量指向的可怜内部存款和储蓄器地址不得更改。对于简易类型的数据(数值、字符串、布尔值),值就保留在变量指向的极度内部存款和储蓄器地址,由此等同常量。但对此复合类型的数码(首假如目的和数组),变量指向的内部存款和储蓄器地址,保存的只是2个指南针,const只好保险这几个指针是定点的,至于它指向的数据结构是还是不是可变的,就全盘不能够决定了。由此,将四个对象评释为常量必须更加小心。

const foo = {};

// 为 foo 添加一个属性,可以成功
foo.prop = 123;
foo.prop // 123

// 将 foo 指向另一个对象,就会报错
foo = {}; // TypeError: "foo" is read-only

地点代码中,常量foo储存的是贰个地方,这么些地址指向1个对象。不可变的只是以此地点,即不能把foo指向另3个地方,但指标自小编是可变的,所以依旧得以为其丰裕新属性。

上边是另三个例子。

const a = [];
a.push('Hello'); // 可执行
a.length = 0;    // 可执行
a = ['Dave'];    // 报错

地点代码中,常量a是2个数组,那一个数组自个儿是可写的,可是如若将另三个数组赋值给a,就会报错。

只要的确想将对象冻结,应该运用Object.freeze方法。

const foo = Object.freeze({});

// 常规模式时,下面一行不起作用;
// 严格模式时,该行会报错
foo.prop = 123;

地点代码中,常量foo指向一个冰冻的指标,所以添加新属性不起功用,严厉形式时还会报错。

除去将对象自小编冻结,对象的属性也相应冻结。上边是四个将对象彻底冻结的函数。

var constantize = (obj) => {
  Object.freeze(obj);
  Object.keys(obj).forEach( (key, i) => {
    if ( typeof obj[key] === 'object' ) {
      constantize( obj[key] );
    }
  });
};

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有