您的位置:新葡亰496net > 新葡亰官网 > 新葡亰496net:30分钟ES6从陌生到熟悉,javascript异

新葡亰496net:30分钟ES6从陌生到熟悉,javascript异

发布时间:2019-11-24 05:18编辑:新葡亰官网浏览(106)

    30分钟ES6从陌生到熟悉

    2018/07/30 · JavaScript · es6

    原文出处: 叶小钗   

    js中的异步是指一个函数在执行过程中,其中一部分不能马上执行完毕,然后执行函数体中另外一部分。等到第一部分得到返回值再执行第二部分。

    1.回调函数callback

    无法捕获错误 try catch

    不能return

    回调地狱

      function personInfo(callback){

        $.ajax({

              type: "GET",

              url: "test.json", 

              data: {

                    username:username,

                    content:content

              },

            dataType: "json",

            success: function(data){

                  if(data.length>0){

                        callback&&callback();

                  }

            }

      });

    }

    2.事件发布/订阅模型

    给一个事件,订阅几个方法,方法依次执行。

    function Event() {

        this.event = {};

    }

    Event.prototype.on = function (type,callBack) {

        if(this.event[type]){

            this.event[type].push(callBack);

        }else{

            this.event[type] = [callBack];

        }

    };

    Event.prototype.emit = function (type,...data) {

        this.event[type].forEach((item)=>item(...data));

    };

    let event = new Event();

    function fn1(){

      console.log('吃饭');

    }

    function fn2(){

        console.log('工作');

    }

    event.on('我的一天',fn1);

    event.on('我的一天',fn2);

    event.emit('我的一天');

    3.Promise异步函数解决方案

      A执行完执行B,B执行完执行C。把A的返回值给B再给C

    每一次执行,返回一个新的Promise实例(链式调用)

      代码易读

    let p1 = new Promise(function(resolve,reject){

      reject(10000000);

    });

    p1.then(function(value){

      console.log('成功1=',value);

    },function(reason){

      console.log('失败1=',reason);

    });

    p1.then(function(value){

      console.log('成功2=',value);

    },function(reason){

      console.log('失败2=',reason);

    });

    4.Generator生成器函数

    调用一个生成器函数它不会立刻执行

    它返回一个迭代器函数,每调用一次next就可以返回一个值对象

    function *go(a){

        console.log(1);

        let b =  yield a;

        console.log(2);

        let c = yield b;

        console.log(3);

        return c;

    }

    let it = go("a值");

    let r1 = it.next();

    let r2 = it.next('B值');

    5.Co

    co是一个为Node.js和浏览器打造的基于生成器的流程控制工具,借助于Promise,你可以使用更加优雅的方式编写非阻塞代码。

    let fs = require('fs');

    function readFile(filename) {

      return new Promise(function (resolve, reject) {

        fs.readFile(filename, function (err, data) {

          if (err)

            reject(err);

          else

            resolve(data);

        })

      })

    }

    function *read() {

      let template = yield readFile('./template.txt');

      let data = yield readFile('./data.txt');

      return template ' ' data;

    }

    co(read).then(function (data) {

      console.log(data);

    }, function (err) {

      console.log(err);

    });

    function co(gen) {

      let it = gen();

      return new Promise(function (resolve, reject) {

        !function next(lastVal) {

          let {value, done} = it.next(lastVal);

          if (done) {

            resolve(value);

          } else {

            value.then(next, reason => reject(reason));

          }

        }();

      });

    }

    6.Async/ await

    可以实现和co一样的功能

    结构简单,可读性强

    let fs = require('fs');

    function readFile(filename) {

    *  return new Promise(function (resolve, reject) {*

    *新葡亰496net,    fs.readFile(filename, 'utf8', function (err, data) {*

    *      if (err)*

    *        reject(err);*

    *      else*

    *        resolve(data);*

    *    })*

    *  })*

    }

    async function read() {

    *  let template = await readFile('./template.txt');*

    *  let data = await readFile('./data.txt');*

    *  return template ' ' data;*

    }

    let result = read();

    result.then(data=>console.log(data));

    今年工作进度到这里结束,整理一下今年收集的自用js库,后期会更新,代码已贴github=>

    这里只讲 ES6比较突出的特性,因为只能挑出十个,所以其他特性请参考官方文档;

    一、简介
    ECMAScript 2015 是在 2015 年 6 月获批的 ECMAScript 标准。对 ECMAScript 来说,ES2015 是一个巨大的更新,第一次这样大的更新是在 2009 年。在主流 JavaScript 引擎中实现 ES2015 中特性的工作目前正在如火如荼地进行。
    ES2015 特性

    前言

    ECMAScript 6.0(以下简称 ES6)是 JavaScript 语言的下一代标准,已经在 2015 年 6 月正式发布了。它的目标,是使得 JavaScript 语言可以用来编写复杂的大型应用程序,成为企业级开发语言。

    这句话基本涵盖了为什么会产生ES6这次更新的原因——编写复杂的大型应用程序。

    回顾近两年的前端开发,复杂度确实在快速增加,近期不论从系统复杂度还是到前端开发人员数量应该达到了一个饱和值,换个方式说,没有ES6我们的前端代码依旧可以写很多复杂的应用,而ES6的提出更好的帮我们解决了很多历史遗留问题,另一个角度ES6让JS更适合开发大型应用,而不用引用太多的库了。

    本文,简单介绍几个ES6核心概念,个人感觉只要掌握以下新特性便能愉快的开始使用ES6做代码了!

    这里的文章,请配合着阮老师这里的教程,一些细节阮老师那边讲的好得多:

    除了阮老师的文章还参考:

    PS:文中只是个人感悟,有误请在评论提出

      

    /**
     * Created by zhangsong on 16/5/20.
     */
    //    ***********Number One : Parameters************
    //                   参数的传递
    //ES5:
    var link = function (height,color,url) {
      var height = height || 50;
      var color = color || 'red';
      var url = url || ''
    };

    二、ES2015 特性
    1、Arrows and Lexical This
    Arrows are a function shorthand using the => syntax.
    arrows 使用“=>”格式,是一种函数简写。
    <code>
    // Expression bodies
    var odds = evens.map(v => v 1);
    var nums = evens.map((v, i) => v i);
    // Statement bodies
    nums.forEach(v => {
    if (v % 5 === 0)
    fives.push(v);
    });
    // Lexical this
    var bob = {
    _name: "Bob",
    _friends: [],
    printFriends() {
    this._friends.forEach(f => console.log(this._name " knows " f));
    }
    };
    // Lexical arguments
    function square() {
    let example = () => {
    let numbers = [];
    for (number of arguments) {
    numbers.push(number * 2);
    }
    return numbers;
    };
    return example();
    }
    square(2, 4, 7.5, 8, 11.5, 21); // returns: [4, 8, 15, 16, 23, 42]
    </code>

    模块Module的引入

    都说了复杂的大型应用了,所以我们第一个要讨论的重要特性就是模块概念,我们做一个复杂的项目必定需要两步走:

    ① 分得开,并且需要分开

    ② 合得起来

    我们普遍认为没有复杂的应用,只有分不开的应用,再复杂的应用,一旦可以使用组件化、模块化的方式分成不同的小单元,那么其难度便会大大降低,模块化是大型、复杂项目的主要拦路虎。为了解决这个问题,社区制定了一些模块加载方案,对于浏览器开发来说,我们用的最多的是AMD规范,也就是大家熟知的requireJS,而ES6中在语音标准层面实现了模块功能,用以取代服务端通信的CommonJS和AMD规范,成为了通用的规范,多说无益,我们这里上一段代码说明:

    /* validate.js 多用于表单验证 */ export function isEmail (text) { var reg = /^(([^<>()[]\.,;:s@"] (.[^<>()[]\.,;:s@"] )*)|(". "))@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}])|(([a-zA-Z-0-9] .) [a-zA-Z]{2,}))$/; return reg.test(text); } export function isPassword (text) { var reg = /^[a-zA-Z0-9]{6,20}$/; return reg.test(text); }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    /*
    validate.js 多用于表单验证
    */
    export function isEmail (text) {
        var reg = /^(([^<>()[]\.,;:s@"] (.[^<>()[]\.,;:s@"] )*)|(". "))@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}])|(([a-zA-Z-0-9] .) [a-zA-Z]{2,}))$/;
        return reg.test(text);
    }
     
    export function  isPassword (text) {
        var reg = /^[a-zA-Z0-9]{6,20}$/;
        return reg.test(text);
    }

    那么我们现在想在页面里面使用这个工具类该怎么做呢:

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <!-- 请注意这里type=module才能运行 --> <script type="module"> import {isEmail} from './validate.js'; var e1 = 'dddd'; var e2 = 'yexiaochai@qq.com' console.log(isEmail(e1)) console.log(isEmail(e2)) </script> </body> </html>

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <!-- 请注意这里type=module才能运行 -->
    <script type="module">
        import {isEmail} from './validate.js';
        var e1 = 'dddd';
        var e2 = 'yexiaochai@qq.com'
        console.log(isEmail(e1))
        console.log(isEmail(e2))
    </script>
    </body>
    </html>

    ES6中的Module提出,在我这里看来是想在官方完成之前requireJS干的工作,这里也有一些本质上的不一样:

    ① requireJS是使用加载script标签的方式载入js,没有什么限制

    ② import命令会被js引擎静态分析,先于模块其他语句执行

    以上特性会直接给我们带来一些困扰,比如原来我们项目控制器会有这么一段代码:

    var viewId = ''; //由浏览器获取试图id,url可能为?viewId=booking|list|... //如果不存在则需要构建,记住构建时需要使用viewdata继承源view requirejs(viewId, function(View) { //执行根据url参数动态加载view逻辑 })

    1
    2
    3
    4
    5
    var viewId = ''; //由浏览器获取试图id,url可能为?viewId=booking|list|...
    //如果不存在则需要构建,记住构建时需要使用viewdata继承源view
    requirejs(viewId, function(View) {
        //执行根据url参数动态加载view逻辑
    })

    前面说过了,import命令会被js引擎静态分析,先于模块其他语句执行,所以我们在根本不能将import执行滞后,或者动态化,做不到的,这种写法也是报错的:

    if (viewId) { import view from './' viewId; }

    1
    2
    3
    if (viewId) {
      import view from './' viewId;
    }

    新葡亰496net 1

    这种设计会有利于提高编译器效率,但是之前的动态业务逻辑就不知道如何继续了?而ES6如果提供import的方法,我们变可以执行逻辑:

    import(viewId, function() { //渲染页面 })

    1
    2
    3
    import(viewId, function() {
        //渲染页面
    })

    事实上他也提供了:

    新葡亰496net 2

    现在看起来,JS中的模块便十分完美了,至于其中一些细节,便可以用到的时候再说了

    /**

    //ES6
    var link = function(height = 50, color = 'red', url = 'azat.co'){

    2、Classes(一种语法糖)
    ES2015 classes are a simple sugar over the prototype-based OO pattern.
    <code>
    class SkinnedMesh extends THREE.Mesh {
    constructor(geometry, materials) {
    super(geometry, materials);
    this.idMatrix = SkinnedMesh.defaultMatrix();
    this.bones = [];
    this.boneMatrices = [];
    //...
    }
    update(camera) {
    //...
    super.update();
    }
    static defaultMatrix() {
    return new THREE.Matrix4();
    }
    }
    </code>

    ES6中的类Class

    我们对我们的定位一直是非常清晰的,我们就是要干大项目的,我们是要干复杂的项目,除了模块概念,类的概念也非常重要,我们之前用的这种方式实现一个类,我们来温故而知新。

    当一个函数被创建时,Function构造函数产生的函数会隐式的被赋予一个prototype属性,prototype包含一个constructor对象

    而constructor便是该新函数对象(constructor意义不大,但是可以帮我们找到继承关系)

    每个函数都会有一个prototype属性,该属性指向另一对象,这个对象包含可以由特定类型的所有实例共享的属性和方法

    每次实例化后,实例内部都会包含一个[[prototype]](__proto__)的内部属性,这个属性指向prototype

    ① 我们通过isPrototypeOf来确定某个对象是不是我的原型 ② hasOwnPrototype 可以检测一个属性是存在实例中还是原型中,该属性不是原型属性才返回true

    1
    2
    ① 我们通过isPrototypeOf来确定某个对象是不是我的原型
    ② hasOwnPrototype 可以检测一个属性是存在实例中还是原型中,该属性不是原型属性才返回true

    var Person = function (name, age) { this.name = name; this.age = age; }; Person.prototype.getName = function () { return this.name; }; var y = new Person('叶小钗', 30);

    1
    2
    3
    4
    5
    6
    7
    8
    var Person = function (name, age) {
        this.name = name;
        this.age = age;
    };
    Person.prototype.getName = function () {
        return this.name;
    };
    var y = new Person('叶小钗', 30);

    新葡亰496net 3

    为了方便,使用,我们做了更为复杂的封装:

    var arr = []; var slice = arr.slice; function create() { if (arguments.length == 0 || arguments.length > 2) throw '参数错误'; var parent = null; //将参数转换为数组 var properties = slice.call(arguments); //如果第一个参数为类(function),那么就将之取出 if (typeof properties[0] === 'function') parent = properties.shift(); properties = properties[0]; function klass() { this.initialize.apply(this, arguments); } klass.superclass = parent; klass.subclasses = []; if (parent) { var subclass = function () { }; subclass.prototype = parent.prototype; klass.prototype = new subclass; parent.subclasses.push(klass); } var ancestor = klass.superclass && klass.superclass.prototype; for (var k in properties) { var value = properties[k]; //满足条件就重写 if (ancestor && typeof value == 'function') { var argslist = /^s*functions*(([^()]*?))s*?{/i.exec(value.toString())[1].replace(/s/i, '').split(','); //只有在第一个参数为$super情况下才需要处理(是否具有重复方法需要用户自己决定) if (argslist[0] === '$super' && ancestor[k]) { value = (function (methodName, fn) { return function () { var scope = this; var args = [function () { return ancestor[methodName].apply(scope, arguments); } ]; return fn.apply(this, args.concat(slice.call(arguments))); }; })(k, value); } } klass.prototype[k] = value; } if (!klass.prototype.initialize) klass.prototype.initialize = function () { }; klass.prototype.constructor = klass; return klass; }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    var arr = [];
    var slice = arr.slice;
     
    function create() {
      if (arguments.length == 0 || arguments.length > 2) throw '参数错误';
     
      var parent = null;
      //将参数转换为数组
      var properties = slice.call(arguments);
     
      //如果第一个参数为类(function),那么就将之取出
      if (typeof properties[0] === 'function')
        parent = properties.shift();
      properties = properties[0];
     
      function klass() {
        this.initialize.apply(this, arguments);
      }
     
      klass.superclass = parent;
      klass.subclasses = [];
     
      if (parent) {
        var subclass = function () { };
        subclass.prototype = parent.prototype;
        klass.prototype = new subclass;
        parent.subclasses.push(klass);
      }
     
      var ancestor = klass.superclass && klass.superclass.prototype;
      for (var k in properties) {
        var value = properties[k];
     
        //满足条件就重写
        if (ancestor && typeof value == 'function') {
          var argslist = /^s*functions*(([^()]*?))s*?{/i.exec(value.toString())[1].replace(/s/i, '').split(',');
          //只有在第一个参数为$super情况下才需要处理(是否具有重复方法需要用户自己决定)
          if (argslist[0] === '$super' && ancestor[k]) {
            value = (function (methodName, fn) {
              return function () {
                var scope = this;
                var args = [function () {
                  return ancestor[methodName].apply(scope, arguments);
                } ];
                return fn.apply(this, args.concat(slice.call(arguments)));
              };
            })(k, value);
          }
        }
     
        klass.prototype[k] = value;
      }
     
      if (!klass.prototype.initialize)
        klass.prototype.initialize = function () { };
     
      klass.prototype.constructor = klass;
     
      return klass;
    }

    View Code

    这里写一个demo:

    var AbstractView = create({ initialize: function (opts) { opts = opts || {}; this.wrapper = opts.wrapper || $('body'); //事件集合 this.events = {}; this.isCreate = false; }, on: function (type, fn) { if (!this.events[type]) this.events[type] = []; this.events[type].push(fn); }, trigger: function (type) { if (!this.events[type]) return; for (var i = 0, len = this.events[type].length; i < len; i ) { this.events[type][i].call(this) } }, createHtml: function () { throw '必须重写'; }, create: function () { this.root = $(this.createHtml()); this.wrapper.append(this.root); this.trigger('onCreate'); this.isCreate = true; }, show: function () { if (!this.isCreate) this.create(); this.root.show(); this.trigger('onShow'); }, hide: function () { this.root.hide(); } }); var Alert = create(AbstractView, { createHtml: function () { return '<div class="alert">这里是alert框</div>'; } }); var AlertTitle = create(Alert, { initialize: function ($super) { this.title = ''; $super(); }, createHtml: function () { return '<div class="alert"><h2>' this.title '</h2>这里是带标题alert框</div>'; }, setTitle: function (title) { this.title = title; this.root.find('h2').html(title) } }); var AlertTitleButton = create(AlertTitle, { initialize: function ($super) { this.title = ''; $super(); this.on('onShow', function () { var bt = $('<input type="button" value="点击我" />'); bt.click($.proxy(function () { alert(this.title); }, this)); this.root.append(bt) }); } }); var v1 = new Alert(); v1.show(); var v2 = new AlertTitle(); v2.show(); v2.setTitle('我是标题'); var v3 = new AlertTitleButton(); v3.show(); v3.setTitle('我是标题和按钮的alert');

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    var AbstractView = create({
      initialize: function (opts) {
        opts = opts || {};
        this.wrapper = opts.wrapper || $('body');
     
        //事件集合
        this.events = {};
     
        this.isCreate = false;
     
      },
      on: function (type, fn) {
        if (!this.events[type]) this.events[type] = [];
        this.events[type].push(fn);
      },
      trigger: function (type) {
        if (!this.events[type]) return;
        for (var i = 0, len = this.events[type].length; i < len; i ) {
          this.events[type][i].call(this)
        }
      },
      createHtml: function () {
        throw '必须重写';
      },
      create: function () {
        this.root = $(this.createHtml());
        this.wrapper.append(this.root);
        this.trigger('onCreate');
        this.isCreate = true;
      },
      show: function () {
        if (!this.isCreate) this.create();
        this.root.show();
        this.trigger('onShow');
      },
      hide: function () {
        this.root.hide();
      }
    });
     
    var Alert = create(AbstractView, {
     
      createHtml: function () {
        return '<div class="alert">这里是alert框</div>';
      }
    });
     
    var AlertTitle = create(Alert, {
      initialize: function ($super) {
        this.title = '';
        $super();
     
      },
      createHtml: function () {
        return '<div class="alert"><h2>' this.title '</h2>这里是带标题alert框</div>';
      },
     
      setTitle: function (title) {
        this.title = title;
        this.root.find('h2').html(title)
      }
     
    });
     
    var AlertTitleButton = create(AlertTitle, {
      initialize: function ($super) {
        this.title = '';
        $super();
     
        this.on('onShow', function () {
          var bt = $('<input type="button" value="点击我" />');
          bt.click($.proxy(function () {
            alert(this.title);
          }, this));
          this.root.append(bt)
        });
      }
    });
     
    var v1 = new Alert();
    v1.show();
     
    var v2 = new AlertTitle();
    v2.show();
    v2.setTitle('我是标题');
     
    var v3 = new AlertTitleButton();
    v3.show();
    v3.setTitle('我是标题和按钮的alert');

    新葡亰496net 4

    ES6中直接从标准层面解决了我们的问题,他提出了Class关键词让我们可以更好的定义类,我们这里用我们ES6的模块语法重新实现一次:

    export class AbstractView { constructor(opts) { opts = opts || {}; this.wrapper = opts.wrapper || $('body'); //事件集合 this.events = {}; this.isCreate = false; } on(type, fn) { if (!this.events[type]) this.events[type] = []; this.events[type].push(fn); } trigger(type) { if (!this.events[type]) return; for (var i = 0, len = this.events[type].length; i < len; i ) { this.events[type][i].call(this) } } createHtml() { throw '必须重写'; } create() { this.root = $(this.createHtml()); this.wrapper.append(this.root); this.trigger('onCreate'); this.isCreate = true; } show() { if (!this.isCreate) this.create(); this.root.show(); this.trigger('onShow'); } hide() { this.root.hide(); } } export class Alert extends AbstractView { createHtml() { return '<div class="alert">这里是alert框</div>'; } } export class AlertTitle extends Alert { constructor(opts) { super(opts); this.title = ''; } createHtml() { return '<div class="alert"><h2>' this.title

    • '</h2>这里是带标题alert框</div>'; } setTitle(title) { this.title = title; this.root.find('h2').html(title) } } export class AlertTitleButton extends AlertTitle { constructor(opts) { super(opts); this.on('onShow', function () { var bt = $('<input type="button" value="点击我" />'); bt.click($.proxy(function () { alert(this.title); }, this)); this.root.append(bt) }); } }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    export class AbstractView {
        constructor(opts) {
            opts = opts || {};
            this.wrapper = opts.wrapper || $('body');
            //事件集合
            this.events = {};
            this.isCreate = false;
        }
        on(type, fn) {
            if (!this.events[type]) this.events[type] = [];
            this.events[type].push(fn);
        }
        trigger(type) {
            if (!this.events[type]) return;
            for (var i = 0, len = this.events[type].length; i < len; i ) {
                this.events[type][i].call(this)
            }
        }
        createHtml() {
            throw '必须重写';
        }
        create() {
            this.root = $(this.createHtml());
            this.wrapper.append(this.root);
            this.trigger('onCreate');
            this.isCreate = true;
        }
        show() {
            if (!this.isCreate) this.create();
            this.root.show();
            this.trigger('onShow');
        }
        hide() {
            this.root.hide();
        }
    }
    export class Alert extends AbstractView {
        createHtml() {
            return '<div class="alert">这里是alert框</div>';
        }
    }
    export class AlertTitle extends Alert {
        constructor(opts) {
            super(opts);
            this.title = '';
        }
        createHtml() {
            return '<div class="alert"><h2>' this.title '</h2>这里是带标题alert框</div>';
        }
        setTitle(title) {
            this.title = title;
            this.root.find('h2').html(title)
        }
    }
    export class  AlertTitleButton extends AlertTitle {
        constructor(opts) {
            super(opts);
            this.on('onShow', function () {
                var bt = $('<input type="button" value="点击我" />');
                bt.click($.proxy(function () {
                    alert(this.title);
                }, this));
                this.root.append(bt)
            });
        }
    }

    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <script type="text/javascript" src="zepto.js"></script> <!-- 请注意这里type=module才能运行 --> <script type="module"> import {Alert, AlertTitle, AlertTitleButton} from './es6class.js'; var v1 = new Alert(); v1.show(); var v2 = new AlertTitle(); v2.show(); v2.setTitle('我是标题'); var v3 = new AlertTitleButton(); v3.show(); v3.setTitle('我是标题和按钮的alert'); </script> </body> </html>

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <script type="text/javascript" src="zepto.js"></script>
     
    <!-- 请注意这里type=module才能运行 -->
    <script type="module">
    import {Alert, AlertTitle, AlertTitleButton} from './es6class.js';
    var v1 = new Alert();
    v1.show();
    var v2 = new AlertTitle();
    v2.show();
    v2.setTitle('我是标题');
    var v3 = new AlertTitleButton();
    v3.show();
    v3.setTitle('我是标题和按钮的alert');
    </script>
    </body>
    </html>

    这里的代码完成了与上面一样的功能,而代码更加的清爽了。

    * @param {long} //通用函数库

    };

    3、Enhanced Object Literals
    Object literals are extended to support setting the prototype at construction, shorthand for foo: foo assignments, defining methods and making super calls. Together, these also bring object literals and class declarations closer together, and let object-based design benefit from some of the same conveniences.
    <code>
    var obj = {
    // Sets the prototype. "proto" or 'proto' would also work.
    proto: theProtoObj,
    // Computed property name does not set prototype or trigger early error
    for duplicate proto properties.
    <code>['proto']: somethingElse, </code>
    // Shorthand for ‘handler: handler’
    handler,
    // Methods
    toString() {
    // Super calls
    return "d " super.toString();
    },
    // Computed (dynamic) property names
    [ "prop_" (() => 42)() ]: 42
    };
    </code>

    ES6中的函数

    我们这里学习ES6,由大到小,首先讨论模块,其次讨论类,这个时候理所当然到了我们的函数了,ES6中函数也多了很多新特性或者说语法糖吧,首先我们来说一下这里的箭头函数

    * @param {onerror} //js错误调试

                //Number Two : Template Literals
    //                  字面量插入字符串
    //ES5

    4、Template Strings(也是一种语法糖)
    Template strings provide syntactic sugar for constructing strings.
    <code>
    // Basic literal string creation
    This is a pretty little template string.
    // Multiline strings
    In ES5 this is not legal.
    // Interpolate variable bindings
    var name = "Bob", time = "today";
    Hello ${name}, how are you ${time}
    // Unescaped template strings
    String.rawIn ES5 "n" is a line-feed.
    // Construct an HTTP request prefix is used to interpret the replacements and construction
    GEThttp://foo.org/bar?a=${a}&b=${b} Content-Type: application/json X-Credentials: ${credentials} { "foo": ${foo}, "bar": ${bar}}(myOnReadyStateChangeHandler);
    </code>

    箭头函数

    //ES5 $('#bt').click(function (e) { //doing something }) //ES6 $('#bt').click(e => { //doing something })

    1
    2
    3
    4
    5
    6
    7
    8
    //ES5
    $('#bt').click(function (e) {
        //doing something
    })
    //ES6
    $('#bt').click(e => {
        //doing something
    })

    有点语法糖的感觉,有一个很大不同的是,箭头函数不具有this属性,箭头函数直接使用的是外部的this的作用域,这个想不想用看个人习惯吧。

    * @author lpg 2017-11-02

    var name = 'your name is'   first   ''   last   '.';
    var url =  ''   id ;

    5、Destructuring(解构)
    允许模式匹配,支持对象和数组匹配。
    <code>
    // list matching
    var [a, ,b] = [1,2,3];
    a === 1;
    b === 3;
    // object matching
    var { op: a, lhs: { op: b }, rhs: c }
    = getASTNode()
    // object matching shorthand
    // binds op, lhs and rhs in scope
    var {op, lhs, rhs} = getASTNode()
    // 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;
    // Destructuring defaults arguments
    function r({x, y, w = 10, h = 10}) {
    return x y w h;
    }
    r({x:1, y:2}) === 23
    </code>

    参数新特性

    ES6可以为参数提供默认属性

    function log(x, y = 'World') { console.log(x, y); } log('Hello') // Hello World log('Hello', 'China') // Hello China log('Hello', '') // Hello

    1
    2
    3
    4
    5
    6
    7
    function log(x, y = 'World') {
      console.log(x, y);
    }
     
    log('Hello') // Hello World
    log('Hello', 'China') // Hello China
    log('Hello', '') // Hello

    至于不定参数撒的,我这里没有多过多的使用,等项目遇到再说吧,如果研究的太细碎,反而不适合我们开展工作。

    */

    //ES6

    6、Default Rest Spread
    Callee-evaluated default parameter values.
    在函数回调中,把数组转换成连续参数
    <code>
    function f(x, y=12) {
    // y is 12 if not passed (or passed as undefined)
    return x y;}
    f(3) == 15
    function f(x, ...y) {
    // y is an Array
    return x * y.length;
    }
    f(3, "hello", true) == 6
    function f(x, y, z) {
    return x y z;
    }
    // Pass each elem of array as argument
    f(...[1,2,3]) == 6
    </code>

    let、const和var

    之前的js世界里,我们定义变量都是使用的var,别说还真挺好用的,虽有会有一些问题,但是对于熟悉js特性的小伙伴都能很好的解决,一般记住:变量提升会解决绝大多数问题。

    就能解决很多问题,而且真实项目中,我们会会避免出现变量出现重名的情况所以有时候大家面试题中看到的场景在实际工作中很少发生,只要不刻意臆想、制造一些难以判断的场景,其实并不会出现多少BUG,不能因为想考察人家对语言特性的了解,就做一些容易容易忘掉的陷阱题。

    无论如何,var 声明的变量受到了一定诟病,事实上在强类型语言看来也确实是设计BUG,但是完全废弃var的使用显然不是js该做的事情,这种情况下出现了let关键词。

    let与var一致用以声明变量,并且一切用var的地方都可以使用let替换,新的标准也建议大家不要再使用var了,let具有更好的作用域规则,也许这个规则是边界更加清晰了:

    { let a = 10; var b = 1; } a // ReferenceError: a is not defined. b // 1

    1
    2
    3
    4
    5
    6
    7
    {
      let a = 10;
      var b = 1;
    }
     
    a // ReferenceError: a is not defined.
    b // 1

    这里是一个经典的闭包问题:

    var a = []; for (var i = 0; i < 10; i ) { a[i] = function () { console.log(i); }; } a[6](); // 10

    1
    2
    3
    4
    5
    6
    7
    var a = [];
    for (var i = 0; i < 10; i ) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 10

    因为i在全局范围有效,共享同一个作用域,所以i就只有10了,为了解决这个问题,我们之前会引入闭包,产生新的作用域空间(好像学名是变量对象,我给忘了),但是那里的i跟这里的i已经不是一个东西了,但如果将var改成let,上面的答案是符合预期的。可以简单理解为每一次“{}”,let定义的变量都会产生新的作用域空间,这里产生了循环,所以每一次都不一样,这里与闭包有点类似是开辟了不同的空间。

    for (let i = 0; i < 3; i ) { let i = 'abc'; console.log(i); } // abc // abc // abc

    1
    2
    3
    4
    5
    6
    7
    for (let i = 0; i < 3; i ) {
      let i = 'abc';
      console.log(i);
    }
    // abc
    // abc
    // abc

    这里因为内部重新声明了i,事实上产生了3个作用域,这里一共有4个作用域指向,let最大的作用就是js中块级作用域的存在,并且内部的变量不会被外部所访问,所以之前为了防止变量侮辱的立即执行函数,似乎变得不是那么必要了。

    之前我们定义一个常量会采用全部大写的方式:

    var NUM = 10;

    1
    var NUM = 10;

    为了解决这个问题,ES6引入了const命令,让我们定义只读常量,这里不对细节做过多研究,直接后续项目实践吧,项目出真知。

    window.onerror = function (errorMessage, scriptURI, lineNumber, columnNumber, errorObj) {

    var name = `your name is ${first} ${last}.`;
    var url = `) ${id}`;

    7、Let Const
    let is the new var. const is single-assignment.
    <code>
    function f() {
    {
    let x;
    {
    // this is ok since it's a block scoped name
    const x = "sneaky";
    // error, was just defined with const above
    x = "foo";
    }
    // this is ok since it was declared with let
    x = "bar";
    // error, already declared above in this block
    let x = "inner";
    }
    }
    </code>

    生成器Generators

    ES6中提出了生成器Generators的概念,这是一种异步编程的解决方案,可以将其理解为一种状态机,封装了多个内部状态,这里来个demo:

    function* helloWorldGenerator() { yield 'hello'; yield 'world'; return 'ending'; } var hw = helloWorldGenerator(); hw.next() // { value: 'hello', done: false } hw.next() // { value: 'world', done: false } hw.next() // { value: 'ending', done: true } hw.next() // { value: undefined, done: true }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    function* helloWorldGenerator() {
      yield 'hello';
      yield 'world';
      return 'ending';
    }
    var hw = helloWorldGenerator();
    hw.next()
    // { value: 'hello', done: false }
    hw.next()
    // { value: 'world', done: false }
    hw.next()
    // { value: 'ending', done: true }
    hw.next()
    // { value: undefined, done: true }

    这个yield(产出)类似于之前的return,直观的理解就是一个函数可以返回多次了,或者说函数具有“顺序状态”,yield提供了暂停功能。这里我想写个代码来验证下期中的作用域状态:

    function* test(){ let i = 0; setTimeout(function() { i ; }, 1000); yield i; yield i ; return i } let t = test(); console.log(t.next()); setTimeout(function() { console.log(t.next()); }, 2000); console.log(t.next()); //{value: 0, done: false} //{value: 0, done: false} //{value: 2, done: true}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    function* test(){
        let i = 0;
        setTimeout(function() {
            i ;
        }, 1000);
        yield i;
        yield i ;
        return i
    }
     
    let t = test();
    console.log(t.next());
     
    setTimeout(function() {
        console.log(t.next());
    }, 2000);
    console.log(t.next());
     
    //{value: 0, done: false}
    //{value: 0, done: false}
    //{value: 2, done: true}

    之前我们写一个城市级联的代码,可能会有些令人蛋疼:

    $.get('getCity', {id: 0}, function(province) { let pid = province[0]; //根据省id获取城市数据 $.get('getCity', {id: pid}, function(city) { let cityId = city[0]; //根据市级id获取县 $.get('getCity', {id: cityId}, function(city) { //do smt. }); }); });

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    $.get('getCity', {id: 0}, function(province) {
        let pid = province[0];
        //根据省id获取城市数据
        $.get('getCity', {id: pid}, function(city) {
            let cityId = city[0];
            //根据市级id获取县
            $.get('getCity', {id: cityId}, function(city) {
                //do smt.
            });
        });
    });

    这个代码大家应当比较熟悉了,用promise能从语法层面解决一些问题,这里简单介绍下promise。

    console.log("错误信息:", errorMessage);

                //Number Three : Multi-line Strings
                //多行字符串
    //ES5

    8、Iterators For..Of
    <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);
    }
    </code>
    Iteration is based on these duck-typed interfaces
    <code>
    interface IteratorResult {
    done: boolean;
    value: any;
    }
    interface Iterator {
    next(): IteratorResult;
    }
    interface Iterable {
    Symbol.iterator: Iterator
    }
    </code>

    Promise

    Promise是一种异步解决方案,有些同事认为其出现就是为了我们代码变得更好看,解决回调地狱的语法糖,ES6将其写入了语音标准,提供了原生Promise对象。Promise为一容器,里面保存异步事件的结果,他是一个对象具有三个状态:pending(进行中)、fulfilled(已成功)、rejected(已失败),这里还是来个简单代码说明:

    function timeout(ms) { return new Promise((resolve, reject) => { setTimeout(resolve, ms, 'done'); }); } timeout(100).then((value) => { console.log(value); });

    1
    2
    3
    4
    5
    6
    7
    8
    9
    function timeout(ms) {
      return new Promise((resolve, reject) => {
        setTimeout(resolve, ms, 'done');
      });
    }
     
    timeout(100).then((value) => {
      console.log(value);
    });

    实例化Promise时,第一个回调必须提供,是进行转为成功时候会执行,第二个也是一个函数失败时候调用,非必须,这里来个demo:

    let timeout = function (ms) { return new Promise(function (resolve) { setTimeout(resolve, ms); }); }; timeout(1000).then(function () { return timeout(1000).then(function () { let s = '大家'; console.log(s) return s; }) }).then(function (data) { return timeout(1000).then(function () { let s = data '好,'; console.log(s) return s; }) }).then(function(data) { return timeout(1000).then(function () { let s = data '我是叶小钗'; console.log(s) return s; }); }).then(function(data) { console.log(data) });

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    let  timeout = function (ms) {
        return new Promise(function (resolve) {
            setTimeout(resolve, ms);
        });
    };
     
    timeout(1000).then(function () {
        return timeout(1000).then(function () {
            let s = '大家';
            console.log(s)
            return s;
        })
     
    }).then(function (data) {
        return timeout(1000).then(function () {
            let s = data '好,';
            console.log(s)
            return s;
        })
    }).then(function(data) {
        return timeout(1000).then(function () {
            let s = data '我是叶小钗';
            console.log(s)
            return s;
        });
    }).then(function(data) {
        console.log(data)
    });

    如果我们请求有依赖的话,第一个请求依赖于第二个请求,代码就可以这样写:

    let getData = function(url, param) { return new Promise(function (resolve) { $.get(url, param, resolve ); }); } getData(' (data) { console.log('我获取了省数据,我们马上根据省数据申请市数据', data); return getData(' (data1) { console.log(data1); return '我是市数据'; }) }).then(function(data) { //前面的参数传过来了 console.log(data); console.log('我获取了市数据,我们马上根据市数据申请县数据'); getData(' (data1) { console.log(data1); }); })

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    let getData = function(url, param) {
        return new Promise(function (resolve) {
            $.get(url, param, resolve );
        });
    }
    getData('http://api.kuai.baidu.com/city/getstartcitys?callback=?').then(function (data) {
        console.log('我获取了省数据,我们马上根据省数据申请市数据', data);
        return getData('http://api.kuai.baidu.com/city/getstartcitys?callback=?').then(function (data1) {
            console.log(data1);
            return '我是市数据';
        })
     
    }).then(function(data) {
        //前面的参数传过来了
        console.log(data);
        console.log('我获取了市数据,我们马上根据市数据申请县数据');
        getData('http://api.kuai.baidu.com/city/getstartcitys?callback=?').then(function (data1) {
            console.log(data1);
        });
    })

    新葡亰496net 5

    如此便可以避免多层嵌套了,关于Promise的知识点还很多,我们遇到复杂的工作场景再拿出来说吧,我对他的定位就是一个语法糖,将异步的方式变成同步的写法,骨子里还是异步,上面我们用Promise解决回调地狱问题,但是回调地狱问题遇到的不多,却发现Promise一堆then看见就有点烦,我们的Generator函数似乎可以让这个情况得到缓解。

    但是暂时在实际工作中我没有找到更好的使用场景,这里暂时到这里,后面工作遇到再详述,对这块不是很熟悉也不妨碍我们使用ES6写代码。

    console.log("出错文件:", scriptURI);

    var str = 'aaaaaaaaaaaaaaaaa'
        'bbbbbbbbbbbbbbbbbbbbbb'
        'cccccccccccccccccccccc';

    9、Generators
    Generators simplify iterator-authoring using function* and yield.
    声明为 function* 的函数返回一个 Generator 实例。Generator 是 iterators 的子类型,它包含 next 和 throw 。这使得值可以回滚进 generator. 因此,yield 是返回一个值或扔掉一个值的表达。
    <code>
    var fibonacci = {
    [Symbol.iterator]: function*() {
    var pre = 0, cur = 1;
    for (;;) {
    var temp = pre;
    pre = cur;
    cur = temp;
    yield cur;
    }
    }
    }
    for (var n of fibonacci) {
    // truncate the sequence at 1000
    if (n > 1000)
    break;
    console.log(n);
    }
    interface Generator extends Iterator {
    next(value?: any): IteratorResult;
    throw(exception: any);
    }
    </code>

    代理

    代理,其实就是你要做什么我帮你做了就行了,一般代理的原因都是,我需要做点手脚,或者多点操作,或者做点“赋能”,如我们常常包装setTimeout一般:

    let timeout = function (ms, callback) { setTimeout(callback, ms); }

    1
    2
    3
    let timeout = function (ms, callback) {
        setTimeout(callback, ms);
    }

    我们包装setTimeout往往是为了clearTimeout的时候能全部清理掉,其实就是拦截下,ES6提供了Proxy关键词用于设置代理器:

    var obj = new Proxy({}, { get: function (target, key, receiver) { console.log(`getting ${key}!`); return Reflect.get(target, key, receiver); }, set: function (target, key, value, receiver) { console.log(`setting ${key}!`); return Reflect.set(target, key, value, receiver); } }); obj.count = 1 // setting count! obj.count // getting count! // setting count! // 2

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    var obj = new Proxy({}, {
      get: function (target, key, receiver) {
        console.log(`getting ${key}!`);
        return Reflect.get(target, key, receiver);
      },
      set: function (target, key, value, receiver) {
        console.log(`setting ${key}!`);
        return Reflect.set(target, key, value, receiver);
      }
    });
    obj.count = 1
    //  setting count!
    obj.count
    //  getting count!
    //  setting count!
    //  2

    //target参数表示所要拦截的目标对象,handler参数也是一个对象,用来定制拦截行为 var proxy = new Proxy(target, handler);

    1
    2
    //target参数表示所要拦截的目标对象,handler参数也是一个对象,用来定制拦截行为
    var proxy = new Proxy(target, handler);

    我们这里继续写一个简单的demo:

    let person = { constructor: function(name, age = 20) { this.name = name; this.age = age }, addAge: function() { this.age ; }, getAge: function() { return this.age; } } var proxy = new Proxy(person, { get: function(target, property) { console.log(arguments); return target[property]; }, set: function(target, property) { console.log(arguments); } }); person.constructor('叶小钗', 30); console.log(person.age) console.log(proxy.age)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    let person = {
        constructor: function(name, age = 20) {
            this.name = name;
            this.age = age
        },
        addAge: function() {
            this.age ;
        },
        getAge: function() {
            return this.age;
        }
    }
     
    var proxy = new Proxy(person, {
        get: function(target, property) {
            console.log(arguments);
            return target[property];
        },
        set: function(target, property) {
            console.log(arguments);
        }
    });
     
    person.constructor('叶小钗', 30);
    console.log(person.age)
    console.log(proxy.age)

    新葡亰496net 6

    但是暂时我没有发现比较好的业务场景,比如说,我现在重写了一个实例的get方法,便能在一个全局容器中记录这个被执行了多少次,这里一个业务场景是:我一次个页面连续发出了很多次请求,但是我单页应用做页面跳转时候,我需要将所有的请求句柄移除,这个似乎也不是代理完成的工作,于是要使用ES6写代码,似乎可以暂时忽略代理。

    console.log("出错行号:", lineNumber);

    //ES6

    三、深度理解
    1、Unicode
    <code>
    // same as ES5.1
    "

    本文由新葡亰496net发布于新葡亰官网,转载请注明出处:新葡亰496net:30分钟ES6从陌生到熟悉,javascript异

    关键词: