ES6的新特性概览

var array = [1,2,3];
// 传统写法写法
array.forEach(function(v) {
console.log(v);
});
// ES6写法
array.forEach(v => console.log(v)); 

// 类的定义
class Animal {
// ES6中新型构造器
constructor(name) {
this.name = name;
}
// 实例方法
sayName() {
console.log('My name is ' + this.name);
}
}
// 类的继承
class Programmer extends Animal {
constructor(name) {
// 直接调用父类构造器进行初始化
super(name);
}
program() {
console.log("I'm coding...");
}
}
// 测试我们的类
var animal = new Animal('dummy'),
wayou = new Programmer('wayou');
animal.sayName(); // 输出 'My name is dummy'
wayou.sayName(); // 输出 'My name is wayou'
wayou.program(); // 输出 'I'm coding...' 

// 通过对象字面量创建对象
var human = { 
breathe() {
console.log('breathing...');
}
};
var worker = { 
__proto__: human, // 设置此对象的原型为human, 相当于继承human
company: 'freelancer',
work() {
console.log('working...');
}
};
human.breathe(); // 输出 'breathing...'
// 调用继承来的breathe方法
worker.breathe(); // 输出 'breathing...' 

// 产生一个随机数
var num = Math.random();
// 将这个数字输出到console 
console.log(`your num is ${num}`);

function getVal() {
return[1,2];
}
var [x,y] = getVal(), // 函数返回值的解构
console.log('x:' + x + ', y:' + y); // 输出：x:1, y:2
[name,,age] = ['wayou','male','secrect']; // 数组解构
console.log('name:' + name + ', age:' + age); //输出：name:wayou, age:secrect 

function sayHello(name) {
// 传统的指定默认参数的方式
var name = name || 'dude';
console.log('Hello ' + name);
} 
sayHello(); // 输出：Hello dude
sayHello('Wayou'); // 输出：Hello Wayou
// 运用ES6的默认参数
function sayHello2(name = 'dude') {
console.log(`Hello${name}`);
}
sayHello2(); // 输出：Hello dude
sayHello2('Wayou'); // 输出：Hello Wayou 

// 将所有参数相加的函数
function add(...x) {
return x.reduce((m,n) => m+n);
}
// 传递任意个数的参数
console.log(add(1,2,3)); // 输出：6
console.log(add(1,2,3,4,5)); // 输出：15 

var people = ['Wayou','John','Sherlock'];
// sayHello函数本来接收三个单独的参数人一，人二和人三
function sayHello(people1, people2, people3) {
console.log(`Hello${people1}, ${people2}, ${people3}`);
}
// 但是我们将一个数组以拓展参数的形式传递，它能很好地映射到每个单独的参数
sayHello(...people); // 输出：Hello Wayou,John,Sherlock
// 而在以前，如果需要传递数组当参数，我们需要使用函数的apply方法
sayHello.apply(null, people); // 输出：Hello Wayou,John,Sherlock 

for (let i=0; i<2; i++) {
console.log(i); // 输出: 0,1
}
console.log(i); // 输出：undefined,严格模式下会报错 

var someArray = ["a","b","c"];
for (v of someArray) {
console.log(v); // 输出 a,b,c
} 

// point.js
module "point" {
export class Point {
constructor(x,y) {
public x=x;
public y=y;
}
}
}
// myapp.js
// 声明引用的模块 
module point from "/point.js";
// 这里可以看出，尽管声明了引用的模块，还是可以通过指定需要的部分进行导入
import Point from "point";
var origin = new Point(0,0);
console.log(origin); 
Map，Set 和 WeakMap，WeakSet

// Sets 
var s = new Set();
s.add("hello").add("goodbye");
s.size === 2;
s.has("hello") === true;
// Maps
var m = new Map();
m.set("hello", 42);
m.set(s, 34);
m.get(s) == 34; 
有时候我们会把对象作为一个对象的键用来存放属性值，普通集合类型比如简单对象会阻止垃圾回收器对这些作为属性键存在的对象的回收，有造成内存泄漏的危险。而WeakMap,WeakSet则更加安全些，这些作为属性键的对象如果没有别的变量在引用它们，则会被回收释放掉，具体还看下面的例子：
// Weak Maps
var wm = new WeakMap();
wm.set(s, {extra: 42});
wm.size === undefined // 对象释放了
// Weak Sets
var ws = new WeakSet();
ws.add({data: 42}); // 因为添加到ws的这个临时对象没有其他变量引用它，所以ws不会保存它的值，也就是说这次添加其实没有意思 
Proxies
Proxy可以监听对象身上发生了什么事情，并在这些事情发生后执行一些相应的操作。一下子让我们对一个对象有了很强的追踪能力，同时在数据绑定方面也很有用处。
// 定义被侦听的目标对象
var engineer = {name: 'Joe Sixpack', salary: 50};
// 定义处理程序
var interceptor = {set: function(receiver, property, value) {
console.log(property, 'is changed to', value);
receiver[property] = value;
}
};
// 创建代理以进行侦听
engineer = Proxy(engineer, interceptor);
//做一些改动来触发代理
engineer.salary = 60; // 控制台输出：salary is changed to 60 

(function() {
// 创建 symbol
var key = Symbol("key");
function MyClass(privateData) {
this[key] = privateData;
}
MyClass.prototype = {
doStuff: function() {
...this[key]...
}
};
})();
var c = new MyClass("hello");
c["key"] === undefined //无法访问该属性，因为是私有的 
Math，Number，String，Object 的新API
对Math,Number,String还有Object等添加了许多新的API。
// Number
// 不同的两个Number之间的最小的差
Number.EPSILON
// 判断是否是整数
Number.isInteger(Infinity) // false
// 判断是否为非数字
Number.isNaN("NaN") // false
// Math
Math.acosh(3) // 1.762747174039086
Math.hypot(3,4) // 5
Math.imul(Math.pow(2,32)-1, Math.pow(2,32)-2) // 2
// String
"abcde".contains("cd") // true
"abc".repeat(3) // "abcabcabc"
// Array
// 将一个类数组对象或可迭代对象转换成真实的数组
Array.from(document.querySelectorAll('*'))
// 将它的任意类型的多个参数放在一个数组里并返回
Array.of(1,2,3)
// 将一个数组中指定区间的所有元素的值, 都替换成或者说填充成为某个固定的值
[0,0,0].fill(7,1) // [0,7,7]
// 用来查找数组中某指定元素的索引, 如果找不到指定的元素, 则返回 -1
[1,2,3].findIndex(x => x == 2) // 1
// 返回一个 Array Iterator 对象，该对象包含数组中每一个索引的键值对
["a","b","c"].entries() // iterator [0, "a"], [1,"b"], [2,"c"]
// 返回一个数组索引的迭代器
["a","b","c"].keys() // iterator 0, 1, 2
// 返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值
["a","b","c"].values() // iterator "a", "b", "c"
// Object
Object.assign(Point, {origin: new Point(0,0)}) 
Promises
Promises是处理异步操作的一种模式，之前在很多三方库中有实现，比如jQuery的deferred 对象。当你发起一个异步请求，并绑定了.when(), .done()等事件处理程序时，其实就是在应用promise模式。
// 创建 promise
var promise = new Promise(function(resolve,reject) {
// 进行一些异步或耗时操作
if(/*如果成功 */) {
resolve("Stuff worked!");
} else {
reject(Error("It broke"));
}
});
// 绑定处理程序
promise.then(function(result) {
// promise成功的话会执行这里
console.log(result); // "Stuff worked!"
}, function(err) {
// promise失败会执行这里
console.log(err); // Error: "It broke"
});