变量和常量的声明

VAR a = 34;            //一般的声明，不在函数内就是全局变量，值可以是基本和引用值，可以随时修改和删除

let 语法,同一个作用域的声明，只要有同样的声明都会报错（Uncaught SyntaxError），只能修改值

let newa = 34;

const语法，和let一样，但是不能更改值；

const b = 34;

以上两个语法都不存在变量提升的效果；直接使用的话，直接引用错误；

console.LOG(newb);        //ReferenceError
let newb = 34;

TDZ 暂时性死区，只要在同一作用域内，包括函数和块级全局，let 和const 就会绑定在这个区域，在这之前使用的话，都会报错，直到声明过后

使用let和const或者var在块级作用域内，会把变量限定在代码块内，无法突破；

{
tyPEof g;        //ReferenceError
typeof v;        //ReferenceError
typeof d;        //undefined
let g = 34;
const v = 3;
var d = 4;
};
typeof g;        //undefined
typeof v;        //undefined
typeof d;        //undefined

需要注意的是const变量的值是引用值的话，引用值的指针不变，就可以添加属性和方法，但是不能从重新指定对象引用值

const obj  = [];//声明一个常量对象
obj.name = 'obama'; //obama
obj.name = 'bush'    //bush;
obj = {}    // typeError

使用大括号{}相当于声明了一个代码块，可以无限制嵌套{{{{ }}}},

全局对象，在ES5之前，全局属性和方法是属于window的属性和方法，使用,window.valiable，都访问到，但是在es6的语法里，虽然在在全局声明的变量和对象都可以直接访问，和之前还是有区别的

var a = 45;
let b = 23;
window.a   ->45;
window.b  ->undefined; 

循环函数

for(var i = 0 ;i<10 ;i++){
    console.log(i);
}
//顺序输出0,,,,,9;
//此时console.log(i) ->10;i为全局变量；
var arr = [];
for(var i = 0 ;i<5 ;i++){
        arr.push(function(){return i})
}
//此时arr数组里面有5个函数function(){return i }；
//修改函数
for(var i = 0 ;i<5 ;i++){
    arr.push((function(i){return i})(i))
};
//执行
var i = 0;
arr.push();//此函数只会保存括号里的值，可以是任何值，函数也行，不一定是数值；
(function(){function(){return i})() //IIFE 此时的i值为0；输出0,不立即执行的话就是普通函数；
arr.push(0);//arr ->[0];
// .
// .
// .
 var i = 4;
arr.push();
(function(){function(){return i})() 
arr.push(4);//arr ->[0,1,2,3,4];
var i = 5;
i <5 //false;   

关于闭包,

为何let会保存原来的值？？

var arr = [];
for(let i =0;i<5;i++){
    arr.push(function(){console.log(i)})
};

//每次迭代

{ let i = 0; arr[0] = function(){console.log(i)} }    //此时因为let绑定在块级作用域，注意此处的{ };i的值只能访问到 i = 0；无法突破作用域，得到其他的值，但是确记住了此时的i值，类似闭包函数，而且不会改变！！
{ let i =1; arr[1] = function(){console.log(i)} }    
{ let i = 2; arr[2] = function(){console.log(i)} }    
{ let i =3; arr[3] = function(){console.log(i)} }    
{ let i = 4; arr[4] = function(){console.log(i)} }    

//let 这样的行为，并不会报错是因为ES6语法针对for ,for-of for-in 特殊规范的，在其他地方，对同一个let 变量赋值的话，会报语法错误
let i = 0;
let i = 1    //报错

let和const对于在循环中新的绑定不会报错对const修改值会报错，但绑定不会

const arr = ['a','b','c'];
const obj = {
    name:'obama',
    age :73
}
for(let i = 0;i<arr.length;i++){
    console.log(arr[i])
}
//a,b,c,此时的i没有声明，可以再次声明let i = 1111;
for(const i = 0;i<arr.length;i++){        //使用const初始化i值，但是i++试图修改时，就会报错，
    console.log(arr[i])
}
for(let i  of arr){
    console.log(i)
}
//a,b,c
for(const i  of arr){        //此处是const初始化i的值，但是没有试图修改，每次都是新的绑定，
    console.log(i)
}
//a,b,c完美运行
//注for in 和for of需要数据有iterator接口才能遍历
//let和const在循环中的行为是特殊设置的标准，

let 和const在函数使用默认值的时候也有一些行为规则