ES6 is one of the most classic readings.

class SkinnedMesh extends THREE.Mesh {
  constructor(geometry.materials) {
    super(geometry, materials);

    this.idMatrix = SkinnedMesh.defaultMatrix(a);this.bones = [];
    this.boneMatrices = [];
    //.
  }
  update(camera) {
    //.
    super.update(a); }get boneCount() {
    return this.bones.length;
  }
  set matrixType(matrixType) {
    this.idMatrix = SkinnedMesh[matrixType]();
  }
  static defaultMatrix() {
    return new THREE.Matrix4();
  }
}Copy the code

var obj = {
    // __proto__
    __proto__: theProtoObj,
    //Shorthand for 'handler: handler'
    handler,
    // Methods
    toString() {
     // Super calls
     return "d " + super.toString(a); },// Computed (dynamic) property names
    [ 'prop_' + (() = > 42) (the)]: 42
};Copy the code

// Basic literal string creation
`In JavaScript '\n' is a line-feed.`

// Multiline strings
`In JavaScript this is
 not legal.`

// String interpolation
var name = "Bob", time = "today";
`Hello The ${name}, how are you The ${time}?`

// Construct an HTTP request prefix is used to interpret the replacements and construction
POST`http://foo.org/bar?a=The ${a}&b=The ${b}
     Content-Type: application/json
     X-Credentials: The ${credentials}
     { "foo": The ${foo}.
       "bar": The ${bar}}`(myOnReadyStateChangeHandler);Copy the code

// list matching
var [a, , b] = [1.2.3];

// object matching
var { op: a, lhs: { op: b }, rhs: c }
       = getASTNode(a)// object matching shorthand
// binds `op`, `lhs` and `rhs` in scope
var {op, lhs, rhs} = getASTNode(a)// Can be used in parameter position
function g({name: x}) {
  console.log(x);
}
g({name: 5})

// Fail-soft destructuring
var [a] = [];
a = = = undefined;

// Fail-soft destructuring with defaults
var [a = 1] = [];
a = = = 1;Copy the code

function f(x.y=12) {
  // y is 12 if not passed (or passed as undefined)
  return x + y;
}
f(3) = = 15Copy the code

function f(x..y) {
  // y is an Array
  return x * y.length;
}
f(3."hello".true) = = 6Copy the code

function f(x.y.z) {
  return x + y + z;
}
// Pass each elem of array as argument
f(.[1.2.3]) = = 6Copy the code

function f() {{let x;
    {
      // okay, block scoped name
      const x = "sneaky";
      // error, const
      x = "foo";
    }
    // error, already declared in block
    let x = "inner"; }}Copy the code

let fibonacci ={[Symbol.iterator] () {let pre = 0, cur = 1;
    return {
      next() {
        [pre, cur] = [cur, pre + cur];
        return { done: false, value: cur }
      }
    }
  }
}

for (var n of fibonacci) {
  // truncate the sequence at 1000
  if (n > 1000)
    break;
  console.log(n);
}Copy the code

var fibonacci ={[Symbol.iterator]: function*() {
    var pre = 0, cur = 1;
    for (;;) {
      var temp = pre;
      pre = cur;
      cur + = temp;
      yieldcur; }}}for (var n of fibonacci) {
  // truncate the sequence at 1000
  if (n > 1000)
    break;
  console.log(n);
}Copy the code

//Same as ES5.1
"𠮷".length = = 2

//New RegExp behaviour, opt-in 'u'
"𠮷".match(/./u) [0].length = = 2

// new form
"\u{20BB7}"= ="𠮷"= ="\uD842\uDFB7"

// new String ops
"𠮷".codePointAt(0) = = 0x20BB7

// for-of iterates code points
for(var c of "𠮷") {
  console.log(c);
}Copy the code

// lib/math.js
export function sum(x.y) {
  return x + y;
}
export var pi = 3.141593;Copy the code

// app.js
import * as math from "lib/math";
alert("2 PI =" + math.sum(math.pi.math.pi));Copy the code

// otherApp.js
import {sum.pi} from "lib/math";
alert("2 PI =" + sum(pi, pi));Copy the code

// lib/mathplusplus.js
export * from "lib/math";
export var e = 2.71828182846;
export default function(x) {
    return Math.log(x);
}Copy the code

// app.js
import ln, {pi.e} from "lib/mathplusplus";
alert("2 PI =" + ln(e)*pi*2);Copy the code

// Dynamic loading – ‘System’ is default loader
System.import('lib/math').then(function(m) {
  alert("2 PI =" + m.sum(m.pi.m.pi));
});

//Create Execution Sandboxes -- New Loaders
var loader = new Loader({
  global: fixup(window) //The replace 'console. The log'
});
loader.eval("console.log('hello world! ');");

// Directly manipulate module cache
System.get('jquery');
System.set('jquery'.Module({$: $})); // WARNING: not yet finalizedCopy the code

// Proxying a normal object
var target = {};
var handler = {
  get: function (receiver.name) {
    return `Hello, The ${name}!`; }};var p = new Proxy(target, handler);
p.world = = = 'Hello, world!';Copy the code

// Proxying a function object
var target = function () { return 'I am the target'; };
var handler = {
  apply: function (receiver..args) {
    return 'I am the proxy'; }};var p = new Proxy(target, handler);
p(a)= = = 'I am the proxy';Copy the code

var handler =
{
  get:.,
  set:.,
  has:.,
  deleteProperty:.,
  apply:.,
  construct:.,
  getOwnPropertyDescriptor:.,
  defineProperty:.,
  getPrototypeOf:.,
  setPrototypeOf:.,
  enumerate:.,
  ownKeys:.,
  preventExtensions:.,
  isExtensible:.
}Copy the code

var MyClass = (function() {

  // module scoped symbol
  var key = Symbol("key");

  function MyClass(privateData) {
    this[key] = privateData;
  }

  MyClass.prototype = {
    doStuff: function() {
      . this[key] .}};returnMyClass; }) ();var c = new MyClass("hello")
c["key"] = = = undefinedCopy the code

// Pseudo-code of Array
class Array {
    constructor(.args) { / *.* / }
    static [Symbol.create] () {// Install special [[DefineOwnProperty]]
        // to magically update 'length'}}// User code of Array subclass
class MyArray extends Array {
    constructor(.args) { super(.args); }}// Two-phase 'new':
// 1) Call @@create to allocate object
// 2) Invoke constructor on new instance
var arr = new MyArray(a); arr[1] = 12;
arr.length = = 2Copy the code

0b111110111 = = = 503 // true
0o767 = = = 503 // trueCopy the code

// No sample yetCopy the code

function factorial(n.acc = 1) {
    'use strict';
    if (n < = 1) return acc;
    return factorial(n - 1, n * acc);
}

// Stack overflow in most implementations today,
// but safe on arbitrary inputs in ES6
factorial(100000)Copy the code