ES6转换为ES5

1.静态函数

　　1.什么是静态函数

　　静态函数最重要的就是不用创建一个实例变量就可以进行调用，在C++里面，无法访问this对象，

　　而在JS里面由于js的this对象支持，是可以访问this对象，只是this对象有所不同

　　2.ES6静态函数代码

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

将会被babel转换为:

"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();

2.=>符号

=>符号的出现是为了解决this作用域改变的问题

function test(){
    this.x = 5;
    this.f = function(){
        console.log(this.x)
    }
}

let xx = new test();
xx.f.call(this);    

在上面的代码里面，本来是期望回调的时候log输出5的，但是此时call的时候this被修改为全局，所以将会产生错误，因为全局里面并没有x

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

将代码修改为上面的代码后，即可正常输出5

"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的

3.解构参数

/*这里只是单纯地翻译
* 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)
}

4.默认参数，不定参数，扩展参数

/*
* 主要是利用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)

5.yield

/*
//这个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();