understandinges6.txt

-----------------------------------------------------------第一章 块级作用域---------------------------------------------------------------------
1. let
	没有变量提升，必须先声明后使用
	在同一作用域内不能重复定义同名变量
	
2. const
	恒定的是指针，而不是内容。所以如果是对象，是可以修改const对象的属性的
	同样是必须先定义才能使用
	
3. 时间死区：TDZ (temporal dead zone)
	定义之前就使用变量的话，定义的语句属于 TDZ
	* 使用时报错，定义语句并不会执行
	
4. 顶级作用域：
	let和const定义在顶级作用域时并不会为window添加或覆盖对象
	
	
-----------------------------------------------------------第二章 字符串和正则表达式---------------------------------------------------------------------
1. String.codePointAt

2. String.fromCodePoint

3. normalize

4. includes、startsWith、endsWith
	* 这3个都还能接收第二个参数，用来标识起始匹配位置
	
5. repeat
	x.repeat(3);			// "xxx"
	
6. 模板字符串：`text`
	`t
	ext ${name}`
	* 可以穿插变量
	* 可以直接输出换行
	并且可以自己定义tag:
		function tag(literals, ...substitutions) {
			// return a string
			// literals的长度始终比substitutions的长度大1
		}
	let message = tag`start ${param1} end ${param2}.`;
		
7. RegExp构造函数允许同时传RegExp和flags
	var re1 = /ab/i,
    re2 = new RegExp(re1, "g");		
	
8. RegExp的y标识：
	如果字符串开头不匹配的话，就不向后匹配。这怎么像^的功能。。。
	* var pattern = /hello\d/y;
	* pttern.stricky				// ES5报错，ES6OK
	
9. RegExp的u标识：
	* 正确匹配2位表示一个字符的UTF-16，即超出常用范围：2^16^的字符
		
10.	RegExp的flags属性
	* 与 source 属性对应，flags 取出正则表达式的标志

	
-----------------------------------------------------------第三章 函数---------------------------------------------------------------------
1. 函数可以默认值，默认值不会被计算进arguments.length，对参数的修改不会再影响arguments
	* 默认参数的值可以从一个函数执行中产生：function func(first, second=getValue());
	* ES5 中严格模式下，对参数的修改才不会影响argumetns
	
2. 仅允许引用前方的参数
	* function add(first = second, second)				// 错误

3. 剩余参数
	function pick(first, ...ten)						// ten 是剩余参数的数组
	* 剩余参数只能有一个，并且必须放在最后
	
	

4.
	Object.is(5,5)
		这两个的判定值都会与 === 相反
		+0 === -0	// true
		NaN === NaN	// false
	Object.assign()
	
5. 结构
	{a, b} = obj;
	{a=1, b: b2, c:c2=1} = obj;
	{a: {b}} = obj	// 嵌套，类似obj.a.b
	
	[a,b,c] = arr;
	[,,c] = arr;
	[a,b] = [b,a]	// 交换值
	[a=1,b] = arr;
	[a, [b]] = arr;	// 嵌套，类似arr[1][0]
	[a, ...b] = arr;
	
	[...newArr] = arr;	// 克隆数组，等同于arr.concat()
	
	function(a,b,{c=1,d,e,f} = {})	// 参数结构
	
6.
	var uid = Symbol("uid");	// new 会报错
	Symbol.for("uid");		// 创建全局Symbol，如果已有则返回现有Symbol
	Symbol.keyFor(uid);			// "uid"
	Object.getOwnPropertySymbols(obj);
	Symbol.hasInstance
	Symbol.isConcatSpreadable
	Symbol.iterator
	Symbol.match
	Symbol.replace
	Symbol.search
	species
	split
	toPrimitive
	toStringTag
	unscopables
	
7.	
	let set = new Set([1,2,3,3]);
	set.add(5)
	set.has(5)
	set.delete(5)
	set.clear();
	set.forEach
	[...set]	// 利用set清除数组重复项
	
	let set = WeakSet()	// 弱引用，原set会保留引用
						// 只能添加引用
						// 没有for of
						// 没有forEach方法
						// 没有size属性
						// 没有迭代器
		key = {}
		set.add(key);
		
	let map = new Map();	// 与object的key不同，这里键由Object.is来决定
	map.set
	map.get
	map.has
	map.delete
	map.clear
	
	let map = new WeakMap();	// 弱引用，弱引用的是key，key不存在时，自动删除该key及value
								// 只有has和delete方法，clear都不存在，因为clear需要对键进行枚举
								
8.
	// * 可以处于任何位置
	function *createIterator(){
		yield 1;
		yield 2;
		yield 3;
	}
	也可以：var createIterator = function *(){
		yield 1;
		yield 2;
		yield 3;
	}
	{
		createIterator: function *(){}
	}
	{
		*createIterator(){
		
		}
	}
	
	yield 有点类似return，只能在函数内部使用
	for(let num of values){			// for of, 遍历可迭代类型（包含Symbol.iterator属性的对象，数组，set, map, string）
		
	}
	
9.
	get和set在class中可以快捷定义：
	class test{
	
		get attrTest(){}
		set attrTest(value){}
	
	}
	类中定义迭代器，可以用以支持for of循环和扩展运算符
	extends 继承
		子类中定义了constructor则必须要调用supper函数
		不定义则默认等于super(...args)
		supper()必须放在第一行，因为它会初始化this，在supper之前访问this会报错
	static静态函数也会被继承
	派生自系统对象的方法将会返回派生类的实例
		class MyArray extends Array{}
		new MyArray(1,2,3,4).slice(1, 3)	// slice 返回的数据类型不是Array而是MyArray
	new.target 返回当前class	
	
10.
	Array.of	// 创建数组
	Array.from	// 创建数组
		// 支持类数组对象、迭代器
		// from中能加入map：Array.from(arg, value=>value+1);
	find
	findIndex
	fill(val, startIndex, endIndex)		// 覆盖值，不包含endIndex
	copyWithin(pastStartIndex, copyStartIndex, copyLength)	// 从自身拷贝数据，覆盖起始索引，拷贝开始索引，拷贝结尾索引
	ArrayBuffer
	DataView
	
11.
	Promise.then.reject.catch
	let promise = new Promise(function(resolve, reject){})
	promise.then.catch
	node中process拥有unhandledRejection和rejectionHandled来全局处理promise的reject, 参数前者为reason, promise, 后者只有promise
	浏览器是windows对象，参数是一个对象{type:'unhandledrejection'||'rejectionhandled', reason, promise}
	then的回调中return的数据会传递给下一个then
	catch之后会继续调用后续的then
	Promise.all([]).then(value=> // value为数组).catch(value=> // value为单个数据，每个reject都会触发一次)
	Promise.race([])	// 哪个先执行完就触发回调，不管是resolve, 还是reject
	await promise	// 返回resolve的值，失败会报错，需要使用try catch捕捉
	
12.
	Proxy
	target = {}
	new Proxy(target,{
		get(trapTarget, key, value, receiver){
			
		},
		set(trapTarget, key, receiver){
			
		},
		has(trapTarget, key){
			return false;	// "attr" in proxy, 会影响 in 操作符的返回值
		},
		deleteProperty(trapTarget, key){
			return false;
			return Reflect.deleteProperty(trapTarget, key);
		},
		getPrototypeOf(trapTarget){
		
		},
		setPrototypeOf(trapTarget, proto){
		
		},
		isExtensible(trapTarget){
			return Reflect.isExtensible(trapTarget);
		},
		preventExtensions(trapTarget){
			return Reflect.preventExtensions(trapTarget);
		},
		defineProperty(trapTarget, key, descriptor){
			return Reflect.defineProperty(trapTarget, key, descriptor);
		}
	})
	
	let {proxy, revoke} = Proxy.revocable(target, {})
	revoke();	// 解除代理
	
13.
	<script type="module" src="module.js" async></script>	// 引入模块js
	new Workder("module.js", {type: "module"})	// 引入模块worker
	
14.
	Number.isInterger
	Number.MAX_SAFE_INTEGER
	Number.MIN_SAFE_INTEGER
	Number.isSafeInteger
	
15.
	5 ** 2	// 求幂，等同于5 * 5
	2 * 5 ** 2	// 优先级比其他二元运算符高
	-5 ** 2	// 抛错，负号必须用括号包起来，明确负号作用的范围：(-5) ** 2 或者 -(5 ** 2)
	[1,2,3].includes(1)	// true, 终于有一个类似contains的函数了
		// includes 使用 === 来判断，但是 NaN会被判定为NaN(尽管 NaN === NaN 的计算结果为false)
		// +0 和 -0会被判定为相等，但Object.js()会判定为不相等
	function(first, second="123"){
		"use strict"	// 会报错，只有参数列表是简单的，并没有解构和默认值的情况下，函数主体才能有 "use strict" 出现
	}