ES6简介
1.ES6 全程ECMAScript 6.0
主要是为了解决ES5的先天不足
目标与愿望：
1.适应更复杂的应用
2.实现代码库之间的共享
3.不断 代维护新版本
4.支持更多语法，使用更方便
新的变量声明方式 let\const
ES6之前，使用声明变量，可以声明多次变量，这样导致的问题查找很难
在ES6中，使用let声明变量，使用const声明常量
let作用域是块级作用域，如：
解构赋值
解构赋值语法是一种JavaScript表达式，用来将数组中的值或对象中的属性取出来区分为不同变量
分为：对象解构赋值和数组解构赋值
案例：定义一个对象，表示3维空间中的一个点，需要用这些坐标点进行开平法计算：
使用解构赋值，能更简单的采集到这些坐标 --对象解构赋值
还有其他形式的解构赋值，如：数组解构赋值
解构赋值能很好的运行在对象中，但它同样也能很快的作用于数组中。
箭头函数是ES6提供的新的语法结构，用于替换匿名函数
相当于简写了function，使用（）代替，使用=>代替{ }
<script>
var show=function(){
console.log("hello word!");
}
show();
var show2=() =>{
console.log("hello word");
show2
}
var show3=function(name){
console.log(name);
}
show3("hxy");
var show4 = name =>{
console.log(name);
}
show4("hxy");
var add =function(a,b){
return a+b;
}
console.log(add(1,2));
var add1=(a,b)=>{
return a+b
}
console.log(add1(1,2));
var add3=(a,b)=>a+b;
console.log(add3(1,2))
</script>
剩余参数
...用于声明剩余的参数，a、b是命名参数，...c用来收集剩余参数
...也称为扩展运算符，通过...运算使得两个数组实现深拷贝
<script>
//数据的解构赋值
let [x,y,z] =[1,2,3]
console.log(x +","+y+","+z+",")
//对象的解构赋值
let newPoint={
x:2,
y:4,
z:5
}
let {x,y,z} =newPoint;
console.log(Math.sqrt(x*x+y*y+z*z).toFixed(2))
let newPoint={
x:2,
y:4,
z:5
}
let x=newPoint.x;
let y=newPoint.y;
let z=newPoint.z;
let distance=Math.sqrt(x*x+y*y+z*z)
console.log(distance);
</script>
数组展开
传递三个参数，实现一个计算任意个数之和的add函数
传递参数的时候，可以使用...
<script>
function show(a,b,...c){
console.log(a);
console.log(b);
console.log(c);
}
show(1,2,3,4,5,9)
let arr =[1,2,4]
console.log(arr);
console.log(...arr);
function add(...aar){
return arr.reduce((previous,current)=>{
return previous+current;
})
}
参数模板（模板字符串）
模板字符串是为了解决使用“+”号拼接字符串的不便利而出现的
它的功能非常强大，但是大多数时候使用它则非常简单
￥{变量名称/常量名称}。外面是由 (反单引号)包裹
<script>
let a="hello";
let b="world";
let c='${a+b}';
let d='${a} ${b}';
console.log(c);
console.log(d);
//对运算的支持
let x=1;
let y=2;
let result='${x+y}';
console.log(result);
</script>
数组方法
Array.from(json):将json字符串转为数组，json字符串转为数组，json字符串务必要有长度属性
实例方法find（）：从数组中查找，传入一个有3个参数的匿名函数：1.value：当前查找的值 2. index：当前查找的数组索引3.arr：当前数组
//json数组格式转换
let json={
'0':"niit",
'1':"computer",
'2':"mobile",
length:3
}
let arr1=Array .from(json);
console.log(arr1);
function test(a,b){
let arr= Array.from(arguments,value=>value+2);
console.log(arr);
}
test(1,2);
//查找
let arr3 = [1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(arr3.find(function(value, index, arr) {
return value > 5
}));
实例方法fill（value，start，end）：使用给定值填充数组，数组中的原有元素会被抹去，从位置start开始填充，不包含end位置
遍历数组，一下3个方法都返回一个遍历器对象，可以使用for...of循环遍历，或使用next（）遍历 ：1.entries（）：键值对遍历2.keys（）：键名遍历3.values（）：键值遍历
//填充
let arr4=[1,2,3,4,5,6,7,8,9]
arr4.fill(1,2,5);
console.log(arr4);
//数组遍历
let arr5 = ['niit','computer','mobile'];
//输出也索引
for(let index of arr5.keys()){
console.log(index);
}
//输出值
for(let index of arr5.values()){
console.log(index)
}
//输出索引和内容
for(let [index,val] of arr5.entries()){
console.log(index+":"+val);
}
//entries()方法
let list =arr5.entries()
console.log(list.next().value);
map: 返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值
案例：一个数组存取了5位学生的成绩，大于等于360分显示及格，否则小于60分显示不及格，按照成绩的顺序，将及格/不及格显示在新的数组中。
//map
let scores2 =[23,45,76,85,34,64]
let scores1 = scores2.map(function(score){
if(score>=60){
return '及格';
}else
{return '不及格';
}
});
console.log(scores2);
console.log(scores1);
JavaScript异步编程
● 方案
● 回调函数Callback
● 事件监听
● 发布订阅
● Promise/A+
● 生成器Generators/yield·
● async/ Await
Promise
异步编程的解决方案，比传统的解决方案–回调函数和事件–更合理和更强大，完美解决回调地狱问题
简单说就是一个容器，保存某个未来才会结束的事件
Promise对象的特点：
对象的状态不受外界影响。Promise对象代表一 个异步操作，有三种状态:pending (进行中)、fulfilled (已成功)和rejected (已失败)。
一旦状态改变,就不会在变。Promise对象的状态改变，只有两种可能:从pending变为fulfilled和从pending变为rejected.
前端模块化
JavaScript模块化进程：
1.全局function模式：将不同功能封装成不同的全局函数，会污染全局命名空间
2.namespace模式：简单对象封装，解决了命名冲突，但是数据不安全
3.IIFE模式：匿名函数自调用，解决了数据安全，但模块依赖存在问题
4.ITFE模式增强：引入依赖，现代模块实现的基石
模块化的优势
1.避免命名冲突（减少命名空间污染）
2.更好的分离，按需加载
3.更高复用性
4.高可维护性
namespace模式
引入多个script后出现的问题
问题：请求过多，依赖模糊，难以维护
解决方案:
1.模块化规范：CommonJS、AMD、ES6、CMD等规范。
2.CommonJS：Node应用采用CommonJS模块规范。主要用于服务器端。
3.AMD：非同步加载模块，允许指定回调函数，浏览器端一般采用AMD规范。
4.ES6：ES6模块的设计思想是尽量的静态化，使得编译时就能确定模块的依赖关系，以及输入和输出的变量。
5.CMD：专门用于浏览器端，模块的加载时异步的，模块使用时才会加载执行。CMD规范整合了CommonJS和AMD规范的特点。
CommonJS模块化规范
CommonJS：
● Node应用有模块组成，采用CommonJS模块规范
● 每隔文件就是一个模块，有自己的作用域
● 在一个文件里面定义的变量、函数、类，都是私有的，对其他文件不可见
● 在服务器端，模块的加载是运行时同步加载的
● 在浏览器端，模块需要提前编译打包处理
特点：
● 所有代码都运行在模块作用域，不会污染全局作用域。
● 模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存，以后再加载就直接读取缓存结果。要想让模块再次运行，必须清楚缓存。
● 模块加载的顺序，按照其在代码中出现的顺序。
CommonJS基本语法
暴露模块：
● module.exports = value
● exports.xxx = value
引入模块：
● require（xxx），如果是第三方模块，xxx为模块名
● 如果是自定义模块，每个模块内部，module变量代表当前模块，它的exports属性（即module.exports）是对外的接口
● 加载某个模块，就是加载该模块的module.exports属性
