// for loop
for (var index = 0; index < myArray.length; index++) {
  console.log(myArray[index]); 
}
//or ES5 forEach
 myArray.forEach(function (value) {
   console.log(value); 
 });
//注意，不要使用 for(var index in myArray) {} 形式。for-in 循环用来遍历对象属性。

for (var value of myArray) { 
  console.log(value); 
}

(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
         // 等价于:  => { return expression; }
// 如果只有一个参数，圆括号是可选的:
(singleParam) => { statements }
singleParam => { statements }
// 无参数的函数需要使用圆括号:
() => { statements }

//ES5
function () {  return console.log(_this.string);  }
//ES6
() => console.log(this.string)

// 返回对象字面量时应当用圆括号将其包起来:
params => ({foo: bar})
// 支持 多重参数（Rest parameters） 和 默认参数:
(param1, param2, ...rest) => { statements }
(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }
// 参数列表中的解构赋值也是被支持的
var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f();  // 6

// ES5
var selected = allJobs.filter(function (job) {
    return job.isSelected();
});
// ES6
var selected = allJobs.filter(job => job.isSelected());

// ES5
var total = values.reduce(function (a, b) {
     return a + b;
}, 0);
// ES6
var total = values.reduce((a, b) => a + b, 0);

// ES5
$("#confetti-btn").click(function (event) {
    playTrumpet();
    fireConfettiCannon();
});
// ES6
$("#confetti-btn").click(event => {
    playTrumpet();
    fireConfettiCannon();
});

// 为每一个puppy创建一个新的空对象
var chewToys = puppies.map(puppy => {});   // 这样写会报Bug！
var chewToys = puppies.map(puppy => ({})); // puppy => ({}) 用小括号包裹空对象就可以了。

// ES6
{
   ...
   addAll: function addAll(pieces) {
        _.each(pieces, piece => this.add(piece));
   },
   ...
}

// ES6的方法语法
{
    ...
    addAll(pieces) {
        _.each(pieces, piece => this.add(piece));
    },
    ...
}

var obj = {
     // 现在不再使用function关键字给对象添加方法
     // 而是直接使用属性名作为函数名称。
     method(args) { ... },
     // 只需在标准函数的基础上添加一个“*”，就可以声明一个生成器函数。
     *genMethod(args) { ... },
     // 借助|get|和|set|可以在行内定义访问器。
     // 只是定义内联函数，即使没有生成器。
     // 注意通过这种方式装载的getter不能接受参数
     get propName() { ... },
     // 注意通过这种方式装载的setter至少接受一个参数
     set propName(arg) { ... },
     // []语法可以用于任意支持预计算属性名的地方，来满足上面的第4中情况。
     // 这意味着你可以使用symbol，调用函数，联结字符串
     // 或其它可以给property.id求值的表达式。
     // 这个语法对访问器或生成器同样有效，我在这里只是举个例子。
     [functionThatReturnsPropertyName()] (args) { ... }
};

class Polygon {
  // 构造函数，可选，一个类只能拥有一个名为 constructor 的方法，否则会抛出 SyntaxError 异常。
  // 不可以用生成器作为构造函数。
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
}

/* 匿名类 */ 
let Polygon = class {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};
/* 命名的类 */ 
let Polygon = class Polygon {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
};

class Polygon {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  }
  get area() {
    return this.calcArea()
  }
  calcArea() {
    return this.height * this.width;
  }
}
const square = new Polygon(10, 10);
//调用area方法 100
console.log(square.area);

class Point {
    constructor(x, y) {
        this.x = x;
        this.y = y;
    }
    static distance(a, b) {
        const dx = a.x - b.x;
        const dy = a.y - b.y;
        return Math.sqrt(dx*dx + dy*dy);
    }
}
const p1 = new Point(5, 5);
const p2 = new Point(10, 10);
console.log(Point.distance(p1, p2));

class Dog extends Animal {
  speak() {
    console.log(this.name + ' barks.');
  }
}

var Animal = {
  speak() {
    console.log(this.name + ' makes a noise.');
  }
};
class Dog {
  constructor(name) {
    this.name = name;
  }
  speak() {
    super.speak();//调用对象的父对象上的函数。
    console.log(this.name + ' barks.');
  }
}
//继承常规对象
Object.setPrototypeOf(Dog.prototype, Animal);
var d = new Dog('Mitzie');
d.speak();

context.fillText(`Ceci n'est pas une chaîne.`, x, y);

function authorize(user, action) {
  if (!user.hasPrivilege(action)) {
    throw new Error(
      `用户 ${user.name} 未被授权执行 ${action} 操作。`);
  }
}

function containsAll(haystack, ...needles) {
  for (var needle of needles) {
    if (haystack.indexOf(needle) === -1) {
      return false;
    }
  }
  return true;
}

function animalSentence(ani2="tigers", ani3="bears") {
    return `Lions and ${ani2} and ${ani3}! Oh my!`;// 模板字符串 template strings
}

export var year = 1958;
export function multiply(x, y) {
  return x * y;
};

// 报错
export 1;
// 报错
var m = 1; export m;
// 报错
function f() {}
export f;
//正确写法：在接口名与模块内部变量之间，建立一一对应的关系
export var m = 1;
var m = 1;  export {m};
var n = 1;  export {n as m};
export function f() {};
function f() {}   
export {f};

export {detectCats, Kittydar};//不一定非要把它放在模块文件的首行，可以在模块文件最外层作用域的任一处
// 此处不需要 `export`关键字
function detectCats(canvas, options) { ... }
 class Kittydar { ... }

//导入的时候重命名
import {flip as flipOmelet} from "eggs.js";
//导出的时候也可以重命名
function v1() { ... }
function v2() { ... }
export {
   v1 as streamV1,
   v2 as streamV2,
   v2 as streamLatestVersion
};

// export-default.js
export default function () {
  console.log('foo');
}
//-------------------------------
// 或者 非匿名函数
export default function foo() {
  console.log('foo');
}
// 或者
function foo() {
  console.log('foo');
}
export default foo;
//------------------------------------------------------
// import-default.js
import customName from './export-default';
customName(); // 'foo'

let myObject = {
      field1: value1,
      field2: value2
    };
export {myObject as default};
//or
export default {
      field1: value1,
      field2: value2
    };

// 正确:指定外对接口为default
export default 42;
// 报错:没有指定对外的接口
export 42;

// main.js
import {firstName, lastName, year} from './profile';

import { lastName as surname } from './profile';

import _, { each } from 'lodash';

// 报错
import { 'f' + 'oo' } from 'my_module';

// circle.js 输出两个方法area和circumference。
export function area(radius) {
  return Math.PI * radius * radius;
}
export function circumference(radius) {
  return 2 * Math.PI * radius;
}
// main.js
import { area, circumference } from './circle';
console.log('圆面积：' + area(4));
//或 整体加载
import * as circle from './circle';
console.log('圆面积：' + circle.area(4));

//world-foods.js
// 导入"sri-lanka"并将它导出的内容的一部分重新导出
export {Tea, Cinnamon} from "sri-lanka";
// 导入"singapore"并将它导出的内容全部导出
export * from "singapore";