Translation of this paper ☞ https://es6.ruanyifeng.com/#docs/ There are changes
let block level variable const block level constant
characteristic:
- Valid only in code blocks
{ let a = 3 } console.log(a); //a is not defined
-
There is no variable promotion
-
Temporary dead zone
var b = 233; if (true) { b = 1 let b;//Cannot access 'b' before initialization }
If it is Es5, VaR is OK
Within a code block, a variable is not available until it is declared using the let command. Syntactically, this is called "temporary dead zone" (TDZ)
- Don't make heavy statements
be careful:
Another special feature of the for loop is that the part that sets the loop variable is a parent scope, and the interior of the loop body is a separate child scope.
for (let i = 0; i < 3; i++) { let i = 'abc'; console.log(i); } // abc // abc // abc
- const
- The essence is:
It is not that the value of the variable cannot be changed, but that the data stored at the memory address pointed to by the variable cannot be changed.
const obj = { x: 1 } obj.x = 2 console.log(obj);//{"x": 2}
Deconstruction and assignment of variables:
destructuring
- Who can deconstruct assignment: as long as a data structure has an Iterator interface (write this later)
- Concept: "pattern matching". As long as the patterns on both sides of the equal sign are the same, the variables on the left will be given corresponding values.
- Details:
- Array:
- Basic writing:
let [foo, [[bar], baz]] = [1, [[2], 3]]; foo // 1 bar // 2 baz // 3
- Deconstruction failure: the value of the variable is equal to undefined, or both sides of the pattern are not equal.
let [bar, foo] = [1];
- Deconstruction semi successful:
let [a, [b], d] = [1, [2, 3], 4];
a // 1
b // 2
d // 4
-
Sequential correspondence: it corresponds one by one
-
Default values are supported
1.1 when can the default value be used: the default value will be used only when the right side is undefined
var [a = 1, b = 2, c = 3] = [undefined, null, NaN] console.log(a, b, c);//1,null,NaN
1.2 the default value is expression: the expression is inert and will be executed only when used
function f() { console.log('aaa'); } let [x = f()] = [1];//x=1
function f() { console.log('aaa'); return 2 } //let [x = f()] = [1]; let [x = f()] = [undefined] //aaa console.log(x); //2
1.3 the default value can refer to other variables assigned by deconstruction, but the variable must have been declared.
let [x = 1, y = x] = []; // x=1; y=1 let [x = 1, y = x] = [2]; // x=2; y=2 let [x = 1, y = x] = [1, 2]; // x=1; y=2 let [x = y, y = 1] = []; // ReferenceError: y is not defined //Because it is executed sequentially, x = undefined and x=y; And y=undefined
Object:
- No installation order assignment, installation property name assignment
let { bar, foo } = { foo: 'aaa', bar: 'bbb' }; foo // "aaa" bar // "bbb"
let {foo} = {bar: 'baz'}; foo // undefined
Essence:
let { foo: foo, bar: bar } = { foo: 'aaa', bar: 'bbb' };
- Nesting is supported, but if the parent property of the object does not exist, an error will be reported
const node = { loc: { start: { line: 1, column: 5 } } }; let { loc, loc: { start }, loc: { start: { line }} } = node; line // 1 loc // Object {start: Object} start // Object {line: 1, column: 5}
- Deconstruction assignment can get inherited attributes
- Default value: the effective condition is consistent with the array
- Purpose: deconstruct function return value, function parameter default value, quick use of json, module import and deconstruction
character string
const [a, b, c, d, e] = 'hello'; a // "h" b // "e" c // "l" d // "l" e // "o let {length : len} = 'hello'; len // 5
Number and Boolean
- Convert to object first:
let {toString: s} = 123; s === Number.prototype.toString // true let {toString: s} = true; s === Boolean.prototype.toString // true
Deconstruction assignment of function parameters
- The incoming parameter has been deconstructed at the moment
function add([x, y]){ return x + y; } add([1, 2]); // 3
be careful
- undefined and null cannot be converted to objects, so an error will be reported when they are deconstructed and assigned.
- Do not use declared variables for deconstruction assignment, {x} like code blocks
- An array can be deconstructed by an object, but not vice versa
let arr = [1, 2, 3]; let {0 : first, [arr.length - 1] : last} = arr; first // 1 last // 3