金沙棋牌官方平台

当前位置:金沙棋牌 > 金沙棋牌官方平台 > 自己收集的工作js库,ES6的十个新特性

自己收集的工作js库,ES6的十个新特性

来源:http://www.logblo.com 作者:金沙棋牌 时间:2019-11-21 10:15

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) {*

*    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 6.0(以下简单称谓 ES6卡塔 尔(阿拉伯语:قطر‎是 JavaScript 语言的新一代规范,已经在 二零一六 年 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 || ''
};

模块Module的引入

都在说了复杂的巨型应用了,所以大家率先个要商讨的根本特征正是模块概念,我们做三个犬牙相错的门类一定会将必要两步走:

① 分得开,而且须求分开

② 合得起来

咱俩普及以为未有复杂的使用,独有分不开的使用,再复杂的应用,意气风发旦得以应用组件化、模块化的措施分为分化的小单元,那么其难度便会大大裁减,模块化是重型、复杂项指标根本障碍。为了消除这一个主题材料,社区制定了部分模块加载方案,对于浏览器开采来说,我们用的最多的是英特尔标准,也正是大户人家熟习的requireJS,而ES6中在语音标准层面达成了模块成效,用以代表服务端通信的CommonJS和英特尔标准,成为了通用的规范,多说无益,大家这里上风流倜傥段代码表达:

/* 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;
}

金沙棋牌官方平台 1

这种安插会实惠增加编写翻译器效能,不过在此以前的动态业务逻辑就不领悟哪些一而再了?而ES6万生龙活虎提供import的不二等秘书诀,大家变能够实施逻辑:

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

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

实际他也提供了:

金沙棋牌官方平台 2

金沙棋牌官方平台,明日看起来,JS中的模块便特别完美了,至于里面部分细节,便得以用到的时候再说了

/**

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

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

金沙棋牌官方平台 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');

金沙棋牌官方平台 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} //通用函数库

};

ES6中的函数

作者们这里上学ES6,由大到小,首先谈谈模块,其次探讨类,当时自然到了大家的函数了,ES6中等高校函授数也多了好些个新天性或然说语法糖吧,首先大家的话一下那边的箭头函数

* @param {onerror} //js错误调节和测量检验

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

箭头函数

//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 ;

参数新特征

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

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}`;

生成器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,直观的知晓正是八个函数能够再次来到数12次了,恐怕说函数具备“顺序状态”,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

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);
    });
})

金沙棋牌官方平台 5

如此那般便能够免止多层嵌套了,关于Promise的知识点还广大,大家相见复杂的干活场景再拿出的话呢,笔者对她的一向就是一个语法糖,将异步的措施改为同步的写法,骨子里大概异步,下边大家用Promise解决回调鬼世界难点,可是回调地狱难题遭遇的相当的少,却发掘Promise一批then见到就有一些烦,咱们的Generator函数仿佛能够让这一个场合赢得杀绝。

不过权且在其实职业中自甲寅有找到更加好的应用情况,这里权且到此地,前边职业碰着再详述,对那块不是很熟识也不要紧碍大家选择ES6写代码。

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

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

代理

代理,其实就是您要做怎么着自身帮你做了就能够了,日常代理的来头都以,小编索要做点动作,只怕多点操作,恐怕做点“赋能”,如作者辈平时包装setTimeout平日:

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

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

咱俩包装set提姆eout往往是为了clear提姆eout的时候能全体清理掉,其实就是阻止下,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)

金沙棋牌官方平台 6

而是临时笔者尚未察觉相比好的工作场景,举个例子说,笔者未来重写了三个实例的get方法,便能在二个大局容器中著录这一个被实行了多少次,这里一个事情场景是:小编壹遍个页面总是发出了很频仍诉求,不过自个儿单页应用做页面跳转时候,小编索要将持有的央浼句柄移除,这几个就好像亦非代理完结的办事,于是要运用ES6写代码,犹如能够一时忽视代理。

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

//ES6

结语

有了以上文化,基本从程序层面能够接收ES6写代码了,不过工程规模还亟需引进webpack等工具,那个大家后一次牵线吧。

1 赞 收藏 评论

金沙棋牌官方平台 7

console.log("出错列号:", columnNumber);

var str = `aaaaaaaaaaaaaaaaaaa
            bbbbbbbbbbbbbbbbbb
            cccccccccccccccccc`;

console.log("错误详细情形:", errorObj);

//              Number Four : Destructuring Assignment
               //读取对象属性恐怕是数组成分

}

//ES5:

var eventUtils = {//跨浏览器事件

var a = {
    p1: "this is p1",
    p2: "this is p2"
};
 var p1 = a.p1;
 var p2 = a.p2;

getEvent: function (event) {//获取事件

//ES6

return event ? event : window.event

var {p1 , p2} = a;

},

var [p1,p2] = arr.split('n');

addHandler: function (ele, type, handler) {//事件监听

            //Number Five : Enhanced Object Literals
            //对象的加重

if (ele.addEventListener) {

//ES5

ele.addEventListener(type, handler)

var serviceBase = {port: 3000, url: 'azat.co'},
    getAccounts = function(){return [1,2,3]}

} else if (ele.attachEvent) {

var accountServiceES5 = {
    port: serviceBase.port,
    url: serviceBase.url,
    getAccounts: getAccounts,
    toString: function() {
        return JSON.stringify(this.valueOf())
    },
    getUrl: function() {return "http://" + this.url + ':' + this.port},
    valueOf_1_2_3: getAccounts()
};

ele.attachEvent('on' + type, handler)

var accountServiceES5ObjectCreate = Object.create(serviceBase)
var accountServiceES5ObjectCreate = {
    getAccounts: getAccounts,
    toString: function() {
        return JSON.stringify(this.valueOf())
    },
    getUrl: function() {return "http://" + this.url + ':' + this.port},
    valueOf_1_2_3: getAccounts()
};

} else {

//ES6

ele['on' + type]

var serviceBase = {port: 3000, url: 'azat.co'},
    getAccounts = function(){return [1,2,3]}
var accountService = {
    __proto__: serviceBase,
    getAccounts,
    toString() {
        return JSON.stringify((super.valueOf()))
    },
    getUrl() {return "http://" + this.url + ':' + this.port},
    [ 'valueOf_' + getAccounts().join('_') ]: getAccounts()
};
console.log(accountService);

}

            //Number Six: Arrow Functions
            //  箭头方法

},

//ES5:

removeHandler: function (ele, type, handler) {//移除监听

var _this = this
$('.btn').click(function(event){
    _this.sendData()
});

if (ele.removeEventListener) {

var ids = ['5632953c4e345e145fdf2df8','563295464e345e145fdf2df9']
var messages = ids.map(function (value) {
    return "ID is " + value // explicit return
});

ele.removeEventListener(type, handler)

//ES6

} else if (ele.attachEvent) {

$('.btn').click((event) =>{
    this.sendData()
});

ele.detachEvent('on' + type, handler)

var ids = ['5632953c4e345e145fdf2df8','563295464e345e145fdf2df9']
var messages = ids.map(value => `ID is ${value}`) // implicit return

} else {

                            //Number Seven : Promises
//ES5

ele['on' + type]

setTimeout(function(){
    console.log('Yay!')
}, 1000)

}

//ES6

},

var wait1000 =  new Promise(function(resolve, reject) {
    setTimeout(resolve, 1000)
}).then(function() {
        console.log('Yay!')
    })

getTarget: function (event) {//事件目的

//OR

if (event.target) {

var wait1000 =  new Promise((resolve, reject)=> {
    setTimeout(resolve, 1000)
}).then(()=> {
        console.log('Yay!')
    })

return event.target

//                       Block-Scoped Constructs Let and Const
//                          块级功效域的变量证明

} else {

//ES5:

return event.srcElement

function calculateTotalAmount (vip) {
    var amount = 0
   if (vip) {
        var amount = 1
    }
    { // more crazy blocks!
       var amount = 100
        {
            var amount = 1000
        }
    }
    return amount
}

}

console.log(calculateTotalAmount(true));

},

//ES6

preventDefault: function (event) {//阻止暗许事件

function calculateTotalAmount (vip) {
    var amount = 0 // probably should also be let, but you can mix var and let
   if (vip) {
        let amount = 1 // first amount is still 0
    }
    { // more crazy blocks!
       let amount = 100 // first amount is still 0
        {
            let amount = 1000 // first amount is still 0
        }
    }
    return amount
}

if (event.preventDefault) {

console.log(calculateTotalAmount(true));

return event.preventDefault

//let 使评释变量不会被升级
//let 严厉限定了所注明变量的成效域,在哪注明在哪用
//let 不可能重新注解同贰个变量
//用 let 能够去掉函数的自实行

} else {

//                      Number Nine: Classes
//                           类

return event.returnValue = false

//New Concept in js:

}

class baseModel {
    constructor(options = {}, data = []) { // class constructor
       this.name = 'Base'
       this.url = ''
       this.data = data
        this.options = options
    }

},

    getName() { // class method
       console.log(`Class name: ${this.name}`)
    }
}

stopPropagation: function (event) {//阻止冒泡

//                            Number  Ten:  Modules
//                                   模块

if (event.stopPropagation) {

//ES5 : Node.js

return event.stopPropagation

module.exports = {
    port: 3000,
    getAccounts: function() {
        //***
    }
}

} else {

var service = require('module.js')
console.log(service.port) // 3000

return event.cancelBubble = true

//ES6

}

export var port = 3000
export function getAccounts(url) {
//...
}

}

import {port, getAccounts} from 'module'
console.log(port) // 3000

}

//OR

/*

import * as service from 'module'
console.log(service.port) // 3000

*通用ajax请求

*需引入jq库支持

*/

var xhr = {

ajaxRequest(options = {

type: 'Get'

}) {//同步ajax

var ajax = {

type: options.type,

url: options.url,

data: options.data,

dataType: 'json',

xhrFields: {

withCredentials: true

},

crossDomain: true

};

ajax.success = (result) => {

console.log(result)

};

$.ajax(ajax)

},

async asyncRequest(options = {

type: 'Get'

}) {//异步ajax

return new promise((resolve, reject) => {

var ajax = {

type: options.type,

url: options.url,

data: options.data,

dataType: 'json',

async: true,

xhrFields: {

withCredentials: true

},

crossDomain: true

};

ajax.success = (result) => {

resolve(result);

console.log(result)

};

ajax.error = (error) => {

resolve(error)

};

$.ajax(ajax)

})

}

}

/**

* @param {httpGet()}老版本http请求

* @method => httpGet({'央求url','传输data','回调函数'})

*/

function httpGet(services, data, callback) {

var url = 'example';

$.ajax({

url: url,

data: data,

dataType: 'json',

xhrFields: {

withCredentials: true

},

crossDomain: true,

success: function (data) {

var info = data['data']['info'];//再次来到数据格式视情况而定

if (data['ret'] == 200 && data['data']['code'] == 0) {

callback(info);

} else {

if (data['data']['code'] == 700) {

return;

}

var msg = data['data'] && data['data']['msg'] ? data['data']['msg'] : '';

msg = msg == '' && data['msg'] ? data['msg'] : msg;

//xhr.showmsg(msg);

}

},

error: function (data) {

}

})

}

/* 封装ajax函数

1 * @param 简易原生ajax

2 * @param {string}opt.type http连接的格局,满含POST和GET三种艺术

3 * @param {string}opt.url 发送乞请的url

4 * @param {boolean}opt.async 是不是为异步哀告,true为异步的,false为合作的

5 * @param {object}opt.data 发送的参数,格式为目的类型

6 * @param {function}opt.success ajax发送并摄取成功调用的回调函数

7 */

function Ajax(opt) {

opt = opt || {};

opt.method = opt.method.toUpperCase() || 'POST';

opt.url = opt.url || '';

opt.async = opt.async || true;

opt.data = opt.data || null;

opt.success = opt.success || function () { };

var xmlHttp = null;

if (XMLHttpRequest) {

xmlHttp = new XMLHttpRequest();

}

else {

xmlHttp = new ActiveXObject('Microsoft.XMLHTTP');

};

var params = [];

for (var key in opt.data) {

params.push(key + '=' + opt.data[key]);

}

var postData = params.join('&');

if (opt.method.toUpperCase() === 'POST') {

xmlHttp.open(opt.method, opt.url, opt.async);

xmlHttp.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded;charset=utf-8');

xmlHttp.send(postData);

}

else if (opt.method.toUpperCase() === 'GET') {

xmlHttp.open(opt.method, opt.url + '?'

  • postData, opt.async);

xmlHttp.send(null);

}

xmlHttp.onreadystatechange = function () {

if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {

opt.success(xmlHttp.responseText);

}

};

}

/**

* 分页加载器

* @type {Function}

* 方法可扩充

*/

function pagingLoad(options) { //分页加载

if (!document.getElementById('load_txt')) {

this.loadTxt

document.createElement('div');

loadTxt.id = "load_txt";

loadTxt.style.textAlign = "center";

document.body.appendChild(loadTxt);

};

this.oPageLoad = {

page: 1,

el: options.el, //滚动的靶子

apiUrl: options.url,

data: options.data || {},

tailload: true,

sucload: true,

totalpage: options.totalpage, //总页数

containArea: options.containArea, //内容区

callback: options.callback

};

var _this = this;

this.oPageLoad.el.onscroll = function () {

var scrollTop = this.scrollTop, //滚动条距最上部的万丈

containHei = _this.oPageLoad.containArea.scrollHeight, //内容惊人(scrollHeight)

clientHei = this.clientHeight; //可视中度

console.log('当前线总指挥部页数'

  • _this.oPageLoad.totalpage, scrollTop, containHei, clientHei);

    if (_this.oPageLoad.page == _this.oPageLoad.totalpage && containHei - scrollTop - clientHei < 20) { //判别页码是或不是等于总页码且滚动条达到最底部

    if (_this.oPageLoad.tailload) {

_this.loadTxt.innerHTML = "已全部加载成功";

_this.oPageLoad.tailload = !_this.oPageLoad.tailload;

return;

} else {

_this.loadTxt.innerHTML = "已全体加载成功";

return;

}

};

if (containHei - scrollTop

  • clientHei < 20 && _this.oPageLoad.sucload) {

_this.oPageLoad.page++;

_this.oPageLoad.sucload = !_this.oPageLoad.sucload;

_this.loadTxt.innerHTML = "加载中...";

console.log('loading...第' + _this.oPageLoad.page

  • '页');

_this.oPageLoad.data["page"] = _this.oPageLoad.page;

httpGet(_this.oPageLoad.apiUrl, _this.oPageLoad.data, function (data) {//供给加载

commonArray = commonArray.concat(data);

if (pagingLoadOption.containArea

document.getElementById('successList')) {//区分区块分区加载

var $successData = template('success_list', {info: commonArray,timeFormat: timeFormat });

$("#successList").html($successData);

} else {

var $inviteData = template('invite_list', {info: commonArray,timeFormat: timeFormat });

$("#inviteList").html($inviteData);

};

_this.loadTxt.innerHTML = "";

_this.oPageLoad.sucload = !_this.oPageLoad.sucload;

});

};

};

}

/**

* @param {function} 实用函数

* @method => bVersion()决断浏览器内核音信EXP:if(bVersion.iwx)

* @method => getExplore获取浏览器类型和本子,EXP:return Safari:9.0

* @method => toArray(['1','2'],2)仿Array.shift()方法从头顶消灭数组钦点长度并再次来到新数组

* @method => initRun() 依照设备视口clientWidth宽度调治字体大小(基于750px宽度设计稿设置跟成分字体大小20px==1rem)

* @method => getQueryString() 获取url链接中参数对应的值

* @method => setStore(key, value) 本地存款和储蓄key的value

* @method => getStore(key, exp, name) 取存款和储蓄的数码:key[名称]exp[过期日子]name[点名命名的变量]

* @method => hasClass(ele,cls)判定element节点是还是不是留存clasName('cls')

* @method => addClass(ele,cls)在hasClass决断功底上加多clasName('cls')

* @method => removeClass(ele,cls)在hasClass判别底蕴上移除clasName('cls')

* @method => getCookie(name)获取名称叫name的cookie值cookName[0]为键名,cookName[1]为键值

* @method => setCookie(name,value,days)设置过期时间戳expires为days名字为name值为value的cookie

* @method => removeCookie(name)重置过期的cookie就可以移除

* @method => randomColor生成随机颜色#xxxxxx

* @method => randomNum生成内定范围的随机数(min-max)

* @method => isPhoneNum(str)是还是不是为手提式有线电话机号

*/

var utils = {

bVersion: function () {

var u = navigator.userAgent;

return { //移动终端浏览器内核新闻

trident: u.indexOf('Trident') > -1, //IE内核

presto: u.indexOf('Presto') > -1, //opera内核

webKit: u.indexOf('AppleWebKit') > -1, //苹果、Google基本

gecko: u.indexOf('Gecko') > -1 && u.indexOf('KHTML') == -1, //火狐内核

mobile: !!u.match(/AppleWebKit.*Mobile.*/) || !!u.match(/AppleWebKit/), //是或不是为运动终端

ios: !!u.match(/(i[^;]+;( U;)? CPU.+Mac OS X/), //ios终端

android: u.indexOf('Android') > -1 || u.indexOf('Linux') > -1, //android终端大概uc浏览器

iPhone: u.indexOf('iPhone') > -1 || u.indexOf('Mac') > -1, //是否为iPhone或者QQHD浏览器

iPad: u.indexOf('iPad') > -1, //是否iPad

iwx: /MicroMessenger/i.test(u),//是不是Wechat

iWeiBo: /Weibo/i.test(navigator.userAgent)//乐乎顾客端

};

}(),

getExplore: function () {//获取浏览器类型和版本

var sys = {},

ua = navigator.userAgent.toLowerCase(),

s; (s = ua.match(/rv:([d.]+)) like gecko/)) ? sys.ie = s[1] : (s = ua.match(/msie ([d.]+)/)) ? sys.ie = s[1] : (s = ua.match(/edge/([d.]+)/)) ? sys.edge = s[1] : (s = ua.match(/firefox/([d.]+)/)) ? sys.firefox = s[1] : (s = ua.match(/(?:opera|opr).([d.]+)/)) ? sys.opera = s[1] : (s = ua.match(/chrome/([d.]+)/)) ? sys.chrome = s[1] : (s = ua.match(/version/([d.]+).*safari/)) ? sys.safari = s[1] : 0;

// 依照关系实行剖断

if (sys.ie) return ('IE: ' + sys.ie)

if (sys.edge) return ('EDGE: ' + sys.edge)

if (sys.firefox) return ('Firefox: ' + sys.firefox)

if (sys.chrome) return ('Chrome: ' + sys.chrome)

if (sys.opera) return ('Opera: ' + sys.opera)

if (sys.safari) return ('Safari: ' + sys.safari)

return 'Unkonwn'

},

toArray(arr, len) {

len = len || 0;

var i = arr.length

  • len;

    var ret = new Array(i);

    while (i--) {

ret[i] = arr[i + len];

}

console.log(ret);

return ret

},

hasClass: function (ele, cls) {//true||false

return (new RegExp('(\s|^)'

  • cls + '(\s|$)')).test(ele.className);

},

addClass: function (cls) {

if (!hasClass(ele, cls)) {

ele.className += '' + cls;

}

},

removeClass: function (cls) {

if (hasClass(ele, cls)) {

var exp = new RegExp('(\s|^)'

  • cls + '(\s|$)');

ele.className = ele.className.replace(exp, ' ');

}

},

getCookie: function (name) {

var cookArr = document.cookie.replace(/s/g, "").split(';');

for (var i = 0, len = cookArr.length; i < len; i++) {

var cookName = cookArr[i].split('=');

if (cookName[0] == name) {

return decodeURIComponent(cookName[1]);

}

};

return '';

},

setCookie: function (name, value, days) {

var date = new Date();

date.setDate(date.getDate()

  • days);

    document.cookie = name + '=' + value + ';expires='

  • date;

},

removeCookie: function (name) {

//设置过期cookie会自动移除

setCookie(name, '1', -1)

},

randomColor: function () {

return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).slice(- 6);

},

rendomNum: function (min, max) {

return Math.floor(Math.random() * (max - min) + min);

},

isPhoneNum: function (str) {

return /^(0|86|17951)?(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$/.test(str)

},

copy: function (event) {//有选拔性使用

var input = document.createElement('input');

input.type = "text";

input.value = "contain to copy";

event.currentTarget.appendChild(input);

input.select();

document.execCommand('copy', false, null);

},

initRun: function () {//响应式字体大小

var _this = this,

resizeEvt = 'orientationchange' in window ? 'orientationchange' : 'resize';

_this.fontAdapt();

window.onresize = function () {

_this.fontAdapt();

}

},

fontAdapt: function () {//div-width(375px)=>(html(20px)=>1rem)==(html(80px)=>html((80/2)px)=2rem)

var w = document.documentElement.clientWidth,

fz = w * 20 / 375;//375为标准视图宽度,为设计稿宽度/2; 20为自定义根字体像素大小

document.getElementsByTagName(html)[0].style.fontSize = fz + 'px';

},

getQueryString: function (key) { //正则拿到url前边的参数值'?service=&name=name'=>name

const reg = new RegExp("(^|&)"

  • key + "=([^&]*)(&|$)");

    const result = window.location.search.substr(1).match(reg);

    return result ? decodeURIComponent(result[2]) : null;

},

setStore(key, value) { //localStorage存款和储蓄数据 key[名称]value[数据]=>(配合store.min.js使用)

const storeTime = new Date().getTime();

value['setKeyTime'] = storeTime;

store.set(key, value);

},

getStore(key, exp, name) { //取存款和储蓄的数据:key[名称]exp[逾期岁月]name[钦点命名的变量]

const getKeyData = store.get(key);

exp && getKeyData && (new Date().getTime()

  • getKeyData.setKeyTime > exp) && store.remove(key) && (name && (name = store.get(key)));

    return getKeyData;

},

showmsg(msg) {//提示框

const $formMsg = document.getElementById('form-msg');

if ($formMsg == null || $formMsg == "") {

const tipEle = document.createElement("div");

tipEle.className = "tc form-msg";

tipEle.id = "form-msg";

tipEle.innerHTML = msg;

document.body.appendChild(tipEle);

} else {

$formMsg.style.display = "block";

$formMsg.innerHTML = msg;

}

setTimeout(() => {

document.getElementById('form-msg').style.display = "none";

}, 1000);

}

}

utils.initRun();

/**

* localStorage包容性管理

*/

if (!window.localStorage) {

Object.defineProperty(window, "localStorage", new (function () {

var aKeys = [], oStorage = {};

Object.defineProperty(oStorage, "getItem", {

value: function (sKey) { return sKey ? this[sKey] : null; },

writable: false,

configurable: false,

enumerable: false

});

Object.defineProperty(oStorage, "key", {

value: function (nKeyId) { return aKeys[nKeyId]; },

writable: false,

configurable: false,

enumerable: false

});

Object.defineProperty(oStorage, "setItem", {

value: function (sKey, sValue) {

if (!sKey) { return; }

document.cookie = escape(sKey) + "="

  • escape(sValue) + "; path=/";

},

writable: false,

configurable: false,

enumerable: false

});

Object.defineProperty(oStorage, "length", {

get: function () { return aKeys.length; },

configurable: false,

enumerable: false

});

Object.defineProperty(oStorage, "removeItem", {

value: function (sKey) {

if (!sKey) { return; }

var sExpDate = new Date();

sExpDate.setDate(sExpDate.getDate()

  • 1);

    document.cookie = escape(sKey) + "=; expires=" + sExpDate.toGMTString()

  • "; path=/";

},

writable: false,

configurable: false,

enumerable: false

});

this.get = function () {

var iThisIndx;

for (var sKey in oStorage) {

iThisIndx = aKeys.indexOf(sKey);

if (iThisIndx === -1) { oStorage.setItem(sKey, oStorage[sKey]); }

else { aKeys.splice(iThisIndx, 1); }

delete oStorage[sKey];

}

for (aKeys; aKeys.length > 0; aKeys.splice(0, 1)) { oStorage.removeItem(aKeys[0]); }

for (var iCouple, iKey,

iCouplId = 0, aCouples

document.cookie.split(/s*;s*/); iCouplId < aCouples.length; iCouplId++) {

iCouple = aCouples[iCouplId].split(/s*=s*/);

if (iCouple.length > 1) {

oStorage[iKey = unescape(iCouple[0])] = unescape(iCouple[1]);

aKeys.push(iKey);

}

}

return oStorage;

};

this.configurable = false;

this.enumerable = true;

})());

} else {

return window.localStorage

}

/**

* 原生js仿jq常用API操作DOM

* @type {Object}

* @method $(".selector").method()

* @method {.css}=>$(".selector").css({Obj})

* @return this

*/

//$ selector

function $(selector) {

return document.querySelector(selector)

}

//hide()

Object.prototype.hide = function () {

this.style.display = "none";

return this;

};

//show()

Object.prototype.show = function () {

this.style.display = "block";

return this;

};

//hasClass()

Object.prototype.hasClass = function (cName) {

return !!this.className.match(new RegExp("(\s|^)"

  • cName + "(\s|$)"));

}

//addClass()

Object.prototype.addClass = function (cName) {

if (!this.hasClass(cName)) {

this.className += " " + cName;

}

return this;

}

//removeClass()

Object.prototype.removeClass = function (cName) {

if (this.hasClass(cName)) {

this.className = this.className.replace(new RegExp("(\s|^)"

  • cName + "(\s|$)"), " ");

}

return this;

}

//parent()

Object.prototype.parent = function () {

return this.parentNode;

}

//next()

Object.prototype.next = function () {

return this.nextElementSibling;

}

//prev()

Object.prototype.prev = function () {

return this.previousElementSibling;

}

//siblings()

Object.prototype.siblings = function () {

var chid = this.parentNode.children;

var eleMatch = [];

for (var i = 0, l = chid.length; i < l; i++) {

if (chid[i] != this) {

eleMatch.push(chid[i]);

}

}

return eleMatch;

}

//css()

Object.prototype.css = function (cssObj) {

var cssStr = '';

function objToCssStr(cssObj) {

for (var k in cssObj) {

cssStr += k + ':' + cssObj[k] + ';'

};

return cssStr

};

this.style.cssText = objToCssStr(cssObj);

}

/**

* @desc 剖断原生类型

* @return {Boolean}

*/

function isObject(obj) {//Object or not

return Object.prototype.toString.call(obj) === '[object Object]'

}

function isNumber(num) {//Number or not

return Object.prototype.toString.call(num) === '[object Number]'

}

function isString(str) {//String or not

return Object.prototype.toString.call(str) === '[object String]'

}

function isArray(arr) {//Array or not

return Object.prototype.toString.call(arr) === '[object Array]'

}

function isBoolean(boolean) {//Boolean or not

return Object.prototype.toString.call(boolean) === '[object Boolean]'

}

function isFunction(fn) {//Function or not

return Object.prototype.toString.call(fn) === '[object Function]'

}

function isRegExp(reg) {//RegExp or not

return Object.prototype.toString.call(reg) === '[object RegExp]'

}

function looseEqual(a, b) {//check two parameter is looslyEqual or not(===)

if (a === b) { return true }

var isObjectA = isObject(a);

var isObjectB = isObject(b);

if (isObjectA && isObjectB) {

try {

var isArrayA = Array.isArray(a);

var isArrayB = Array.isArray(b);

if (isArrayA && isArrayB) {

return a.length === b.length && a.every(function (e, i) {

return looseEqual(e, b[i])

})

} else if (!isArrayA && !isArrayB) {

var keysA = Object.keys(a);

var keysB = Object.keys(b);

return keysA.length === keysB.length && keysA.every(function (key) {

return looseEqual(a[key], b[key])

})

} else {

/* istanbul ignore next */

return false

}

} catch (e) {

/* istanbul ignore next */

return false

}

} else if (!isObjectA && !isObjectB) {

return String(a) === String(b)

} else {

return false

}

};

本文由金沙棋牌发布于金沙棋牌官方平台,转载请注明出处:自己收集的工作js库,ES6的十个新特性

关键词: