ES6语法的归纳
本文介绍ES6常用扩展。
竟然在图书馆借到了想买的ES6入门标准，省下一顿多伦多。[捂脸].jpg
一，变量声明扩展
1，let
在ES5声明变量的方法一直是var，var有着变量提升和全局声明的特点，也因此var声明的变量本身不存在块级作用域。
在ES6的let中，声明的变量仅在块级作用域中有效，且不会出现变量提升的情况。
var a = []
for(var i = 0 ; i < 10 ; i++){
a[i] = function(){
//此处闭包可以访问函数外其他作用域的变量i
//但是此时的i的值已经是10
console.log(i)
}
}
a[3]() //10
以上代码中由于function中的i，由var定义，没有块级作用域，最终结果10个函数都输出i的最终值10
var a = []
for(var i = 0 ; i < 10 ; i++){
(function(){
console.log(i)
})(i)
} //输出1-10
以上代码模仿块级作用域，也可以用闭包返回一个匿名函数，来实现块级作用域，但是闭包会导致资源泄漏等问题，需要主动释放资源。
var a = []
for(let i = 0 ; i < 10 ; i++){
a[i] = function(){
console.log(i)
}
}
a[3]() //3
使用let之后,每个i在都有一个单独的作用域，互相不受影响。
2，const
const用来声明常量，一旦声明不可改变。
const声明的常量也有块级作用域
和C里面的DEFINE差不多
3，解构赋值
ES6允许按照一定的模式，从数组和对象中提取值，对变量进行赋值，这被称为解构
var [a,b] = [1,2]
//按照对应的关系a为1，b为2
var [a,...b] = [1,2,3,4,5]
//a为1，b为数组形式[2,3,4,5]
//除了解构数组还能解构对象
var {foo,bar} = {foo:"aaa",bar:"bbb"}
console.log(foo) //"aaa"
console.log(bar) //"bbb"
//加载模块时，经常使用这种方法，可以准确地在对应模块中获取对应的参数
const {SourceMapConsumer,SourceNode} = require("source-map");
tip:使用如[x,y] = [y,x]可以交换变量的值
二，字符串扩展
1，includes、repeat、startsWith、endsWith
[1,2,3,4].includes(2)
//返回true
includes包含，若字符串/数组中包含所输入字符，则返回true，否则返回false
ES5中常用indexOf()，若包含字符所输则返回字符在字符串/数组中所在的位置，若不存在则返回-1
'abc'.startsWith('a') //true
'abc'.endsWith('c') //true 如其名= =
"x".repeat(3) //repeat接收一个number参数，返回一个此字符串重复n次的字符串，此处返回xxx
2，模板字符串
个人感觉，模板字符串的好处在于写前端代码需要写大量字符串拼接时可以使用，减少代码量。模板字符串用``反引号包裹，需要引用的变量用${x}包裹。
var x = 1,y = 2
console.log(`${x}+${y}=${x+y}`)
//1+2=3
三，数组的扩展
1，Array.from()
一行数组去重让我记忆犹新
console.log(Array.from(new Set([1,2,3,4,2,1])))
//[1, 2, 3, 4]
Array.from()可以将类数组和可遍历的对象转化为真正的数组
类数组，如Map，Set这种类型，本身无法调用数组的api，经Array.from()转化之后即可使用.
2，find()和findIndex()
数组实例的find用于找出第一个符合条件的数组函数，而findindex用于找出第一个符合条件的数组，两个函数的参数都是一个回调函数，所有元素会依次遍历该回调函数。该回调函数接收三个参数function(value,index,arr){}分别是当前的值、当前的位置、还有原数组。
[11,23,32,44,51].find(function(value,index,arr){
if(value%2==0){
return value
}
}) //返回第一个除以2余数为0的value，即32
[11,23,32,44,51].findIndex(function(value,index,arr){
if(value%2==0){
return value
}
})//如果换成findIndex，则返回第一个除以2为0的value的下标，即2
3，数组实例的entries()，keys()，values()
这三个方法都返回一个数组的迭代器Array Iterator {}，可以通过遍历获取其中的键值。
在ES5中对数组常用forEach遍历，得到数组的value/键值，而for...in获取数组的index序号/键名
而for...of始终用于获取值
这三个方法将其完全分隔，当需要获取该数组的键时使用keys()，需要获取值时使用values()，需要获取键值对则使用entries()。
var arr = ['a','b']
for(let index of arr.keys()){
console.log(index)
//返回arr的键位0,1
}
for(let item of arr.values()){
console.log(item)
//返回arr的值位a,b
}
for(let [index,item] of arr.entries()){
console.log(index,item)
//返回arr的键值index分别为0,1，item分别为a，b
}
对数组的所有类型的遍历上述方法都能实现，且代码更规范清晰。
四，对象的扩展
1，Object.assign()
Object.assign()接受两个参数，可以实现引用类型的深拷贝
var a = [1,2]
var copy = []
Object.assign(copy,a)
copy.push(3)
console.log(copy,a)
// (3) [1, 2, 3]
// (2) [1, 2]
// 对copy新增的数据并没有影响a
2，Object.setPrototypeOf(),Object.getPrototypeOf()
分别用于设置和获取对象proto指向的原型
tip : ES5的Object.creat()也可以动态设置对象的原型，此处为创建
3，Symbol
JS基本类型再添一员
1，Undefined 未定义
2，Null 空值
3，Boolean 布尔类型
4，Number 数字类型
5，String 字符串类型
6，Array 数组类型
7，Symbol 独一无二的类型
ES6书写Symbol类型可以通过.name获取其描述值，亲测不行= =
Symbol数据通过Symbol函数创建
var mySymbol = Symbol('cty')
此mySymbol是独一无二的，即使再创建一个mySymbol2有同样描述
mySymbol == mySymbol //false
4，Object.observe()和Object.unobserve()
用于监听一个对象的改变Object.observe(o,observer) //observer为改变时的回调
但是此提案已被撤回，类似的功能还有拦截代理proxy。待续
五，函数的扩展
1，扩展运算符...
与结构赋值相似，在函数参数中的...argument代表一个参数序列
function(...s){
//s可以是任意长度的字符串
console.log(s)
}
2，箭头函数
箭头函数只能在函数内部使用，因为其本身没有this域，它的this代表的是最近的，定义的构造函数所在的对象。使用示例：
var result = values.sort((a,b)=>{return a - b})
3，Generator遍历器
Generator函数与普通函数只有稍许差别，一是，function关键字后面带有一个号；二是函数体内部使用yield*语句定义遍历器的每个成员。
function* echoHello(){
yield 'hello'
yield '。'
return ’ending‘
}
var eH = echoHello() //储存echoHello函数，此时echoHello函数并不执行，而是返回了一个遍历器，此步是必要的
//之后每次对此遍历器执行.next操作，如果碰到yield语句，则暂停执行，并返回一个带返回值和执行是否结束的标志done
eH.next()
//{ value: 'hello' ， done: false }
eH.next()
//{ value:'。' ， done: false }
eH.next()
//{ value:'ending' ， done: true }
eH.next()
//{ value:undefined ， done:true }
generate的此种特性可以用来执行异步操作，因为.next()操作是同步执行，js又是单线程的，上一个.next方法未结束时，下一个.next方法并不会执行，只需要将任务顺序按次序在generate中排好即可。
4，promise对象
promise承诺，通过.then的链式调用避免了回调地狱，使异步操作更优雅，清晰
//以下新建一个promise对象
var promise = new Promise((resolve,reject)=>{
if(/*异步操作成功*/){
resolve(value)
}else{
//抛出错误
reject(error)
}
})
promise.then(value=>{ //success }).catch(err=>{ //error })
用promise实现原生ajax请求
var getJSON = function(url){
var promise = new Promise(function(resolve,reject){
var xhr = new XMLHttprequest()
xhr.open("POST",url,false)
xhr.onreadychange = function(){
if(this.readyState == 4){
if(this.status == 200){
//此处res是后端规定的返回对象
resolve(this.res)
}else{
reject(this)
}
}
}
xhr.send()
return promise //返回promise对象
})
}
getJSON('/post.json').then(function(json){
// 此处的json为getJSON函数返回的promise的resolve中所传递的返回值
//ajax请求成功后的后续操作
}).catch(function(err){
//失败操作
})
在传递成功后可以继续使用链式调用但是要保证给then方法传递的是一个promise对象，才可以继续执行.then操作，否则链式调用会中断。
5，class和extends
类和继承
class animals(){
//此处还是创建了构造函数
constructor(name){
this.name = name
this.say = function(){
console.log(this.name)
}
}
}
var cat = new animals('miaomiao') //class类只能通过new来调用，产生一个这个类的实例
cat.say() //miaomiao
经检测，animals.prototype.constructor == animals 返回true
typeof animals 返回function
每个class和class原型的constructor都是相等的，且每个class都是function
//此部分展示getter和setter的使用
class Class2{
get name(){
return 'jay';
}
set name(value){
console.log('set name = ' + value);
}
}
var c2 = new Class2();
c2.name = 'hu'; // "set name = hu" 设置时会触发class中的set函数
console.log(c2.name); // "jay" //获取时返回get中预先设置的值
继承
在ES5中，没有extend的帮助，采用的原型继承，使子类的原型对象成为父类的一个实例，子类中的prototype指针即指向了父类，再在子类的构造函数中动态调用父类的构造函数解决引用类型互相影响的现象，俗称组合继承。
如今
class cat extends animals{
constructor(character){
super(name) //子类中动态调用父类的构造函数
this.char = character
}
}
var myCat = new cat('miaomiao','quit')
myCat.say() //miaomiao
console.log(myCat.char) //quit
通过extends关键字，引入了子类父类的区别，类似于组合继承，依然没有完全脱离原型链的思想。
ES6语法写到这里，以后踩坑了再来补充把0.0
陈小源 2017/10/20
