你必须要懂的 ES6 语法

// var
if (true) {
  var test = 'hello word';
}
console.log(test); // hello word;
// let
if (true) {
  let test = 'hello word';
}
console.log(test); // ReferenceError: test is not defined

// 情况一
const test = {a: 1};
test.a = 2;
console.log(test); // {a: 2}
// 情况二
const test = 'hello word';
test = 'test'; // TypeError: Assignment to constant variable.

let arr = [1, 2, 3, 4];
console.log(typeof arr); // object

let arr = [1, 2, 3];
console.log(arr instanceof Array); // true
console.log(Array.isArray(arr)); // true

// es5
var msg = 'hello word';

var str1 = '<div>' + msg + '</div>';
var str2 = '<div>' +
          '<span>' +
          '</span>' +
          '</div>';
var str3 = '<div>\
            <span>\
            </span>\
            </div>';
// es6
var str1 = `<div>${msg}</div>`;
var str2 = `<div>
            <span>
            </span>
            </div>
            `;

var test = v => v;
// 等同于
var test = function (v) {
  return v;
};
// 
var test = () => 5;
// 等同于
var test = function () { return 5 };
//
var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {
  return num1 + num2;
};
// 如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。
var sum = (num1, num2) => { return num1 + num2; }

// es6之前
function log (x, y) {
  x = x || 1;
  y = y || 2;
  return x + y;
}
log(); // 3
log(2,3) // 5
// es6
function log (x = 1, y = 2) {
  return x + y;
}
// 或者
let log = (x = 1, y = 2) => x + y;

log(); // 3
log(2,3) // 5

// es6之前
function sum () {
  var s = 0;
  for (var i in arguments) {
    s += arguments[i]
  }
  console.log(s);
}
sum(1,2,3,4,5,6); // 21

// es6
function sum (...num) {
  var s = 0;
  for (var i in num) {
    s += num[i];
  }
  console.log(s);
}
sum(1,2,3,4,5,6); // 21

// 基本使用
class Point {
  // 类方法
  toString () {}
}
typeof Point; // function

// 类的两种方法
class Foo {
   // ...
}
const f = new Point(); // Uncaught ReferenceError: Foo is not defined(...)
var Point = class {
  // ...
}
const f = new Point(); // 正确

// 静态方法
class Foo {
  static toString () {
    console.log('我是静态方法');
  }
  point () {
    console.log('我不是静态方法');
  }
  log () {
    console.log('我是输出方法');
  }
}
class Point extends Foo {
  log () {
    console.log('重写父级log方法');
  }
}

let f = new Foo();
let p = new Point();

Foo.toString(); // 我是静态方法
f.toString();   // TypeError: f.toString is not a function
f.point();     // 我不是静态方法
f.log();       // 我是输出方法

Point.toString(); // 我是静态方法
p.toString();  // TypeError: p.log is not a function
p.point();     // 我不是静态方法
p.log();       // 重写父级log方法

class Point {
  get prop () {
    console.log('我是get方法');
  }
  set prop (value) {
    console.log('我是set方法---值为 : ' + value);
  }
}

let p = new Point();
p.prop;     // 我是get方法
p.prop = 'demo'; // 我是set方法---值为 : demo

class Point {}
class Foo extends Point {}
// Foo就具有Point的所有方法，相当于复制

class A {}
class B extends A {
  constructor() {
    super(); //ES6 要求，子类的构造函数必须执行一次super函数。
  }
}

class A {
  c() {
  return 2;
}
}
class B extends A {
  constructor() {
    super();
    console.log(super.c()); // 2
  }
}
let b = new B();

// 方法一
export const a = 1;
export const b = 2;
export function toString () {}

// 方法二
const a = 1;
const b = 2;
function toString () {}
export {a, b, toString};

// 重命名
const a = 1;
const b = 2;
function toString () {}
export {
  a as v1,
  b as v2,
  toString as v3
}

export default function  () {}
// 加载时
import toString from './a.js';
toString();

// 方法一
import axios from './axios';
// 方法二
import {toString, a, b} from './mo.js';
// 方法三
import {a as b, n as c} from './mo.js'; // 对方法重命名
import * as reg from './reg.js'; // 把所有方法放入到reg对象中