let
- let声明的变量不提升
if(true){
//tmp = 'abc';//ReferenceError
//console.log(tmp);//ReferenceError
let tmp; //暂时死区(TDZ)结束,在let命令声明变量tmp之前,都属于变量tmp的死区
console.log(tmp);//undefined
tmp = 123;
console.log(tmp);//123
}
//typeof x; //ReferenceError "暂时性死区"也意味着typeof不再是一个百分之百安全的操作,
//上面代码中,变量x使用let命令声明,所以在声明之前,都属于x的"死区",只要用到该变量就会报错.因此
//typeof运行时就会抛出一个ReferenceError
//let x;
typeof undeclared_variable; //undefined 在上面代码中,undeclared_variable是一个不存在的变量名,结果返回"undefined",
//所以,在没有let之前,typeof运算符是百分百安全的,永远不会报错.现在这一点不成立了
//var x = x; //不报错
let x = x; //ReferenceError : x is not defined
//使用let变量声明时,只要变量在还没有声明完成前使用,就会报错.在变量x的声明语句还没有执行完成前,就去取x的值,
//导致报错"x未定义"
//报错
function (){
let a = 10;
var a = 1;
}
//报错
function (){
let a = 10;
let a = 1;
}//let不允许在相同的作用域内,重复声明同一个变量.
function func(arg){
let arg; //报错
}
function func(arg){
{
let arg; //不报错,新的作用域
}
}
块级作用域
var tmp = new Date();
function f(){
console.log(tmp); //undefined
if(false){
var tmp = 'hello world';// if代码块的外部使用外层的tmp变量,内部使用内层的tmp变量,但是,函数f执行后,
//输出结果为undefined,原因在于变量提升,导致内层的tmp变量覆盖了外层的tmp变量
}
}
f();
var s = 'hello';
for(var i = 0 ;i<s.length;i++){
console.log(s[i]);// h e l l o
}
console.log(i);//5 变量i只用来控制循环,但是循环结束后,它并没有消失,泄露成了全局变量
function f1(){
let n = 5;
if(true){
let n = 10;
}
console.log(n); //5
}
f1();
{{{{
let insane = 'hello world';
{
let insane = 'hello world'
}
}}}} //内层作用域可以定义外层作用域的同名变量
块级作用域与函数声明
ES5规定，函数只能在顶层作用域和函数作用域之中声明，不能在块级作用域声明
//es6中
// function f(){
// console.log('i am outside');
// }
//
// (function (){
// if(false){
// //重复声明一次函数f
// function f(){
// console.log('i am inside');
// }
// }
// f(); //Uncaught TypeError: f is not a function
// }());
// 浏览器的 ES6 环境
function f() { console.log('I am outside!'); }
(function () {
var f = undefined;
if (false) {
function f() { console.log('I am inside!'); }
}
f();
}());
// Uncaught TypeError: f is not a function
{
let a = 'secret';
function f(){ //函数声明语句
return a;
}
}
{
let a = 'secret';
let f = function (){ //函数表达式
return a;
};
}
//考虑到环境导致的行为差异太大,应该避免在块级作用域内声明函数.如果确实需要,
// 也应该写成函数表达式,而不是函数声明语句
const
const PI = 3.1415;
console.log(PI) //3.1415
PI = 3;// TypeError: Assignment to constant variable.
// 上面代码表明改变常量的值会报错.const声明的变量不得改变值,这意味着,const一旦表明变量,
// 就必须初始化,不能留到以后赋值
const foo; // SyntaxError: Missing initializer in const declaration
//const声明的变量不得改变值,这意味着,const一旦声明变量,就必须立即初始化,不能留到以后赋值
//对于const来说,只声明不赋值,就会报错
if(true){
const MAX = 5;
}
MAX //Uncaught ReferenceError: MAX is not defined
//const的作用域与let命令相同,只在声明所在的块级作用域内有效
if(true){
console.log(MAX); //ReferenceError
const MAX = 5;
} //const命令声明的常量也是不提升,同样存在暂存性死区,只能在声明的位置后面使用
var message = "hello!";
let age = 25;
//一下两行都会报错 const 声明的常量,也与let一样不可重复声明
const message = "goodbye!";
const age = 30;
本质
- const实际上保证的，并不是变量的值不得改动，而是变量指向的那个内存地址不得改动。对于简单类型的数据（数值、字符串、布尔值），值就保存在变量指向的那个内存地址，因此等同于常量。但对于复合类型的数据（主要是对象和数组），变量指向的内存地址，保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，就完全不能控制了。因此，将一个对象声明为常量必须非常小心。
const foo = {};
// 为 foo 添加一个属性，可以成功
foo.prop = 123;
foo.prop // 123
// 将 foo 指向另一个对象，就会报错
foo = {}; // TypeError: "foo" is read-only
- 上面代码中，常量foo储存的是一个地址，这个地址指向一个对象。不可变的只是这个地址，即不能把foo指向另一个地址，但对象本身是可变的，所以依然可以为其添加新属性。
const a = [];
a.push('Hello'); // 可执行
a.length = 0; // 可执行
a = ['Dave']; // 报错
//常量a是一个数组，这个数组本身是可写的，但是如果将另一个数组赋值给a，就会报错。