一、symbol
javascript基本数据类型:
null、undefined、number、boolean、string、symbol
ES6 引入了一种新的原始数据类型Symbol，表示独一无二的值（随机生成的一个永远都不会重复的id串）
let s = Symbol();
typeof s
// "symbol"二、Set和Map
1、Set()
是es6提供的一种新的数据结构，类似于数组，但是set里面的数据具有唯一性
const s = new Set();Set实例的属性和方法
let set = new Set([1, 2, 3, 4, 4]);
//返回实例的总数
set.size //5
//操作方法
set.add(value) //添加某个值，返回结构本身
set.delete(value) //删除某个值,返回一个布尔值
set.has(value) //返回一个布尔值，表示是否为set成员
set.clear() //清空所有成员，无返回值
//遍历方法
keys()，values()，entries()
// 注：Set 结构没有键名,只有键值，所以keys()，values()的行为完全一致2、Map()
Map 数据结构,它类似于对象,但是键的范围不限于字符串，可以为各种类型的值（包括对象）
let map = new Map();
let obj = {msg:'hello'}
//map设置和获取值（用一个对象作为了键）
map.set(obj, 'content')
map.set('key', 'value')
map.get(obj) //'content'
//size 属性
map.size //2
//返回一个布尔值，表示某个键是否在当前 Map 对象之中
map.has(obj) //true
//删除某个键，返回true。如果删除失败，返回false
map.delete(obj) //true
//清除所有成员，没有返回值。
map.clear()
//遍历方法
keys()，values()，entries()
//注：Map 的遍历顺序就是插入顺序三、promise
是异步编程的一种解决方案，可以处理多个异步请求的执行顺序等
//基本用法
let p1 = function(){
return new Promise((resolve,reject)=>{
//异步操作1，成功执行resolve函数，失败执行reject函数
})
}
let p2 = function(){
return new Promise((resolve,reject)=>{
//异步操作2，成功执行resolve函数，失败执行reject函数
})
}
p1.then((data)=>{
console.log('成功的回调')
},(err)=>{
console.log('失败的回调')
})
//Promise.all方法用于将多个 Promise 实例，包装成一个新的 Promise 实例
let p = Promise.all([p1,p2])
p.then((data)=>{
//两个都执行了resolve方法
}).catch((err)=>{
//一个不满足就执行这里
})四、Generator函数 和 async函数
1、Generator函数
ES6 提供的一种异步编程解决方案
操作繁琐，需要手动调用next方法，不常用
function* test(){
yield 'hello'; //yield可以为一个异步函数的返回结果
yield 'world';
...
}
let result = test();
console.log(result.next()); // { value: 'hello', done: false }
console.log(result.next()); // { value: 'world', done: false }
console.log(result.next()); // { value: undefined, done: true }2、async函数（es7）
它就是 Generator 函数的语法糖
async函数返回一个 Promise 对象，可以使用then方法添加回调函数。
function timeout(ms) {
return new Promise((resolve, reject) => {
setTimeout(resolve, ms, "finish");
});
}
async function asyncTimeSys(){
await timeout(1000);
console.log("第一层异步结束！")
await timeout(1000);
console.log("第二层异步结束！")
await timeout(1000);
console.log("第三层异步结束！")
await timeout(1000);
console.log("第四层异步结束！")
await timeout(1000);
console.log("第五层异步结束！")
return "all finish";
}
asyncTimeSys().then((value)=>{
console.log(value);
});五、Class类
通过class关键字，可以定义类
1、基本用法
//es6之前定义类（构造函数）
function Person(name,age){
this.name = name;
this.age = age;
}
let student = new Person('小明',18);
//定义共有方法
Person.prototype.say = function(){
return this.name +'今年'+ this.age;
}
console.log(student.say()) //小明今年18
//通过class定义类
class Person {
//静态属性，直接通过Person.type拿到值
static type = '地球人';
//静态方法，通过Person.eat()调用
static eat(){
console.log('吃点啥');
}
//构造器定义类的属性
constructor(name,age){
this.name = name;
this.age = age;
}
//定义共有方法
say(){
return this.name +'今年'+ this.age
}
}
let student = new Person('小明',18)
console.log(student.say()) //小明今年18
2、class的继承
可以通过extends关键字实现继承
class Person {
constructor(name){
this.name = name;
}
say(){}
}
class Teachaer extends Person{
constructor(name,job){
super(name); //需要用到this，则必须执行一次super函数，
this.job = job;
}
work(){
return `${this.name}的工作是${this.job}`;
}
}
let xiaoming = new Teachaer('小明','教书')
console.log(xiaoming .work()) //小明的工作是教书六、Module语法
ES6之前已经出现了js模块加载的方案，最主要的是CommonJS(用于服务器端，如nodeJS)和AMD规范(用于浏览器，如requireJS)
1、export 导出
export用于对外输出本模块（一个文件可以理解为一个模块）变量的接口
//1、一个一个的导出
//导出多个变量
export var name = "小明";
export var age = 18;
//导出方法
export function say(){}
//导出类
export class Person{}
//2、多个一起导出
let a = 1;
let b = 2;
let c = 3;
export { a, b, c }
//通过向大括号中添加 a、b、c 变量并且export输出，就可以将对应变量值以 a、b、c 变量标识符形式暴露给其他文件而被读取到2、import 导入
import用于在一个模块中加载另一个含有export接口的模块。
//1、引入所有成员
import * as items from '模块路径'
//注：* 代表所有，as后面跟别名
//2、引入指定成员
import { a, b } from '模块路径'3、export default 导出默认成员
一个模块只能有一个export default
var name = '小明'
export default name;
//引入default成员
import name from '模块路径'