ES6基础语法

为什么要用ES6？？？

	1. 具有模块化机制
	2. 简洁的语法
	3. 高效函数

1. 变量声明

    1. var
    	var a = 3;
    	1. 声明可以重复
    	2. 声明会提升
    		console.log(b);
    		var b = 3;
    	3. 没有局部作用域
    		if(true){
    			var c = 3;
    		}
    		console.log(c);    //c=3;
    		模拟
    		(function(){
    			var d = 3;
    		})()
    		console.log(d);    //d=3;
    2. let
    	1. 在同一作用域下声明不可以重复
    	2. 声明不会提升
    	3. 具有局部作用域
    		let a = 0;
    		if(true){
    			a++;	//报错
    			let a = 1;
    		}
    		console.log(a); 	//报错
    	4. 暂时性死区
    3. const
    	具备let的所有特性
    	只能被显示初始化一次
    	const a = 3;
    	a++;      //报错
   
    	const obj = {
    		age :12
    	}
    	console.log(obj);       //age=12;
    	obj.age++;           //因为obj里面存的是堆区指针，指针没改变，指针所指的值可以改变
    	console.log(obj);        //age=13;
   

2. 解构
   在一个表达式中为多个变量赋值

    1. 数组的解构
    	let [a,b,c,[d,e],f,g=0] = [1,2,3,[4,5],6];
    	
    	交换两个变量的值
    	let i = 1;
    	let j = 2;
    	[i,j] = [j,i]		
    2. 对象的解构
    	let {name:a,age:b} = {name:'terry',age:12}
    	a =terry, b=12
    	
    	category.js
    		module.exports = {
    			findAllCategory:function(){},
    			deleteCategoryById:function(){},
    			batchDeleteCategory:function(){},
    			updateCategory:function(){}
    		}
    	index.js
    	    	let {deleteCategoryById} = require('./category');
    	main.js
    		let {batchDeleteCategory,updateCategory} = require('./category');
   
   
   
    function ajax(url,{method='get',data={},dataType,async,success}){
    		
    	}	
    	$.ajax(url,{
    		dataType:'json',
    		async:true
    	})
   
   
    3. 字符串的解构
    	let [a,b,c,...d] = "hello"
    	let {length,substring} = "hello"
   
    	"hello"
   
    	substring(begin,end)
    	substr(begin,length)
    	"hello".substring(0,3)
    	substring(begin,end)
   
   
             'hello'.substring(0,3)   //截取hel
    	   substring.call('this',0,3)     //截取hel
    	   substr(begin,length)
   
   
   
    4. 数字的解构
    	let {} = 31
   

3. 拓展
   (1)对象拓展

    1. 对象简写
    	let name ="terry"
    	let obj = {
    		name,
    		age:12
    		sayName(){
    		}
    	}
    2. Object API拓展
    	Object.js()    //与===类似
    	Object.assign() 
    	Object.setPrototypeOf()
    	Object.getPrototypeOf()
    	__proto__
   
    	Object.keys(obj)        //返回属性名
    	Object.values(obj)           //返回属性值
    	Object.entries(obj)		//返回键值对
    		[["推荐",31],[],[],[]]
   
    	var data = {
    		"推荐":31,
    		"娱乐":23,
    		"IT":18,
    		"体育":17
    	}
    	Object.keys(data)
    	Object.values(data)
   

（2）函数拓展

1) 函数参数默认值           第三阶段 p45
2) rest参数
	function test(a,b,c){
		console.log(a,b,c);
	}
	var param = [1,2,3];
	test(...param); 	//1,2,3

	将字符串转换为数组
	[...'hello']        // ['h','e','l','l','o']
	[...'hello']            --->   ['h','e','l','l','o']
  	Array.from('hello')     --->   ['h','e','l','l','o']

3)箭头函数
	function(){}

	()=>{}

	一般用于回调函数中

	method.call(this，参数列表)
	method.apply(this，参数数组)
	箭头函数里面没有自己的this，而是引用外层的this
	
	function abc(){};
	abc(123)      //123是参数
	abc.call(111)      //111是this
	abc.apply(222)      //222是this
	
	arr.some(()=>{})
	arr.sort(()=>{})

	var obj = {
		sayName(){

		},
		sayAge(){

		}
	}

（3）数组的扩展

1) 语法
	let name = 'terry'
	[a(){},{name}]
2) Array API扩展
	1. Array.isArray(arr)   判断arr是否为数组
	2. Array.from()
		将可迭代或类数组对象转换为数组
		Array.from('hello')        // ['h','e','l','l','o']
	3. Array.of()
		初始化数组
		Array.of(3,0,8)     	  //[3,0,8]
3) Array.prototype API扩展
	Array.prototype.find()     	找到第一符合条件的值
	Array.prototype.findIndex()         找到第一符合条件的值的索引
	Array.prototype.fill()
	arr.forEach()
	arr.some()
	arr.every()
	arr.filter()
	arr.map()
	arr.find()
		找到第一符合条件的值
	arr.findIndex()
		找到第一符合条件的值的索引

	arr.fill()
		填充一个数组
		['a','b','c'].fill(7)          //[7,7,7]
		new Array(3).fill(7)      //[7,7,7]
	arr.keys()
		返回一个迭代器对象，通过for-of进行遍历
		迭代器对象中保存的是索引的集合,返回值是索引
	arr.entries()
		返回一个迭代器对象，通过for-of进行遍历
		迭代器对象中保存的是索引与元素组成的数组，返回值是索引和值
	arr.includes()
		[1,2,3].includes(2)     //true
		[1,2,3].includes(4)     //false
		[1,2,NaN].includes(NaN)     //true