前端学习之路 --ES6新特性

前言

这篇博客是我在b站进行学习es6课程时的笔记总结与补充。
此处贴出up主的教程视频地址：深入解读ES6系列(全18讲)

1、ES6学习之路

1.1 ES6新特性

1. 变量
2. 函数
3. 数组
4. 字符串
5. 面向对象
6. Promise
7. generator	//类似于Promise
8. 模块化

1.2 变量

1.2.1 let、var、const和作用域

知识点：
1. ES6之前的JS只有函数作用域和全局作用域，ES6引入了let后新增了块级作用域，还引入const。
2. 所有window对象内置属性都拥有全局作用域。

var
1. 可以重复声明
2. 无法限制修改
3. 函数作用域（在函数体内可访问）

let
1. 不能重复声明
2. 变量（可以修改）
3. 块级作用域（在大括号{}内可访问）



const
1. 不能重复声明
2. 常量（不能修改）
3. 块级作用域

[块级作用域]
说明：因为var是全局变量，js是单线程运行，而for循环是同步执行，onclick()是异步执行，所以for循环执行完成后，全局变量i为3，再执行onclick()就得到了3
var btn=document.getElementsByTagName('input');	//有三个input组件
for(var i=0;i

1.2.2 立即执行函数（IIFE / Immediately Invoked Function Expression）

此处引用自stpice的博客

知识点：
function foo(){}	//这是定义（Declaration），让解释器知道其存在，并不会立即执行
foo();	//这是语句，（Statement），解释器遇到它会执行

IIFE调用方式：
(function foo(){}());
(function foo(){})();
!function foo() {}();
+function foo() {}();
-function foo() {}();
~function foo() {}();

在需要表达式的场景下，就不需要用括号了：
void function(){}();
var foo = function(){}(); 
true && function () {}();
0, function () {}();

$(function(){})的用法：
$(document).ready(function(){
	console.log("ready");
});
等同于
$(function(){
	console.log("ready");
});

1.3 箭头函数

1.3.1 箭头函数基本用法

知识点：
箭头函数 ()=>{} 等价于 function(){}
当只有一个参数的时候，可以省略()，如 (res)=>{} 等价 res=>{}
当只有一个返回值时，可以省略{}，如 ()=>{return 0;} 等价 ()=>return 0;

1.3.2 调用位置和调用栈

此处引用自博主越努力越幸运_952c

知识点：
调用栈：调用栈主要是存放返回地址
调用位置：当前函数在代码中被调用的位置

function baz(){
	//当前调用栈是baz
	//当前调用位置是全局作用域
	bar();	//<--bar的调用位置
}

function bar(){
	//当前调用栈是baz->bar
	//当前调用位置在baz中
	foo();	//<--foo的调用位置
}

function foo(){
	//当前调用栈是baz->bar->foo
	//当前调用位置是在bar中
}

baz();	//<--baz的调用位置

1.3.3 ES5和ES6的this指向（箭头函数）

此处引用自博主蔡香满屋

ES5：
函数的调用位置决定了this的绑定
全局环境下，this始终指向全局对象（window）
普通函数内部的this分为两种情况：严格模式和非严格模式

非严格模式：this默认指向全局对象window
function f2(){
	return this;
}
f2()===window;	//true

严格模式：this为undefined
function f2(){
	"use strict";	//使用严格模式
	return this;
}
f2()===undefined;	//true

ES6:
箭头函数的定义位置决定了this的绑定
所以call()/apply()/bind()方法对于箭头函数来说只是传入参数，不会影响this值

var Animal=function(){
	this.name="Animal";	//下面那一行的this指向的时这外面的this
	this.speak=(name,words)=>{
		console.log(this.name+'is saying'+words+'.');
	}
}

var cat=new Animal();
cat.speak("cat","miao~");	//Animal is saying miao~

1.4 函数的参数扩展

知识点：
...可以用于展开/收集参数

[收集参数]
function show(a,b,...args){	//...args必须是最后一个形参
	alert(a);
	alert(b);
	alert(args);	//输出3,4,5,6
}
show(1,2,3,4,5,6);

[展开参数]
let arr1=[1,2,3];
let arr2=[4,5,6];
let arr=[...arr1,...arr2];	//等价于arr=[1,2,3,4,5,6]

1.5 解构赋值

知识点：
1. 左右两边结构必须一样
2. 右边的格式必须是合法的
3. 声明和赋值不能分开

let [a,b,c]=[1,2,3];	//把1,2,3分别赋值给a,b,c
let [{a,b,c},[d,e,f],g,e]=[{a:1,b:2,c:3},[1,2,3],"string",1];
let [json,arr,s,i]=[{a:1,b:2,c:3},[1,2,3],"string",1];	//注意与上式的区别

1.6 数组

1.6.1 map（映射）

知识点：
map映射可以实现两个数组间的对应映射，比如下面a[]，b[]两个数组间的元素一一对应：
a=[10,60,88,50,30];
b=['不及格','及格','及格','不及格','及格']

let score=[19,85,99,25,90];
let result=score.map(item=>item>=60?'及格':'不及格');
alert(score);	//分别输出19，85，99，25，90
alert(result);	//分别输出'不及格','及格','及格','不及格','及格'

1.6.2 reduce（汇总）

知识点：
reduce将数组[1,2,3]各个元素相加得到总数5


let arr=[12,69,180,8763];
let result=arr.reduce(function(tmp,item,index){	//tmp代表两数相加产生的中间数，item表示当前第二个加数，index为索引（第一次运算得到中间数后为2）
	return tmp+item;
});


let arr=[12,69,180,8763];
let result=arr.reduce(function(tmp,item,index){
	if(index!=arr.length-1){	//不是最后一次运算
		return tmp+item;
	}else{
		return (tmp+item)/arr.length;
	}
});
alert(result);

1.6.3 filter（过滤器）

知识点：
filter将返回true或false来实现过滤


let arr=[12,5,8,99,27,36,75];
let result=arr.filter(item=>item%3==0);
alert(result);

1.6.4 forEach（循环迭代）

知识点：
forEach迭代输出数组的元素

let arr=[12,5,8,9];
arr.forEach((item,index)=>{	//index可加可不加
	alert(index,": ",item);
});

1.6.5 map和forEach的异同点

相同点：
都是遍历数组的每一项
执行匿名函数时都支持传入三个参数：item,index,arr	//item为当前项，index为索引，arr为原数组

不同点：
map会分配内存空间存储新数组并返回，forEach不会返回
forEach对数据的操作会改变原数组，map不会改变原数组，而是会返回一个新数组

1.7 字符串

1.7.1 startsWith和endsWith

知识点：
startsWith和endsWith通过判断字符串开头或结尾是否含有特定字符串来返回true和false

1.7.2 字符串模板：` 搭配 ${} 连接字符串

知识点：
可以直接把东西塞到字符串里面	$(东西)
可以折行书写代码

let title='标题';
let content='内容';

旧的写法：
let str='
\	//折行需要加'\'
	
'+title+'
\
	
'+content+'
\
';

新的写法：
let str=`
	//使用反引号包裹
	
$(title)
	//不需要加'+'连接符
	
$(content)
`;

1.8 面向对象

1.8.1 老版本JS

缺点：
面向对象概念模糊，类和函数的不分家
方法需要在外面用prototype定义


function User(name,pass){
	this.name=name;
	this.pass=pass;
}

User.prototype.showName=function(){
	alert(this.name);
}

User.prototype.showPass=function(){
	alert(this.pass);
}

var u1=new User('zhang','123');

u1.showName();
u1.showPass();

//---------------继承User----------------

function VipUser(name,pass,level){
	User.call(this,name,pass);	//call实现继承
	this.level=level;
}

VipUser.prototype=new User();
VipUser.prototype.constructor=VipUser;	//个人猜测这里是加入User后，重新构造VipUser

VipUser.prototype.showLevel=function(){
	alert(this.level);
}

var v1=new VipUser('zhang','123',3);

v1.showName();
v1.showPass();
v1.showLevel();

1.8.2 ES6

优点：
强化面向对象概念，区分函数和类
class关键字、构造器和类分开了
class里面直接加方法


class User{
	constructor(name,pass){	//构造器
		this.name=name;
		this.pass=pass;
	}

	showName(){	//方法
		alert(this.name);
	}

	showPass(){
		alert(this.pass);
	}
}

var u1=new User('zhang','123');

u1.showName();
u1.showPass();

//---------------继承User----------------

class VipUser extends User{
	constructor(name,pass,level){
		super(name,pass);	//super关键字继承父类
		this.level=level;
	}

	showLevel(){	//直接在class里面加方法
		alert(this.level);
	}
}

var v1=new VipUser('zhang','123',3);

v1.showName();
v1.showPass();
v1.showLevel();

1.8.3 面向对象应用–React

React特点:
1. 强调组件化，一个组件即一个class
2. 强依赖与JSX（JSX==babel==browser.js）

（这里先简单介绍一下react框架，后续将会详细学习）

1.9 JSON

1.9.1 JSON和字符串之间的互换

知识点：
1. JSON转换成字符串：JSON.stringfy()
2. 字符串转换成JSON：JSON.parse()
3. 把字符串作为URI组件进行编码：encodeURIComponent()
4. JSON的标准写法：
 · 所有key和字符串类型的value都要用双引号包裹
 · 最外层用单引号包裹

eg：let str='{"a":12,"b":"hello"}';

1.9.2 JSON简写

知识点：
1. 名字一样可以简写（key和value一样）
2. 方法可以简写

eg：

let a=12;
let b=5;
let json={a:a,b:b};	//可简写为：let json={a,b};


let json={
	a:12,
	show:function(){	//可简写为：show(){alert(this.a);}
		alert(this.a);
	}
};

1.10 Promise

1.10.1 Promise简介与基本用法

知识点：
Promise的出现解决了ajax异步加载时代码复杂的问题，在较新版本的ajax中有封装了Promise



let p = new Promise(function(resolve,reject){
	$.ajax({
		url:'hello.txt',
		dataType:'json',
		success(arr){
			resolve(arr);	//执行成功调用resolve()返回arr
		},
		error(err){
			reject(err);	//执行失败调用reject()返回err
		}
	})
});

p.then(function(arr){	//接受resolve()返回的参数
	console.log('成功',arr);
},function(err){	//接受reject()返回的参数
	console.log('失败',err);
});

1.10.2 Promise.all()

知识点：
当有多个Promise一起异步执行时，使用Promise.all()来返回多个Promise调用结果

let p1 = new Promise(functioin(resolve,reject){...});

let p2 = new Promise(functioin(resolve,reject){...});

Promise.all([p1,p2]).then(arr=>{	//此处也可简写成箭头函数
	let [res1,res2]=arr;	//解构赋值
	console.log(res1,res2);
},err=>{
	let [err1,err2]=err;
	console.log(err1,err2);
});

1.10.3 Promise.race()

知识点：
与Promise.all()用法相似，原则是谁先来先返回谁，即哪个Promise返回的值快就返回谁，可以用于超时处理

Promise.race([p1,p2]).then(results=>{},err=>{});

1.11 generator

1.11.1 generator简介

知识点：
generator（生成器），执行过程中可以暂停去执行其他函数
generator跟promise相似，用于异步回调处理，异步的请求可以用类似同步的逻辑来写

普通函数异步请求：
function 函数(){
	代码...

	ajax(xxx,function(){
		代码...
	});
}

generator异步请求：
function *函数(){	//*不能省略
	代码...

	yield ajax(xxx);

	代码...
}

1.11.2 yield介绍

知识点：
yield把函数分成了几部分，通过调用next()来分别执行
yield可以传参和返回

传参：
function *show(){
	alert('a');

	let a=yield;	//执行第二个next的时候把5赋值给a

	alert('b');
	alert(a);	//输出5
}

let gen=show();
gen.next(12);	//执行yield的上半部分
gen.next(5);	//执行yield的下半部分

返回：
function *show(){
	alert('a');

	yield 12;	//返回12给第一个next

	alert('b');

	return 55;	//返回55给第二个next
}

let gen=show();

let res1=gen.next();
console.log(res1);	//输出{value:12,done:false}

let res2=gen.next();
console.log(res2);	//输出{value:55,done:true}

1.11.3 generator实例

知识点：
在使用前需要安装runner，并引入jquery.js（用于ajax）和runner.js

runner(function *(){

	//使用同步的写法实现异步的请求

	let data1=yield $.ajax({url:'data/1.txt',dataType:'json'});
	let data2=yield $.ajax({url:'data/2.txt',dataType:'json'});
	let data3=yield $.ajax({url:'data/3.txt',dataType:'json'});

	console.log(data1.data2.data3);
});

1.12 回调函数的对比

知识点：
1. 在同时请求多条数据的时候，promise和generator方法效果差不多


//第一层
$.ajax({
	url:xxx,
	dataType:'json',
	success(data1){
		//第二层
		$.ajax({
			url:xxx,
			dataType:'json',
			success(data2){
				//第三层
				$.ajax({
					url:xxx,
					dataType:'json',
					success(data3){
						//OK
					},error(){
						alert('失败');
					}
				});
			},error(){
				alert('失败');
			}
		});
	},error(){
		alert('失败');
	}
});


Promise.all([
	$.ajax({url:xxx,dataType:'json'}),
	$.ajax({url:xxx,dataType:'json'}),
	$.ajax({url:xxx,dataType:'json'}),
]).then(res=>{
	//OK
},err=>{
	alert('失败');
});


runner(function *(){
	let data1=yield $.ajax({url:xxx,dataType:'json'});
	let data2=yield $.ajax({url:xxx,dataType:'json'});
	let data3=yield $.ajax({url:xxx,dataType:'json'});

	//OK
});

2. 在请求完数据后，通过数据的值来判断下一条请求时，generator>传统回调>promise


$.ajax({url:'getUserData',dataType:'json',success(userData){
	if(userData.type=='vip'){
		$.ajax({url:'getVipData',dataType:'json',success(items){
			//OK
		},error(err){
			alert('失败');
		}})
	}
},error(err){
	alert('失败');
}})


Promise.all([
	$.ajax({url:'getUserData',dataType:'json'})
]).then(res=>{
	let userData=res[0];

	if(userData.type=='vip'){
		Promise.all([
			$.ajax({url:'getVipData',dataType:'json'})
		]).then(res=>{
			//OK
		},err=>{
			alert('失败');
		});
	}
},err=>{
	alert('失败');
});


runner(function *(){
	let userData=yield $.ajax({url:'getUserData',dataType:'json'});

	if(userData.type=="vip"){
		let items=yield $.ajax({url:'getVipData',dataType:'json'});
		//OK
	}
});