ES6学习笔记（一）--------------------------------------let和const

let和var同样也是用来定义变量，不一样之处在于let是块级做用域，只在所定义的块级做用域中生效，一个花括号即是一个块级做用域

{var a="我是var定义的";let b="我是let定义的"}
console.log(a);  //我是var定义的
console.log(b); //b is not defined

能够看出let定义的变量在全局做用域内并无生效

若是咱们在全局做用域中定义，试一下看在函数或者流程控制语句中是否会输出

let a="我是let定义的"
var b=0;
while(b<5){b++;console.log(a)}//⑤我是let定义的变量
if(true){console.log(a)}//我是let定义的变量

咱们发现这样能够输出

若是咱们反向来一下呢

for(let i=0;i<5;i++){
let a="流程控制语句花括号中的let";
var b="流程控制语句花括号中的var";
console.log(i)}
//0,1,2,3,4
console.log(a);
//a is not defined
console.log(b);
//流程控制语句中的var

for(var j=0;j<1;j++){
console.log(j)}
// 0
console.log(j);
//1

咱们发现let定义的变量不会被提高，只要有块级括号存在，它就只在该块级中有意义

若是在函数中呢

function test(){console.log(a)}() //报错

咱们发现并不能输出

咱们能够得出结论，流程控制语句中的变量均属于全局变量，可是在流程控制语句中的括号中定义则为块级，不会提高为全局变量

for循环还有一个特别之处，就是设置循环变量的那部分是一个父做用域，而循环体内部是一个单独的子做用域

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

let在for循环声明的变量每一次循环的值都会被引擎内部记下，可是var声明的变量则会刷新覆盖掉上一次的值

var a=[];
for(var i=0;i<10;i++){
a[i]=function(){return i};}
console.log(a)//[f,f,f,f,f,f,f,f,f,f]
a.forEach((e)=>{console.log(e())})
//⑩10

咱们能够看出，这种方式其实将未执行的函数push进数组了，当每次调用时候发现此刻的i早已经被循环覆盖掉，最终输出都为此刻的i值10

var a=[];
for(let i=0;i<10;i++){
a[i]=function(){return i};}
console.log(a)//[f,f,f,f,f,f,f,f,f,f]
a.forEach((e)=>{console.log(e())})
//0,1,2,3,4,5,6,7,8,9

可是对于let声明的变量，每一次引擎都会自动存储记录i的值，而不会覆盖掉，所以每次输出都是push当时的i值

let不存在变量提高，只有在定义后再使用才不会报错

console.log(a);var a=1;//undefined
console.log(b);let b=2;//报错

let具备强制性绑定变量的能力，原先var声明的变量，当被let从新声明的时候会被强制性绑定，原先var声明的全部被let所管辖的块级做用域里的变量均被let强制为本身声明的值，造成暂时性死区，let所处块级做用域中let声明以前的该变量均报错

var a=1;
{console.log(a);
let a=2;}
//a is not defined

var a=1;
{let a=2;
console.log(a);//2
};
console.log(a)//1

var a=1;
console.log(a);//1
{let a=2;
console.log(a);//2
};

let不容许在相同做用域内，重复声明同一个变量。

{var a=0;
let a=1;
console.log(a)}//报错

{let a=0;
var a=1;
console.log(a)}//报错

{
let a=2;
let a=3;
console.log(a)}//报错

{let a=2;
console.log(a);
let a=3;}//报错

上面的最后一个例子能够看出当再次声明该变量以前调用的变量都会炸掉

咱们能够看到let声明的变量能够引用块级做用域外面的函数

let a=f();
function f(){
return 1
}
console.log(a)// 1

{let a=f();
console.log(a)// 1
function f(){
return 1
}

const声明的变量为永恒变量，不能更改，并且声明之后必须初始化

const a;//报错

const b=1;
b=2//报错

const的做用域与let命令相同：只在声明所在的块级做用域内有效。
const命令声明的常量也是不提高，一样存在暂时性死区，只能在声明的位置后面使用。
const声明的常量，也与let同样不可重复声明。
const实际上保证的，并非变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，所以等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是否是可变的，就彻底不能控制了。所以，将一个对象声明为常量必须很是当心。

常量foo储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把foo指向另外一个地址，但对象自己是可变的，因此依然能够为其添加新属性。

const foo={};
foo.prop=123;
console.log(foo.prop)//123

常量a是一个数组，这个数组自己是可写的，可是若是将另外一个数组赋值给a，就会报错。

const a=[];
a.push(1);
console.log(a)//[1]
console.log(a.length)//1
a=[]//报错

再来验证如下引用

var a=1;
b=a;
console.log(b);//1
a=2;
console.log(b)//1
b=3;
console.log(a)//2

能够看出var定义的变量，b=a时候，是直接复制了一份a，并非a的引用

let a=1;
b=a;
console.log(b);//1
a=2;
console.log(b);//1
b=3;
console.log(a);//2
console.log(b);//3
var b=4;
console.log(b)//4

能够看出let也同样
const也是复制一份

const a=1;
b=a;
console.log(b);//1
b=3;
console.log(a);//1
console.log(b);//3
var b=4;
console.log(b)//4

还有不少不甚明朗的地方，各位大佬能够指点一二，互相学习，加深理解