第一部分:扩展
1.1、let和const
const声明一个只读的常量。一旦声明,常量的值就不能改变
let不允许在相同作用域内,重复声明同一个变量
for循环的计数器,就很合适使用let命令
- 不存在变量提升
- 会创建块级作用域
1.2、变量的解构赋值
数组解构赋值应用场景
1 2 3 4 5 6
| function fn() { return [1,2,3,4,5] }
[a,,,b] = fn();
|
对象解构赋值场景
1 2 3 4 5 6 7 8 9 10 11
| let metaData = { title: "hah", test: [ { title:"poetries", desc: "test_data" } ] }
let {title:esTitle,test:[{title:cnTitle,desc:cnDesc}]} = metaData;
|
1.3、字符串扩展
- 模板字符串是增强版的字符串,用反引号(`)标识。它可以当作普通字符串使用,也可以用来定义多行字符串.
1 2 3 4 5 6 7 8 9 10 11 12 13
| `In javascript '\n' is a line-feed.`
`In javascript this is not legal.`
console.log(`string text line 1 string text line 2`);
let name = "Bob", time = "today"; `Hello ${name}, how are you ${time}?`
|
1.4、数值扩展
Number.isFinite(), Number.isNaN()
Number.isFinite()用来检查一个数值是否为有限的
1 2 3 4 5 6 7 8
| Number.isFinite(15); // true Number.isFinite(0.8); // true Number.isFinite(NaN); // false Number.isFinite(Infinity); // false Number.isFinite(-Infinity); // false Number.isFinite('foo'); // false Number.isFinite('15'); // false Number.isFinite(true); // false
|
Number.isNaN()用来检查一个值是否为NaN
1 2 3 4 5 6 7
| Number.isNaN(NaN) // true Number.isNaN(15) // false Number.isNaN('15') // false Number.isNaN(true) // false Number.isNaN(9/NaN) // true Number.isNaN('true'/0) // true Number.isNaN('true'/'true') // true
|
Number.parseInt(), Number.parseFloat()
ES6将全局方法parseInt()和parseFloat(),移植到Number对象上面,行为完全保持不变
1.5、数组扩展
扩展运算符
- 扩展运算符是三个点(
...)。它好比 rest 参数的逆运算,将一个数组转为用逗号分隔的参数序列
1 2 3 4 5 6 7 8
| console.log(...[1, 2, 3]) // 1 2 3
console.log(1, ...[2, 3, 4], 5) // 1 2 3 4 5
[...document.querySelectorAll('div')] // [
|
1 2 3 4 5 6 7 8
| Math.max.apply(null, [14, 3, 77])
Math.max(...[14, 3, 77])
Math.max(14, 3, 77);
|
Array.from()
Array.from方法用于将两类对象转为真正的数组:类似数组的对象(array-like object)和可遍历(iterable)的对象(包括ES6新增的数据结构Set和Map)
1 2 3 4 5 6 7 8 9 10 11 12
| let arrayLike = { '0': 'a', '1': 'b', '2': 'c', length: 3 };
var arr1 = [].slice.call(arrayLike);
let arr2 = Array.from(arrayLike);
|
- 实际应用中,常见的类似数组的对象是
dom操作返回的nodeList集合,以及函数内部的arguments对象。Array.from都可以将它们转为真正的数组。
querySelectorAll方法返回的是一个类似数组的对象,可以将这个对象转为真正的数组,再使用forEach方法
1 2 3 4 5 6 7 8 9 10 11
| let ps = document.querySelectorAll('p'); Array.from(ps).forEach(function (p) { console.log(p); });
function foo() { var args = Array.from(arguments); }
|
Array.of()
Array.of方法用于将一组值,转换为数组
Array.of基本上可以用来替代Array()或new Array()
1 2 3
| Array.of(3, 11, 8) Array.of(3) Array.of(3).length
|
数组实例的 find() 和 findIndex()
数组实例的find方法,用于找出第一个符合条件的数组成员。它的参数是一个回调函数,所有数组成员依次执行该回调函数,直到找出第一个返回值为true的成员,然后返回该成员。如果没有符合条件的成员,则返回undefined
1 2
| [1, 4, -5, 10].find((n) => n < 0)
|
数组实例的findIndex方法的用法与find方法非常类似,返回第一个符合条件的数组成员的位置,如果所有成员都不符合条件,则返回-1
1 2 3
| [1, 5, 10, 15].findIndex(function(value, index, arr) { return value > 9; })
|
数组实例的fill()
fill方法使用给定值,填充一个数组
fill方法用于空数组的初始化非常方便。数组中已有的元素,会被全部抹去
fill方法还可以接受第二个和第三个参数,用于指定填充的起始位置和结束位置
1 2 3 4 5 6 7 8 9
| ['a', 'b', 'c'].fill(7)
new Array(3).fill(7)
['a', 'b', 'c'].fill(7, 1, 2)
|
数组实例的 entries(),keys() 和 values()
ES6 提供三个新的方法——entries(),keys()和values()——用于遍历数组
keys()是对键名的遍历、values()是对键值的遍历,entries()是对键值对的遍历
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| for (let index of ['a', 'b'].keys()) { console.log(index); }
for (let elem of ['a', 'b'].values()) { console.log(elem); }
for (let [index, elem] of ['a', 'b'].entries()) { console.log(index, elem); }
|
数组实例的 includes()
Array.prototype.includes方法返回一个布尔值,表示某个数组是否包含给定的值,与字符串的includes方法类似
1 2 3
| [1, 2, 3].includes(2) [1, 2, 3].includes(4) [1, 2, NaN].includes(NaN)
|
1.6、对象扩展
属性的简洁表示法
1 2 3 4 5 6 7 8 9
| function f(x, y) { return {x, y}; }
function f(x, y) { return {x: x, y: y}; }
|
1 2 3 4 5 6 7 8 9 10 11 12 13
| const o = { method() { return "Hello!"; } };
const o = { method: function() { return "Hello!"; } };
|
1 2 3 4 5 6 7
| module.exports = { getItem, setItem, clear };
module.exports = { getItem: getItem, setItem: setItem, clear: clear };
|
属性名表达式
1 2 3 4 5
| obj.foo = true;
obj['a' + 'bc'] = 123;
|
ES6允许字面量定义对象时,用方法二(表达式)作为对象的属性名,即把表达式放在方括号内
1 2 3 4 5 6
| let propKey = 'foo';
let obj = { [propKey]: true, ['a' + 'bc']: 123 };
|
1 2 3 4 5 6 7
| let obj = { ['h' + 'ello']() { return 'hi'; } };
obj.hello()
|
Object.is()
Object.is 它用来比较两个值是否严格相等,与严格比较运算符(===)的行为基本一致
1 2 3 4
| Object.is('foo', 'foo')
Object.is({}, {})
|
- 不同之处只有两个:一是
+0不等于-0,二是NaN等于自身
1 2 3 4 5
| +0 === -0 NaN === NaN
Object.is(+0, -0) Object.is(NaN, NaN)
|
Object.assign()
Object.assign方法用于对象的合并,将源对象的所有可枚举属性,复制到目标对象
1 2 3 4 5 6 7
| const target = { a: 1 };
const source1 = { b: 2 }; const source2 = { c: 3 };
Object.assign(target, source1, source2); target
|
属性的遍历
ES6 一共有5种方法可以遍历对象的属性
1.7、函数扩展
函数参数的默认值
ES6 允许为函数的参数设置默认值,即直接写在参数定义的后面
1 2 3 4 5 6 7
| function log(x, y = 'World') { console.log(x, y); }
log('Hello') log('Hello', 'China') log('Hello', '')
|
与解构赋值默认值结合使用
1 2 3 4 5 6 7
| function foo({x, y = 5}) { console.log(x, y); }
foo({}) foo({x: 1}) foo({x: 1, y: 2})
|
rest 参数
ES6 引入 rest 参数(形式为...变量名),用于获取函数的多余参数,这样就不需要使用arguments对象了。rest 参数搭配的变量是一个数组,该变量将多余的参数放入数组中
1 2 3 4 5 6 7 8 9 10 11
| function add(...values) { let sum = 0;
for (var val of values) { sum += val; }
return sum; }
add(2, 5, 3)
|
箭头函数
1 2 3 4 5 6
| var f = v => v
var f = function(v) { return v; };
|
1 2 3 4 5 6 7 8 9
| var f = () => 5;
var f = function () { return 5 };
var sum = (num1, num2) => num1 + num2;
var sum = function(num1, num2) { return num1 + num2; };
|
绑定 this
- 箭头函数可以绑定this对象,大大减少了显式绑定this对象的写法(
call、apply、bind)
第二部分:新增
2.1、Symbol
ES6引入了一种新的原始数据类型Symbol,表示独一无二的值
- 凡是属性名属于
Symbol 类型,就都是独一无二的,可以保证不会与其他属性名产生冲突
2.2、Proxy
对要保护的对象套一层,不被外界所访问。Proxy 可以理解成,在目标对象之前架设一层“拦截”,外界对该对象的访问,都必须先通过这层拦截,因此提供了一种机制,可以对外界的访问进行过滤和改写
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56
| let obj={ time:'2017-03-11', name:'net', _r:123 };
let monitor=new Proxy(obj,{ get(target,key){ return target[key].replace('2017','2018') }, set(target,key,value){ if(key==='name'){ return target[key]=value; }else{ return target[key]; } }, has(target,key){ if(key==='name'){ return target[key] }else{ return false; } }, deleteProperty(target,key){ if(key.indexOf('_')>-1){ delete target[key]; return true; }else{ return target[key] } }, ownKeys(target){ return Object.keys(target).filter(item=>item!='time') } });
console.log('get',monitor.time);
monitor.time='2018'; monitor.name='poetries'; console.log('set',monitor.time,monitor);
console.log('has','name' in monitor,'time' in monitor);
console.log('ownKeys',Object.keys(monitor));
|
2.3、Reflect
Reflect对象与Proxy对象一样,也是ES6 为了操作对象而提供的新 api
1 2 3 4 5 6 7 8 9 10
| let obj={ time:'2017-03-11', name:'net', _r:123 };
console.log('Reflect get',Reflect.get(obj,'time')); Reflect.set(obj,'name','poetries'); console.log(obj); console.log('has',Reflect.has(obj,'name'));
|
2.4、Set和Map
Set
Set和Map类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在Set中,没有重复的key
- 要创建一个
Set,需要提供一个Array作为输入,或者直接创建一个空Set
1 2
| var s1 = new Set(); // 空Set var s2 = new Set([1, 2, 3]); // 含1, 2, 3
|
1 2
| var s = new Set([1, 2, 3, 3, '3']); s; // Set {1, 2, 3, "3"}
|
- 通过
add(key)方法可以添加元素到Set中,可以重复添加,但不会有效果
1 2 3 4 5 6
| >>> s.add(4) >>> s {1, 2, 3, 4} >>> s.add(4) >>> s {1, 2, 3, 4}
|
1 2 3 4
| var s = new Set([1, 2, 3]); s; // Set {1, 2, 3} s.delete(3); s; // Set {1, 2}
|
Map
Map是一组键值对的结构,具有极快的查找速度
- 用
Map实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用javascript写一个Map如下:
1 2
| var m = new Map([['Michael', 95], ['Bob', 75], ['Tracy', 85]]); m.get('Michael'); // 95
|
- 初始化
Map需要一个二维数组,或者直接初始化一个空Map。Map具有以下方法
1 2 3 4 5 6 7
| var m = new Map(); // 空Map m.set('Adam', 67); // 添加新的key-value m.set('Bob', 59); m.has('Adam'); // 是否存在key 'Adam': true m.get('Adam'); // 67 m.delete('Adam'); // 删除key 'Adam' m.get('Adam'); // undefined
|
- 由于一个
key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉
1 2 3 4
| var m = new Map(); m.set('Adam', 67); m.set('Adam', 88); m.get('Adam'); // 88
|
2.5、Promise
Promise 是异步编程的一种解决方案,比传统的解决方案——回调函数和事件——更合理和更强大
Promise对象代表一个异步操作,有三种状态
pending(进行中)
fulfilled(已成功)
rejected(已失败)
基本用法
1 2 3 4 5 6 7 8 9
| var promise = new Promise(function(resolve, reject) {
if (){ resolve(value); } else { reject(error); } });
|
Promise实例生成以后,可以用then方法分别指定resolved状态和rejected状态的回调函数
1 2 3 4 5
| promise.then(function(value) { }, function(error) { });
|
2.6、Generator
generator(生成器)是ES6标准引入的新的数据类型。一个generator看上去像一个函数,但可以返回多次
2.7、Class
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
| { class Parent{ constructor(name='poetries'){ this.name=name; } } let v_parent=new Parent('v'); console.log('构造函数和实例',v_parent); }
{ class Parent{ constructor(name='poetries'){ this.name=name; } }
class Child extends Parent{
}
console.log('继承',new Child()); }
{ class Parent{ constructor(name='poetries'){ this.name=name; } }
class Child extends Parent{ constructor(name='child'){ super(name); this.type='child'; } }
console.log('继承传递参数',new Child('hello')); }
{ class Parent{ constructor(name='poetries'){ this.name=name; }
get longName(){ return 'mk'+this.name }
set longName(value){ this.name=value; } }
let v=new Parent(); console.log('getter',v.longName); v.longName='hello'; console.log('setter',v.longName); }
{ class Parent{ constructor(name='poetries'){ this.name=name; }
static tell(){ console.log('tell'); } }
Parent.tell();
}
{ class Parent{ constructor(name='poetries'){ this.name=name; }
static tell(){ console.log('tell'); } }
Parent.type='test';
console.log('静态属性',Parent.type);
}
|
2.8、Module
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| let A=123; let test=function(){ console.log('test'); } class Hello{ test(){ console.log('class'); } }
export default { A, test, Hello }
|