ES6核心基础（一）

1，es6新增的关键字

1.1let申明变量

例：let num = 10;

{    let num = 10;
//console.log(num);
}
console.log(num);

注：关键字let和var申明变量的区别：
1，使用var关键字申明的变量不存在块级作用域，而使用let关键字申明的变量有块级作用域（代码块内有效）；2，let只能申明一次而var可以申明多次；3，let不存在变量提升，var存在变量提升。

1.2 const申明变量

例1， const a = 10;
例2，

var a = 10;
        if (true) {    
       console.log(a);    
      const a = 10;
       }

注:const是申明一个常量一经申明不可改变，且const申明的常量存在暂时性死区如例2

2，解构赋值

2.1数组模型的解构

例：

// 1,基本
let [a, b, c] = [1, 2, 3];
// 2,嵌套
let [a, [    [b]], c] = [1, [    [2], 3]];
// 3,可忽略
let [a, ,b]=[1,2,3];
// 4,不完全解构
let [a=1,b]=[];
// 5,剩余运算符
let [a,...b]=[1,2,3];
// 6,字符串
let [a,b,c,d,e]="nihao";
// 7,解构默认值
let [a=2]=[undefined];
// 当解构模式有匹配结果，且匹配结果是 undefined 时，会触发默认值作为返回结果。

2.2对象模型的解构

// 对象模型的解构
// 1，基本
let { name, age } = { name: "lisi", age: 23 };
// 2,可嵌套可忽略
let obj={p:['hello',{y:'wor;d'}]};
let {p:[a,{y}]}=obj;
let {p:[x,{}]}
// 3,不完全解构
let obj={p:[{y:'wor;d'}]};
let {p:[{y},x]}=obj;
// 4,剩余运算符
let {a, b, ...rest} = {a: 10, b: 20, c: 30, d: 40};
// a = 10// b = 20// rest = {c: 30, d: 40}
// 5，解构默认值
let {a = 10, b = 5} = {a: 3};// a = 3; b = 5;

3，symbol

3.1Symbol的创建

例：

let person=Symbol();   //不传参数
let person=Symbol(name);   //传递字符参数

注:Symbol是一个基础的数据类型，当我们使用typeof检测它的数据类型的时候它会返回一个Symbol

3.2Symbol.for()的使用

// Symbol.for()方法的使用
let name = Symbol.for('name');
let Obj = {};
Obj[name] = "zhangsan";
console.log(Obj[name]);     //输出结果：zhangsan
console.log(name);          //输出结果:Symbol(name)

3.3Symbol实例唯一

let s2 = Symbol('name')；
let s3 = Symbol('name')；
console.log(s2 === s1);      //输出结果：false

3.4Symbol作为对象的属性名

et obj = {    
[Symbol('name')]: '张三',    
age: 18,    
title: 'student'
}
for (key in obj) { 
   console.log(obj[key]);
   }

注:使用Symbol作为对象的属性名是不能通过Object.keys()或者for…in来访问，所以当使用JSON.stringify()将对象转换未字符串是Symbol属性会被排除在外
例：

let obj = {    
[Symbol('name')]: '张三',    a
ge: 18,    
title: 'student'}
for (key in obj) {    
console.log(obj[key]);
}
var obj1 = JSON.stringify(obj)；
console.log(obj1);

输出结果：

3.5使用Symbol来替代常量

const TYPE_n = Symbol();
const TYPE_m = Symbol();
const TYPE_b = Symbol();

注:这样定义的好处是保证了定义的常量的唯一性

3.6使用Symbol可以定义类的私有属性和方法

3.7注册和获取全局变量

let gs1 = Symbol.for('global_symbol_1')  //注册一个全局Symbol
let gs2 = Symbol.for('global_symbol_1')  //获取全局Symbol

4,Map

4.1Map对象的创建

const n = new Map()

注Map和传统对象的区别：

• 传统对象的键名只能用字符串或symbol而Map可以以任何数据类型作为键名。
  *Map可以接收一个迭代对象作为参数初始化：
  例：

const map = new Map([
  ['name', '张三'],
  ['title', 'student']
]);

map.get('name') //张三
map.get('title') //student

注：如果 map 中存在相同的键名（比较规则是栈内存中是否一致，只要内存地址不一样，就视为两个键），则后面的赋值会覆盖前面的如果读取一个未知的键，则返回 undefined。

4.2Map的方法

// size 属性可以返回 map 的长度。
// Map.prototype.set(key,value) —— 添加或修改键值对，返回值是当前的集合，所以可以采用链式调用。
// Map.prototype.get(key) —— 根据 key 获取 value
// Map.prototype.has(key) —— 是否含有键名 key，返回布尔值
// Map.prototype.delete(key) —— 删除某个 key-value
// Map.prototype.clear() —— 清空集合
// Map.prototype.keys() —— 返回键名的遍历器
// Map.prototype.values() —— 返回键值的遍历器
// Map.prototype.entries() —— 返回键值对的遍历器
// Map.prototype.forEach() —— 遍历集合

4.3Map的遍历

const map = new Map([    
['name', '张三'],    
['title', 'Author']
]);
for (let key of map.keys()) {
    console.log(key);
}
// 输出结果：name  title
for (let value of map.values()) {
    console.log(value);
}
// 输出结果：  name  title   张三  Authorfor (let item of map.entries()) {
    console.log(item[0], item[1]);
}
// 输出结果：// name 张三// title Authorfor (let [key, value] of map) {
    console.log(key, value);
}
// 输出结果：// name 张三// title Author

4.4Map结构转化为数组结构

const map = new Map([  
['name', 'zhangsan'],  
['age', 12],  
['sex', '女'],
]); 
[...map.keys()]
// ['name', 'age', 'sex'] 
[...map.values()]
// ['zhangsan', 12, '女'] 
[...map.entries()]
// [['name','zhangsan'], ['age', 12], ['sex', '女']] 
[...map]
// [['name','zhangsan'], ['age', 12], ['sex', '女']] 

注Map转化为数组结构就可以使用数组的方法例：
filter方法：

const map = new Map([    
['name', '张三'],   
 ['title', 'Author']
 ]);
 const map1 = new Map(
    [...map].filter(([k, v]) => k < "title")
);
console.log(map1);
// 输出结果：Map { 'name' => '张三' }

map方法：

const map = new Map([   
 [1, 'a'],   
  [2, 'b']
  ]);
  const map2 = new Map(
    [...map].map(([k, v]) => [k * 2, '_' + v])
);
console.log(map2);
// 输出结果：Map { 2 => '_a', 4 => '_b' }

4.5Map 和JSON的相互转换

4.5.1Map和JSON字符串的转换

1）Map转换为JSON字符串

function mapToJson(map) {    
return JSON.stringify([...map]);
}
let map1 = new Map().set('name', "zhangsan").set('sex', "女");
console.log(mapToJson(map1));
//输出结果：[["name","zhangsan"],["sex","女"]]

2）JSON字符串转化为Map

function jsonToMap(jsonStr) {    
return new Map(JSON.parse(jsonStr));
}
console.log(jsonToMap('[["name","zhangsan"],["sex","女"]]'));
// 输出结果：Map { 'name' => 'zhangsan', 'sex' => '女' }

4.5.2Map和数组的相互转换

// Map 构造函数可以将一个 二维 键值对数组转换成一个 Map 对象
var mp1 = new Map(Array);
// 使用 Array.from 函数可以将一个 Map 对象转换成一个二维键值对数组
var outArray = Array.from(mp2);

4.5.3Map的合并

var map3 = new Map([...map1, ...map2]);

注：合并两个 Map 对象时，如果有重复的键值，则后面的会覆盖前面的

5，Set对象

5.1Set 对象存储的值总是唯一的

const s = new Set(); 
[2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x));
 for (let i of s) {
   console.log(i);
   }
   输出结果：// 2 3 5 4

const set = new Set([1, 2, 3, 4, 4]);
[...set]
// [1, 2, 3, 4]
set.size 
// 4

根据Set的特性可以实现数组去重：
例：

// 去除数组的重复成员
[...new Set(array)]
//函数去重
function dedupe(array) { 
 return Array.from(new Set(array));
 } 
 dedupe([1, 1, 2, 3])
  // [1, 2, 3]

5.2Set的方法

1，操作数据类：
1）add(value)：添加某个值，返回Set结构本身。
2）delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
3）has(value)：返回一个布尔值，表示该值是否为Set的成员。
4）clear()：清除所有成员，没有返回值。
2，遍历方法类：
1）keys()：返回键名的遍历器

2）values()：返回键值的遍历器

3）entries()：返回键值对的遍历器

4）forEach()：使用回调函数遍历每个成员