云顶娱乐-云顶娱乐游戏平台官网
做最好的网站
当前位置: 云顶娱乐 > 云顶娱乐 > 正文

CSS3弹性伸缩布局,轻便阴毒地通晓

时间:2019-10-05 16:40来源:云顶娱乐
4)原型格局 //4.原型情势,间接定义prototype属性 function Person () {}Person.prototype.name = '杰克'; Person.prototype.age = 18;Person.prototype.sayName = function () { alert(this.name); };//4.原型形式,字面量定义方

4)原型格局

//4.原型情势,间接定义prototype属性 function Person () {} Person.prototype.name = '杰克'; Person.prototype.age = 18; Person.prototype.sayName = function () { alert(this.name); }; //4.原型形式,字面量定义方式 function Person () {} Person.prototype = { name: '杰克', age: 18, sayName: function () { alert(this.name); } }; var p1 = new Person(); //name='杰克' var p2 = new Person(); //name='杰克'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//4.原型模式,直接定义prototype属性
function Person () {}
Person.prototype.name = 'Jack';
Person.prototype.age = 18;
Person.prototype.sayName = function () { alert(this.name); };
//4.原型模式,字面量定义方式
function Person () {}
Person.prototype = {
    name: 'Jack',
    age: 18,
    sayName: function () { alert(this.name); }
};
var p1 = new Person(); //name='Jack'
var p2 = new Person(); //name='Jack'

此间须要小心的是原型属性和格局的分享,即怀有实例中都只是引用原型中的属性方法,任何四个地方产生的转移会唤起别的实例的转移。

有关小编:chokcoco

云顶娱乐 1

经不住小运似水,逃不过此间少年。 个人主页 · 小编的篇章 · 63 ·    

云顶娱乐 2

CORS跨域及WebService的支持

先来看贰个例子,大家新建三个中坚的html页面,在其中编写贰个简便的是或不是支持跨域的小本子,如下:

XHTML

<html xmlns="; <head> <title>AJAX跨域哀告测验</title> </head> <body> <input type='button' value='开始测验' onclick='crossDomainRequest()' /> <div id="content"></div> <script type="text/javascript"> //<![CDATA[ var xhr = new XMLHttpRequest(); var url = ''; function crossDomainRequest() { document.getElementById("content").innerHTML = "起先……"; if (xhr) { xhr.open('POST', url, true); xhr.onreadystatechange = handler; xhr.send(); } else { document.getElementById("content").innerHTML = "不可能创造 XMLHttpRequest"; } } function handler(evtXH奥德赛) { if (xhr.readyState == 4) { if (xhr.status == 200) { var response = xhr.responseText; document.getElementById("content").innerHTML = "结果:" + response; } else { document.getElementById("content").innerHTML = "不一致意跨域央求。"; } } else { document.getElementById("content").innerHTML += "<br/>执增势况 readyState:" + xhr.readyState; } } //]]> </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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>AJAX跨域请求测试</title>
</head>
<body>
  <input type='button' value='开始测试' onclick='crossDomainRequest()' />
  <div id="content"></div>
 
  <script type="text/javascript">
    //<![CDATA[
    var xhr = new XMLHttpRequest();
    var url = 'http://localhost:8078/json/ShopUserLogin';
    function crossDomainRequest() {
      document.getElementById("content").innerHTML = "开始……";
      if (xhr) {
        xhr.open('POST', url, true);
        xhr.onreadystatechange = handler;
        xhr.send();
      } else {
        document.getElementById("content").innerHTML = "不能创建 XMLHttpRequest";
      }
    }
 
    function handler(evtXHR) {
      if (xhr.readyState == 4) {
        if (xhr.status == 200) {
          var response = xhr.responseText;
          document.getElementById("content").innerHTML = "结果:" + response;
        } else {
          document.getElementById("content").innerHTML = "不允许跨域请求。";
        }
      }
      else {
        document.getElementById("content").innerHTML += "<br/>执行状态 readyState:" + xhr.readyState;
      }
    }
    //]]>
  </script>
 
</body>
</html>

下一场保留为本地html文件,能够看来,那几个剧本中,对地方的劳务 发起了二个伸手, 假诺使用chrome 直接张开,拜候到输出的结果,不容许跨域央浼。 在javascript调节台程序中一致可以看来错误提醒:

云顶娱乐 3

那就是说只要在回来响应头header中流入Access-Control-Allow-Origin,那样浏览器检测到header中的Access-Control-Allow-Origin,则就足以跨域操作了。

同一,倘诺应用ServcieStack,在广大地点能够支撑COPAJEROS的跨域格局。最简便的依旧在AppHost的Configure函数里面平昔写入:

JavaScript

/// <summary> /// Application specific configuration /// This method should initialize any IoC resources utilized by your web service classes. /// </summary> /// <param name="container"></param> public override void Configure(Container container) { this.AddPlugin(new CorsFeature()); }

1
2
3
4
5
6
7
8
9
/// &lt;summary&gt;
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// &lt;/summary&gt;
/// &lt;param name=&quot;container&quot;&gt;&lt;/param&gt;
public override void Configure(Container container)
{
    this.AddPlugin(new CorsFeature());
}

如此就足以了,也正是采用默许的COTiguanS配置:

JavaScript

CorsFeature(allowedOrigins:"*", allowedMethods:"GET, POST, PUT, DELETE, OPTIONS", allowedHeaders:"Content-Type", allowCredentials:false);

1
2
3
4
CorsFeature(allowedOrigins:&quot;*&quot;,
allowedMethods:&quot;GET, POST, PUT, DELETE, OPTIONS&quot;,
allowedHeaders:&quot;Content-Type&quot;,
allowCredentials:false);

若是单独允许GET和POST的乞求辅助CO景逸SUVS,则只必要改为:

JavaScript

Plugins.Add(new CorsFeature(allowedMethods: "GET, POST"));

1
Plugins.Add(new CorsFeature(allowedMethods: &quot;GET, POST&quot;));

当然也得以在AppHost的Config里面安装全局的CO凯雷德S,如下:

JavaScript

/// <summary> /// Application specific configuration /// This method should initialize any IoC resources utilized by your web service classes. /// </summary> /// <param name="container"></param> public override void Configure(Container container) { base.SetConfig(new EndpointHostConfig { GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" }, { "Access-Control-Allow-Headers", "Content-Type" }, }, }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/// &lt;summary&gt;
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// &lt;/summary&gt;
/// &lt;param name=&quot;container&quot;&gt;&lt;/param&gt;
public override void Configure(Container container)
{
 
    base.SetConfig(new EndpointHostConfig
    {
        GlobalResponseHeaders = {
            { &quot;Access-Control-Allow-Origin&quot;, &quot;*&quot; },
            { &quot;Access-Control-Allow-Methods&quot;, &quot;GET, POST, PUT, DELETE, OPTIONS&quot; },
            { &quot;Access-Control-Allow-Headers&quot;, &quot;Content-Type&quot; },
                },
    });
}

今昔运转WebService,使用postman只怕Chrome调用那一个乞请,能够看来重返的值头文件中,已经增进了响应头,而且能够健康显示重临结果了:

云顶娱乐 4

CO奥德赛S使用起来轻便,没有须要客商端的额外管理,而且支持Post的艺术交给央浼,但是CO宝马X5S的独一三个弱点是对客商端的浏览器版本有须求,支持CO纳瓦拉S的浏览器机器版本如下:

云顶娱乐 5

 

JavaScript 的 this 原理

2018/06/19 · JavaScriptCSS3弹性伸缩布局,轻便阴毒地通晓。 · this

原稿出处: 阮一峰   

flex-direction属性

flex-direction属性用于安装伸缩项指标排列方式。

CSS

div{ display:flex; flex-direction:column; }

1
2
3
4
div{
    display:flex;
    flex-direction:column;
}

意义如下:

云顶娱乐 6

结果正是容器内的富有类型按照从上到下排列的。

当你设置为row-reverse时,效果便是:

云顶娱乐 7

本条是从浏览器的左边往左侧排列的。

此属性的属性值有:

  • row : 设置从左到右排列
  • row-reverse : 设置从右到左排列
  • column : 设置从上到下排列
  • column-reverse : 设置从下到上排列

大家无妨都试一下,看看每三个的职能如何。

小结


说了那般多,其实大旨唯有多个:属性分享和单独的支配,当您的靶子实例供给单独的习性,全部做法的真相都以在指标实例之中创设属性。若不思虑太多,你大能够在Person里面一贯定义你所急需单独的性质来覆盖掉原型的习性。不问可见,使用原型承继的时候,要对此原型中的属性要特别注意,因为她们都以一着不慎满盘皆输的存在。

上边轻松罗列下js中创制对象的各个情势,今后最常用的措施是整合情势,熟识的同桌能够跳过到小说末尾点赞了。

打赏扶助自个儿写出更加的多好小说,多谢!

任选一种支付格局

云顶娱乐 8 云顶娱乐 9

2 赞 16 收藏 4 评论

浅谈跨域以WebService对跨域的支撑

2015/04/03 · HTML5, JavaScript · WebService, 跨域

原作出处: 寒江独钓   

跨域难点来自JavaScript的同源战术,即唯有 公约+主机名+端口号 (如存在)同样,则允许相互访谈。也正是说JavaScript只可以访问和操作本人域下的财富,不可能访谈和操作别的域下的财富。

在在此此前,前端和后端混杂在一道, 比方JavaScript直接调用同系统里面包车型客车贰个Httphandler,就不设有跨域的主题材料,不过随着今世的这种二种顾客端的风靡,举个例子贰个施用常常会有Web端,App端,以及WebApp端,各样客商端平日会利用同一套的后台管理逻辑,即API, 前后端分离的开销政策流行起来,前端只关注表现,平日选用JavaScript,后端管理逻辑和数据常常选拔WebService来提供json数据。平日的前端页面和后端的Web瑟维斯API平时安顿在分裂的服务器恐怕域名上。那样,通过ajax央浼WebService的时候,就能够现出同源攻略的主题素材。

内需证实的是,同源计谋是JavaScript里面包车型的士限制,其余的编制程序语言,举例在C#,Java只怕iOS等另外语言中是能够调用外界的WebService,相当于说,假使开荒Native应用,是荒诞不经那一个主题材料的,可是一旦开荒Web或许Html5如WebApp,常常采纳JavaScript ajax对WebService发起呼吁然后分析再次回到的值,那样就或然存在跨域的主题素材。

相似的,很轻易想到,将表面的财富搬到同叁个域上就可以一蹴而就同源战术的界定的。即在Web网址上同一时间支付贰个Http服务端页面,全体JavaScript的哀告都发到那个页面上来,这一个页面在其间使用其余语言去调用外界的WebService。即增添叁个代理层。这种艺术得以消除难点,但是相当不足直接和飞跃。

当前,比较广泛的跨域实施方案包含JSONP (JSON with padding)和CORS (Cross-origin resource sharing )。一些解决方案需求顾客端和服务端合营如JSOP,一些则只要求服务端合营管理例如CO奥迪Q5S。上边分别介绍那二种跨域方案,以及劳动端WebService怎样帮衬这两种跨域方案。

二、内部存款和储蓄器的数据结构

JavaScript 语言之所以有this云顶娱乐 ,的规划,跟内部存储器里面的数据结构有提到。

var obj = { foo: 5 };

1
var obj = { foo:  5 };

地点的代码将二个对象赋值给变量obj。JavaScript 引擎会先在内部存储器里面,生成三个指标{ foo: 5 },然后把那个目的的内部存款和储蓄器地址赋值给变量obj

云顶娱乐 10

也便是说,变量obj是三个地方(reference)。前面假如要读取obj.foo,引擎先从obj得到内部存款和储蓄器地址,然后再从该地点读出原始的靶子,重临它的foo属性。

原来的靶子以字典结构保留,每贰天品质名都对应两个性能描述对象。譬如来讲,上边例子的foo属性,实际上是以下边包车型大巴款型保留的。

云顶娱乐 11

{ foo: { [[value]]: 5 [[writable]]: true [[enumerable]]: true [[configurable]]: true } }

1
2
3
4
5
6
7
8
{
  foo: {
    [[value]]: 5
    [[writable]]: true
    [[enumerable]]: true
    [[configurable]]: true
  }
}

注意,foo特性的值保存在属性描述对象的value天性之中。

order属性

order 属性和旧版本的box-ordinal-group 属性同样调控伸缩项目出现的逐个。

CSS

p:nth-child(1) { order: 2; } p:nth-child(2) { order: 3; } p:nth-child(3) { order: 1; }

1
2
3
4
5
6
7
8
9
p:nth-child(1) {
    order: 2;
}
p:nth-child(2) {
    order: 3;
}
p:nth-child(3) {
    order: 1;
}

意义如下:

云顶娱乐 12

1)组合承袭

function Mother (age) { this.age = age; this.hobby = ['running','football'] } Mother.prototype.showAge = function () { console.log(this.age); }; function Person (name, age) { Mother.call(this, age);  //第二遍实行 this.name = name; } Person.prototype = new Mother();  //首回施行Person.prototype.constructor = Person; Person.prototype.showName = function () { console.log(this.name); } var p1 = new Person('杰克', 20); p1.hobby.push('basketball'); //p1:'杰克'; __proto__:20,['running','football'] var p2 = new Person('Mark', 18); //p2:'Mark'; __proto__:18,['running','football']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
function Mother (age) {
    this.age = age;
    this.hobby = ['running','football']
}
Mother.prototype.showAge = function () {
    console.log(this.age);
};
 
function Person (name, age) {
    Mother.call(this, age);  //第二次执行
    this.name = name;
}
Person.prototype = new Mother();  //第一次执行
Person.prototype.constructor = Person;
Person.prototype.showName = function () {
    console.log(this.name);
}
 
var p1 = new Person('Jack', 20);
p1.hobby.push('basketball');  //p1:'Jack'; __proto__:20,['running','football']
var p2 = new Person('Mark', 18);  //p2:'Mark'; __proto__:18,['running','football']

结果是酱紫的:

云顶娱乐 13  云顶娱乐 14

此地首先次实践的时候,获得 Person.prototype.age = undefined, Person.prototype.hobby = [‘running’,’football’],第二遍执行也等于 var p1 = new Person(‘杰克’, 20) 的时候,获得 p1.age =20, p1.hobby = [‘running’,’football’],push后就改为了 p1.hobby = [‘running’,’football’, ‘basketball’]。其实分辨好 this 的转移,领会起来也是对比简单的,把 this 不难替换一下就会获得那一个结果了。 假设以为精晓起来相比绕的话,试着把脑筋里面包车型客车定义扔掉吗,把温馨当浏览器从上到下实施一次代码,结果是还是不是就出来了吧?

通过第三次施行原型的构造函数 Mother(),大家在目的实例中复制了一份原型的质量,那样就变成了与原型属性的分开独立。留神的您会开掘,大家首先次调用 Mother(),好像什么用都不曾啊,能不调用他吧?可以,就有了上边包车型地铁寄生组合式承继。

深入显出妙用 Javascript 中 apply、call、bind

2015/09/24 · JavaScript · 4 评论 · apply, bind, call

本文作者: 伯乐在线 - chokcoco 。未经作者许可,制止转发!
招待参加伯乐在线 专辑小编。

这篇小说实在是很难下笔,因为英特网有关文章看不完。

偶合的是明日见到阮老师的一篇小说的一句话:

“对本人的话,博客首先是一种知识管理工科具,其次才是流传工具。我的技术小说,首要用来收拾自身还不懂的学识。小编只写那二个自身还平昔不完全调节的事物,那多少个自身精通的事物,往往未有动力写。炫人眼目未有是自家的遐思,好奇才是。”

对于这句话,不能扶助越来越多,也让自家下决心好好写那篇,英特网文章虽多,大多复制粘贴,且晦涩难懂,小编梦想能够因而那篇小说,能够清楚的升级对apply、call、bind的认知,何况列出部分它们的妙用加深记念。

   apply、call

在 javascript 中,call 和 apply 皆感到着改动有个别函数运维时的上下文(context)而留存的,换句话说,正是为着改变函数体内部 this 的针对。

JavaScript 的一大特征是,函数存在「定义时上下文」和「运行时上下文」以及「上下文是能够更换的」这样的概念。

先来一个榛子:

JavaScript

function fruits() {} fruits.prototype = { color: "red", say: function() { console.log("My color is " + this.color); } } var apple = new fruits; apple.say(); //My color is red

1
2
3
4
5
6
7
8
9
10
11
function fruits() {}
 
fruits.prototype = {
    color: "red",
    say: function() {
        console.log("My color is " + this.color);
    }
}
 
var apple = new fruits;
apple.say();    //My color is red

但是假若大家有三个目的banana= {color : “yellow”} ,我们不想对它再一次定义 say 方法,那么大家得以因而 call 或 apply 用 apple 的 say 方法:

JavaScript

banana = { color: "yellow" } apple.say.call(banana); //My color is yellow apple.say.apply(banana); //My color is yellow

1
2
3
4
5
banana = {
    color: "yellow"
}
apple.say.call(banana);     //My color is yellow
apple.say.apply(banana);    //My color is yellow

就此,能够看来 call 和 apply 是为了动态改造 this 而出现的,当三个 object 未有某些方法(本栗子中banana没有say方法),可是任何的有(本栗子中apple有say方法),大家能够依据call或apply用别样对象的主意来操作。

apply、call 的区别

对此 apply、call 二者来讲,功用完全等同,只是接受参数的方式不太一致。举例,有多少个函数定义如下:

JavaScript

var func = function(arg1, arg2) { };

1
2
3
var func = function(arg1, arg2) {
 
};

就能够透过如下格局来调用:

JavaScript

func.call(this, arg1, arg2); func.apply(this, [arg1, arg2])

1
2
func.call(this, arg1, arg2);
func.apply(this, [arg1, arg2])

个中 this 是您想钦命的上下文,他得以是其他三个 JavaScript 对象(JavaScript 中总体皆对象),call 须要把参数按梯次传递步入,而 apply 则是把参数放在数组里。

JavaScript 中,有些函数的参数数量是不稳固的,因而要说适用原则的话,当你的参数是举世出名精晓数码时用 call 。

而不分明的时候用 apply,然后把参数 push 进数组传递步向。当参数数量不确按期,函数内部也可以因此 arguments 这些数组来遍历全体的参数。

为了加固深化回想,下边罗列部分常用用法:

1、数组之间追加

JavaScript

var array1 = [12 , "foo" , {name "Joe"} , -2458]; var array2 = ["Doe" , 555 , 100]; Array.prototype.push.apply(array1, array2); /* array1 值为 [12 , "foo" , {name "Joe"} , -2458 , "Doe" , 555 , 100] */

1
2
3
4
var array1 = [12 , "foo" , {name "Joe"} , -2458];
var array2 = ["Doe" , 555 , 100];
Array.prototype.push.apply(array1, array2);
/* array1 值为  [12 , "foo" , {name "Joe"} , -2458 , "Doe" , 555 , 100] */

2、获取数组中的最大值和最小值

JavaScript

var numbers = [5, 458 , 120 , -215 ]; var maxInNumbers = Math.max.apply(Math, numbers), //458 maxInNumbers = Math.max.call(Math,5, 458 , 120 , -215); //458

1
2
3
var  numbers = [5, 458 , 120 , -215 ];
var maxInNumbers = Math.max.apply(Math, numbers),   //458
    maxInNumbers = Math.max.call(Math,5, 458 , 120 , -215); //458

number 本人并未有 max 方法,但是 Math 有,大家就能够依赖 call 或然 apply 使用其情势。

3、验证是还是不是是数组(前提是toString()方法未有被重写过)

JavaScript

functionisArray(obj){ returnObject.prototype.toString.call(obj) === '[object Array]' ; }

1
2
3
functionisArray(obj){
    returnObject.prototype.toString.call(obj) === '[object Array]' ;
}

4、类(伪)数组使用数组方法

JavaScript

var domNodes = Array.prototype.slice.call(document.getElementsByTagName("*"));

1
var domNodes = Array.prototype.slice.call(document.getElementsByTagName("*"));

Javascript中存在一种名称为伪数组的目的组织。比较极度的是 arguments 对象,还恐怕有像调用 getElementsByTagName , document.childNodes 之类的,它们重回NodeList对象都属于伪数组。无法利用 Array下的 push , pop 等办法。

然而我们能由此 Array.prototype.slice.call 调换为真正的数组的带有 length 属性的对象,那样 domNodes 就足以行使 Array 下的保有办法了。

深远精通运用apply、call

下面就借用一道面课题,来更透顶的去领会下 apply 和 call 。

概念多少个 log 方法,让它能够代办 console.log 方法,常见的消除办法是:

JavaScript

function log(msg) { console.log(msg); } log(1); //1 log(1,2); //1

1
2
3
4
5
function log(msg) {
  console.log(msg);
}
log(1);    //1
log(1,2);    //1

地点方法能够化解最中央的供给,不过当传入参数的个数是不分明的时候,上边包车型地铁不二法门就失效了,那年就能够虚构使用 apply 只怕call,注意这里传出多少个参数是不明确的,所以接纳apply是最棒的,方法如下:

JavaScript

function log(){ console.log.apply(console, arguments); }; log(1); //1 log(1,2); //1 2

1
2
3
4
5
function log(){
  console.log.apply(console, arguments);
};
log(1);    //1
log(1,2);    //1 2

接下去的渴求是给每一个 log 新闻加多三个”(app)”的前辍,例如:

JavaScript

log("hello world"); //(app)hello world

1
log("hello world");    //(app)hello world

该如何是好比较文雅呢?这年需求想到arguments参数是个伪数组,通过 Array.prototype.slice.call 转化为专门的学业数组,再利用数组方法unshift,像那样:

JavaScript

function log(){ var args = Array.prototype.slice.call(arguments); args.unshift('(app)'); console.log.apply(console, args); };

1
2
3
4
5
6
function log(){
  var args = Array.prototype.slice.call(arguments);
  args.unshift('(app)');
 
  console.log.apply(console, args);
};

bind

说罢了 apply 和 call ,再来讲说bind。bind() 方法与 apply 和 call 很相像,也是能够更改函数体内 this 的对准。

MDN的分解是:bind()方法会创制三个新函数,称为绑定函数,当调用这几个绑定函数时,绑定函数会以创制它时传出 bind()方法的率先个参数作为 this,传入 bind() 方法的第1个以及之后的参数加上绑定函数运营时自身的参数依据顺序作为原函数的参数来调用原函数。

一向来拜谒具体什么运用,在相近的单人体模型式中,日常我们会动用 _this , that , self 等保存 this ,那样大家得以在改变了上下文之后持续援用到它。 像那样:

JavaScript

var foo = { bar : 1, eventBind: function(){ var _this = this; $('.someClass').on('click',function(event) { /* Act on the event */ console.log(_this.bar); //1 }); } }

1
2
3
4
5
6
7
8
9
10
var foo = {
    bar : 1,
    eventBind: function(){
        var _this = this;
        $('.someClass').on('click',function(event) {
            /* Act on the event */
            console.log(_this.bar);     //1
        });
    }
}

是因为 Javascript 特有的体制,上下文蒙受在 eventBind:function(){ } 过渡到 $(‘.someClass’).on(‘click’,function(event) { }) 发生了改观,上述使用变量保存 this 这一个点子都以一蹴而就的,也不曾怎么难点。当然使用 bind() 能够进一步高雅的缓和那几个难题:

JavaScript

var foo = { bar : 1, eventBind: function(){ $('.someClass').on('click',function(event) { /* Act on the event */ console.log(this.bar); //1 }.bind(this)); } }

1
2
3
4
5
6
7
8
9
var foo = {
    bar : 1,
    eventBind: function(){
        $('.someClass').on('click',function(event) {
            /* Act on the event */
            console.log(this.bar);      //1
        }.bind(this));
    }
}

在上述代码里,bind() 创设了一个函数,当那几个click事件绑定在被调用的时候,它的 this 关键词会被设置成被盛传的值(这里指调用bind()时传出的参数)。因而,这里我们传入想要的上下文 this(其实正是 foo ),到 bind() 函数中。然后,当回调函数被实行的时候, this 便指向 foo 对象。再来二个简单的栗子:

JavaScript

var bar = function(){ console.log(this.x); } bar(); // undefined var func = bar.bind(foo); func(); // 3

1
2
3
4
5
6
7
var bar = function(){
    console.log(this.x);
}
 
bar(); // undefined
var func = bar.bind(foo);
func(); // 3

此处大家创立了八个新的函数 func,当使用 bind() 创立多个绑定函数之后,它被实行的时候,它的 this 会被设置成 foo , 并非像大家调用 bar() 时的大局作用域。

有个风趣的问题,假如一连 bind() 五遍,亦或许是接二连三 bind() 三回那么输出的值是怎么啊?像那样:

JavaScript

var bar = function(){ console.log(this.x); } var foo = { x:3 } var sed = { x:4 } var func = bar.bind(foo).bind(sed); func(); //? var fiv = { x:5 } var func = bar.bind(foo).bind(sed).bind(fiv); func(); //?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var bar = function(){
    console.log(this.x);
}
var foo = {
    x:3
}
var sed = {
    x:4
}
var func = bar.bind(foo).bind(sed);
func(); //?
 
var fiv = {
    x:5
}
var func = bar.bind(foo).bind(sed).bind(fiv);
func(); //?

答案是,四遍都仍将出口 3 ,而非期望中的 4 和 5 。原因是,在Javascript中,多次 bind() 是于事无补的。更加深档期的顺序的开始和结果, bind() 的兑现,也便是接纳函数在其间包了三个 call / apply ,第壹次 bind() 相当于再包住第四回 bind() ,故第壹遍之后的 bind 是无计可施生效的。

apply、call、bind比较

那么 apply、call、bind 三者相相比,之间又有何异同呢?什么时候使用 apply、call,何时使用 bind 呢。轻易的贰个尖栗:

JavaScript

var obj = { x: 81, }; var foo = { getX: function() { return this.x; } } console.log(foo.getX.bind(obj)()); //81 console.log(foo.getX.call(obj)); //81 console.log(foo.getX.apply(obj)); //81

1
2
3
4
5
6
7
8
9
10
11
12
13
var obj = {
    x: 81,
};
 
var foo = {
    getX: function() {
        return this.x;
    }
}
 
console.log(foo.getX.bind(obj)());  //81
console.log(foo.getX.call(obj));    //81
console.log(foo.getX.apply(obj));   //81

八个出口的都以81,可是注意看使用 bind() 方法的,他前面多了对括号。

也正是说,差异是,当你期待更动上下文情形之后不要立即实行,而是回调推行的时候,使用 bind() 方法。而 apply/call 则会立时试行函数。

再总计一下:

  • apply 、 call 、bind 三者都是用来改换函数的this对象的针对性的;
  • apply 、 call 、bind 三者第三个参数都以this要对准的目的,也正是想钦定的上下文;
  • apply 、 call 、bind 三者都足以应用一而再参数字传送参;
  • bind 是重临对应函数,便于稍后调用;apply 、call 则是当下调用 。

正文实例出现的兼具代码,在自笔者的github上能够下载。

打赏支持本身写出更多好小说,多谢!

打赏作者

JSONP以及WebService的支持

同源计策下,有个别服务器是爱莫能助赢获得服务器以外的数量,可是html里面包车型地铁img,iframe和script等标签是个不等,这个标签能够经过src属性央求到别的服务器上的数额。而JSONP便是通过script节点src调用跨域的央浼。

当我们向服务器交由多个JSONP的伏乞时,大家给劳务传了多个不相同平常的参数,告诉服务端要对结果特别管理一下。那样服务端重临的多寡就博览会开一些装进,客商端就能够拍卖。

举个例子,服务端和客商端约定要传一个名称叫callback的参数来利用JSONP作用。比方央浼的参数如下:

JavaScript

1
http://www.example.net/sample.aspx?callback=mycallback

只要未有后边的callback参数,即不行使JSONP的情势,该服务的回来结果或许是叁个一味的json字符串,比方:

JavaScript

{ foo : 'bar' }

1
{ foo : &#039;bar&#039; }

要是和劳动端约定jsonp格式,那么服务端就能够管理callback的参数,将重回结果实行一下甩卖,比方拍卖成:

JavaScript

mycallback({ foo : 'bar' })

1
mycallback({ foo : &#039;bar&#039; })

可以看看,那实质上是二个函数调用,比如能够兑今后页面定义二个名字为mycallback的回调函数:

JavaScript

mycallback = function(data) { alert(data.foo); };

1
2
3
4
mycallback = function(data)
         {
            alert(data.foo);
         };

到现在,央求的重返值回去触发回调函数,这样就完了了跨域需要。

假使选拔ServiceStack创造WebService的话,援助Jsonp方式的调用很简单,只须求在AppHost的Configure函数里面注册一下对响应结果开展过滤管理就可以。

JavaScript

/// <summary> /// Application specific configuration /// This method should initialize any IoC resources utilized by your web service classes. /// </summary> /// <param name="container"></param> public override void Configure(Container container) { ResponseFilters.Add((req, res, dto) => { var func = req.QueryString.Get("callback"); if (!func.isNullOrEmpty()) { res.AddHeader("Content-Type", ContentType.Html); res.Write("<script type='text/javascript'>{0}({1});</script>" .FormatWith(func, dto.ToJson())); res.Close(); } }); }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/// &lt;summary&gt;
        /// Application specific configuration
        /// This method should initialize any IoC resources utilized by your web service classes.
        /// &lt;/summary&gt;
        /// &lt;param name=&quot;container&quot;&gt;&lt;/param&gt;
        public override void Configure(Container container)
        {
            ResponseFilters.Add((req, res, dto) =&gt;
            {
                var func = req.QueryString.Get(&quot;callback&quot;);
                if (!func.isNullOrEmpty())
                {
                    res.AddHeader(&quot;Content-Type&quot;, ContentType.Html);
                    res.Write(&quot;&lt;script type=&#039;text/javascript&#039;&gt;{0}({1});&lt;/script&gt;&quot;
                        .FormatWith(func, dto.ToJson()));
                    res.Close();
                }
            });
        }

JSONP跨域格局相比平价,也支撑各类较老的浏览器,然则劣点很醒目,他只支持GET的方法交给,不扶助别的Post的交付,Get格局对央浼的参数长度有限定,在有一点意况下或然不满意须求。所以上面就介绍一下COENVISIONS的跨域建设方案。

三、函数

那般的布局是很明显的,难点在于属性的值大概是一个函数。

var obj = { foo: function () {} };

1
var obj = { foo: function () {} };

此刻,引擎会将函数单独保存在内部存储器中,然后再将函数的地点赋值给foo属性的value属性。

云顶娱乐 15

{ foo: { [[value]]: 函数的地址 ... } }

1
2
3
4
5
6
{
  foo: {
    [[value]]: 函数的地址
    ...
  }
}

出于函数是贰个独门的值,所以它能够在差异的条件(上下文)实践。

var f = function () {}; var obj = { f: f }; // 单独实施 f() // obj 情形进行 obj.f()

1
2
3
4
5
6
7
8
var f = function () {};
var obj = { f: f };
 
// 单独执行
f()
 
// obj 环境执行
obj.f()

最后

在此间本人推荐一下阮一峰写的两篇关于flex布局的博客,写得不行好:

编辑:云顶娱乐 本文来源:CSS3弹性伸缩布局,轻便阴毒地通晓

关键词: