classtestClass{    static staticFunc(){    console.log("instatic")    }}

"use strict";var _createClass = function () {    function defineProperties(target, props)    {        for (var i = 0; i < props.length; i++) {            var descriptor = props[i];            descriptor.enumerable = descriptor.enumerable || false;            descriptor.configurable = true;            if ("value" in descriptor)                descriptor.writable = true;            //利用defineProperty来创建函数            Object.defineProperty(target, descriptor.key, descriptor);        }    }    //创建函数，根据传入的数组创建成员函数和静态函数    return function (Constructor, protoProps, staticProps)    {        //注意这里，传入的是Constructor.prototype和Constructor        //所以可以区分是静态函数还是成员函数        if (protoProps)            defineProperties(Constructor.prototype, protoProps);        if (staticProps)            defineProperties(Constructor, staticProps);        return Constructor;    };}();function _classCallCheck(instance, Constructor) {    if (!(instance instanceof Constructor)) {        throw new TypeError("Cannot call a class as a function");    }}var testClass = function () {    function testClass() {        /*         *这是是为了保证这个class只能new出来,在usestrict模式下，this是undefined，         *正常模式下，this为window,也就是说我们这直接调用这个函数，_classCallCheck的时候将会抛出异常         **/        _classCallCheck(this, testClass);    }    _createClass(testClass, null, [{        key: "staticFunc",        value: function staticFunc() {            console.log("instatic");        }    }]);    return testClass;}();testClass.staticFunc();

function test(){    this.x = 5;    this.f = function(){        console.log(this.x)    }}    let xx = new test();xx.f.call(this);    

function test(){    this.x = 5;    this.f = ()=>{        console.log(this.x)    }}let xx = new test();xx.f.call(this);

"use strict";function test() {    var _this = this;     //通过创建一个临时的_this变量来规避this改变的问题    this.x = 5;    this.f = function () {        console.log(_this.x);    };}    var xx = new test();xx.f.call(undefined);     //在babel默认的use strict模式下，是不会有默认的全局this的

/*这里只是单纯地翻译* var a=arr[0]* var b=arr[1]* var c=arr[2]* */let arr = [1,2,3];let [a, b, c] = arr;/** 这里也只是由编译器自动生成分割的语法，有点类似于erlang的语法* var head = 1;* var second = 2;* var tail = [3, 4]* */{    let [head,second, ...tail] = [1, 2, 3, 4];}{    /**     * 这里暂时不管yiled是怎么转换的，转换完的代码后:     * var first = _fibs[0]     * var second = _fibs[1]     * var three = _fibs[2]     * 还是自动生成与语法糖     */    function* fibs() {        var a = 0;        var b = 1;        while (true) {            yield a;            [a, b] = [b, a + b];        }    }    var [first, second, third, fourth, fifth, sixth] = fibs();}{    /*    * 跟之前的大同小异,    * var _foo$bar = { foo: “lorem", bar: "ipsum" };    * var bar = _foo$bar.bar;    * var foo = _foo$bar.foo;    * */    var { bar, foo } = { foo: "lorem", bar: "ipsum" };    function t(a){        if(a == 0 ){            return [1, 2, 3];        }        else{            return [];        }    }    let [a, b, c] = t(0);    let [d=1, e=2, f] = t(1);    console.log(d)}

/** 主要是利用arguments取得所有的参数，然后从1开始，把参数都取出来，如果是a, b,...tail则会从2开始*  for (var _len = arguments.length, needles = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {*   needles[_key - 1] = arguments[_key];*  }* */function containsAll(haystack,...tail) {    console.log(arguments.length)}containsAll(1, 2,3,4);//判断arguments的[0]是否为undefined//var a = arguments.length <= 0 || arguments[0] === undefined ? ‘11‘ : arguments[0];function containsAll2(a = ‘11‘){    console.log(a)}containsAll2(2)

/*//这个regeneratorRuntime估计是polyfill的东西var _marked = [fu].map(regeneratorRuntime.mark);function fu() {    var i;    //这里讲函数内部的变量声明在这里，然后利用闭包一直保持住这些变量的改变的改变，再通过switch来选择执行到那一段    //跟C++里面的无堆栈routine的实现比较相似    return regeneratorRuntime.wrap(function fu$(_context) {        while (1) {            switch (_context.prev = _context.next) {                case 0:                    i = 9;                    i++;                    _context.next = 4;                    return i;                case 4:                    i++;                    _context.next = 7;                    return i;                case 7:                case "end":                    return _context.stop();            }        }    }, _marked[0], this);}*/function *fu(){    let i = 9;    i++;    yield i;    i++;    yield i;}fu();fu();