ES6 知识点总结~~~上

ES6 变量的声明与表达式

let和const

   et

   let 声明的变量只在 let 命令所在的代码块内有效。

基本用法

{
  let a = 0;
  a   // 0
}
a   // 报错 ReferenceError: a is not defined
	 //不同作用域无法访问　

  let 是在代码块内有效，var 是在全局范围内有效:

{
  let a = 0;
  var b = 1;
}
a  // ReferenceError: a is not defined
b  // 1

不能重复声明

let 只能声明一次 var 可以声明多次:

let a = 1;
let a = 2;
var b = 3;
var b = 4;
a  // Identifier 'a' has already been declared
b  // 4

不存在变量提升

let 不存在变量提升，var 会变量提升:

console.log(a);  //ReferenceError: a is not defined
let a = "apple";
 
console.log(b);  //undefined
var b = "banana";

const

   const 声明一个只读的常量，一旦声明，常量的值就不能改变。 

const PI = "3.1415926";
PI = 123456 // 报错　

暂时性死区:

var PI = "a";
if(true){
  console.log(PI);  // ReferenceError: PI is not defined
  const PI = "3.1415926";
}

ES6 明确规定，代码块内如果存在 let 或者 const，代码块会对这些命令声明的变量从块的开始就形成一个封闭作用域。代码块内，在声明变量 PI 之前使用它会报错。

注意要点

const 如何做到变量在声明初始化之后不允许改变的？

其实 const 其实保证的不是变量的值不变，而是保证变量指向的内存地址所保存的数据不允许改动。此时，简单类型和复合类型保存值的方式是不同的。对于简单类型（数值 number、字符串 string 、布尔值 boolean）,值就保存在变量指向的那个内存地址，因此 const 声明的简单类型变量等同于常量。而复杂类型（对象 object，数组 array，函数 function），变量指向的内存地址其实是保存了一个指向实际数据的指针，所以 const 只能保证指针是固定的，至于指针指向的数据结构变不变就无法控制了，所以使用 const 声明复杂类型对象时要慎重。

解构赋值

什么是解构

在ES6中 按照一定的模式 从数组中提取数 对对应的变量进行赋值的操作 就叫做解构赋值

本质上讲 解构赋值 就是模式匹配

解构模型

在解构中，有下面两部分参与：

解构的源，解构赋值表达式的右边部分。解构的目标，解构赋值表达式的左边部分。

数组模型的解构

var [a, b, c] = [1, 2, 3];
// a = 1
// b = 2
// c = 3

可以嵌套

var [a, b, c] = [1, [2], 3];
// a = 1
// b = [2]
// c = 3

　　

不完全解构

var [a,b,c] = [1,2]
// a = 1
// b = 2
// c = undefined
1
2
3
4
var [a,b,c] = [1,2,3]
// a = 1
// b = 2
//这个也属于不完全解构 多的值直接忽略
1
2
3
4
扩展运算符

let [a, ...b] = [1, 2, 3];
//a = 1
//b = [2, 3]
1
2
3
支持默认值

let[a,b = "abc"] = [1];
// a = 1
// b = "abc"
1
2
3

数组的拷贝

var arr = [1,2,3]
var arrsp = [...arr]
// arrsp = [1,2,3]
1
2
3

字符串等

在数组的解构中，解构的目标若为可遍历对象，皆可进行解构赋值。可遍历对象即实现 Iterator 接口的数据。

let [a, b, c, d, e] = 'hello';
// a = 'h'
// b = 'e'
// c = 'l'
// d = 'l'
// e = 'o'
1
2
3
4
5
6

对象的扩展

属性的简介表示方法

ES6在{} 允许直接写入变量名 解析的时候 变量名作为属性名 变量值作为属性值

const age = 12;
const name = "Amy";
const person = {age, name};
person   //{age: 12, name: "Amy"}
//等同于
const person = {age: age, name: name}
方法名也可以简写

const person = {
  sayHi(){
    console.log("Hi");
  }
}
person.sayHi();  //"Hi"
//等同于
const person = {
  sayHi:function(){
    console.log("Hi");
  }
}
person.sayHi();//"Hi"
属性名表达式
ES6允许用表达式作为属性名，但是一定要将表达式放在方括号内。

const obj = {
 ["he"+"llo"](){
   return "Hi";
  }
}
obj.hello();  //"Hi"

注意点：属性的简洁表示法和属性名表达式不能同时使用，否则会报错。

const hello = "Hello";
const obj = {
 [hello]
};
obj  //SyntaxError: Unexpected token }
 
const hello = "Hello";
const obj = {
 [hello+"2"]:"world"
};
obj  //{Hello2: "world"}

对象的新方法

Object.assign()

用于用来合并对象的

let target = {a: 1};
let object2 = {b: 2};
let object3 = {c: 3};
Object.assign(target,object2,object3);  
// 第一个参数是目标对象，后面的参数是源对象
target;  // {a: 1, b: 2, c: 3

1. 返回值是传入的第一个目标对象 会把所有的对象合并上去时候

2. 第一个参数必须是对象 如果不是对象 就会把它准换成对象

3. 如果是undefined 或者 null 没办法转换成对象 name 就会报错

4. 如果在需要合并的多个对象里面 有同名的属性 那么后面的属性就会啊对前面的进行覆盖

5. 如果undefined和null不是第一个参数 那么就不会报错 第一个参数返回

6. assign方法是浅拷贝 不是深拷贝

Object.is()

这个方法和js的严格判断（===）用法基本一样 只是在对于 -0 和 +0 以及NaN 的判断的时候不同

console.log(-0 === +0);//true ====> 需要他是 false
console.log(NaN === NaN);//false ====> 需要他是 true

console.log(Object.is(-0, +0)); //false
console.log(Object.is(NaN, NaN)); //true

Object,setPrototypeOf

给一个对象设置原型对象

如果对象的[[Prototype]]被修改成不可扩展(通过 Object.isExtensible()查看)，就会抛出 TypeError异常。如果prototype参数不是一个对象或者null(例如，数字，字符串，boolean，或者 undefined)，则什么都不做。否则，该方法将obj的[[Prototype]]修改为新的值。

var dict = Object.setPrototypeOf({}, null);

　　

 

var PI = "a";
if(true){
  console.log(PI);  // ReferenceError: PI is not defined
  const PI = "3.1415926";
}