- 浏览: 1162728 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
zhizhen23:
LZ 提供的链接地址失效了
重写的isPlainObject方法 -
LovingBaby:
LovingBaby 写道function fun() {}f ...
读jq之二(两种扩展) -
LovingBaby:
说的很清楚!jQuery作者为了实现简洁调用的苦心!高超的编程 ...
读jq之一(jq对象的组成) -
hard_ly:
...
将伪数组转换成数组 -
zlxzlxzlxzlxzlx:
这不能算是任意进制之间的转换,例如二十六进制、十二进制又该如何 ...
用递归实现十进制数转换N进制
方法链一般适合对一个对象进行连续操作(集中在一句代码)。一定程度上可以减少代码量,缺点是它占用了函数的返回值。
一、方法体内返回对象实例自身(this)
function ClassA(){ this.prop1 = null; this.prop2 = null; this.prop3 = null; } ClassA.prototype = { method1 : function(p1){ this.prop1 = p1; return this; }, method2 : function(p2){ this.prop2 = p2; return this; }, method3 : function(p3){ this.prop3 = p3; return this; } }
定义了function/类ClassA。有三个属性/字段prop1,prop2,prop3,三个方法methed1,method2,method3分别设置prop1,prop2,prop3。
链式调用如下:
var obj = new ClassA(); obj.method1(1).method2(2).method(3); // obj -> prop1=1,prop2=2,prop3=3
可以看到对obj进行了连续三次操作,只要愿意ClassA的N多方法都这样定义,调用链会一直延续。
该方式缺点是链方法唯一地绑定于一种对象类型(ClaaaA),按这种方式实现链式操作,每定义一个类,其方法体中都要返回this。第二种方式可以解决这个问题。
二、对象传入后每次调用返回函数自身
/** * chain 精简版 * @param {Object} obj */ function chain(obj){ return function(){ var Self = arguments.callee; Self.obj = obj; if(arguments.length==0){ return Self.obj; } Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1)); return Self; } } //定义的function/类ClassB function ClassB(){ this.prop1 = null; this.prop2 = null; this.prop3 = null; } ClassB.prototype = { method1 : function(p1){ this.prop1 = p1; }, method2 : function(p2){ this.prop2 = p2; }, method3 : function(p3){ this.prop3 = p3; } }
注意ClassB的method1,method2,method3中不再返回this了。
链式调用如下:
var obj = new ClassB(); chain(obj)('method1',4)('method2',5)('method3',6); // obj -> prop1=4,prop2=5,prop3=6
第一种方式3次调用后返回了对象自身,这里使用一个空"()"取回对象
// result -> prop1=4,prop2=5,prop3=6 var result = chain(obj)('method1',4)('method2',5)('method3',6)();
这种方式写类时方法体中无须返回this,且可以对任何对象进行链式调用。
从写法上总结下两种的调用方式:
obj .method1(arg1) .method2(arg2) .method3(arg3) ... chain(obj) (method1,arg1) (method2,arg2) (method3,arg3) ...
最后,感谢沐海,我是从wee库中获取以上灵感的。
- chain.rar (1 KB)
- 下载次数: 171
评论
21 楼
deepthink
2010-09-07
补充一下,再jquery的weight机制中是默认使用chain的调用样式
举个例子可能说的更加明白:
var tabs = $("#tabs").tabs().tabs("switchTo:,'#tab-1').tabs("method1");
tabs.tabs("switchTo:,'#tab-2').tabs("method1");
weight对象,每一个方法返回的都是 tabs本身,这是LZ所说的第二种方法样式
举个例子可能说的更加明白:
var tabs = $("#tabs").tabs().tabs("switchTo:,'#tab-1').tabs("method1");
tabs.tabs("switchTo:,'#tab-2').tabs("method1");
weight对象,每一个方法返回的都是 tabs本身,这是LZ所说的第二种方法样式
20 楼
deepthink
2010-09-07
笨笨狗 写道
另外,说起这个chaing call,不得不推荐dustin diaz的这篇文章:
Asynchronous method queue chaining in JavaScript
http://www.dustindiaz.com/async-method-queues/
异步链式调用更为有趣,也更为实用:)
Asynchronous method queue chaining in JavaScript
http://www.dustindiaz.com/async-method-queues/
异步链式调用更为有趣,也更为实用:)
这种调用方法很久以前用过,但是不是用的jquery,是用的prototype
19 楼
deepthink
2010-09-07
第一种方法我经常用,有的时候在JAVA中也大量使用,比如构建SQL,URL,或者JSON,或者DataModel 比较繁琐的时候,一般会用
Hql hql = new Hql("from UserInfo o where o.xx = ? ",xx).append("and o.userName = ? and o.yy = ? ",userName,yy) ; return orm().findFirst(hql); new UrlEngine(request).remove("arg1").append("arg2",arg2).append("arg3",arg3).toString() ; new JSONMap().append("k1",val1).appendList("list1").add("list item1").parentMap() new AppDataModel().setEntity(entity).append("user",user).setRows(entity.getDepts()).setPager(pager);
18 楼
zhouyrt
2010-09-03
To 笨笨狗,
探讨,学习,进步。
谢谢!
探讨,学习,进步。
谢谢!
17 楼
笨笨狗
2010-09-03
另外,说起这个chaing call,不得不推荐dustin diaz的这篇文章:
Asynchronous method queue chaining in JavaScript
http://www.dustindiaz.com/async-method-queues/
异步链式调用更为有趣,也更为实用:)
Asynchronous method queue chaining in JavaScript
http://www.dustindiaz.com/async-method-queues/
异步链式调用更为有趣,也更为实用:)
16 楼
笨笨狗
2010-09-03
zhouyrt 写道
To 笨笨狗
首先,谢谢您给我戴上“降低代码可读性的典型反面教材”的帽子。既然是教材,虽然是反面的,仍然可以给旁人以警惕作用。
其次,我想说的是
1,代码可读性与精简的代码并不必然关系,可以慢慢多琢磨下。
2, 代码可读性与代码风格也不必然关系,多数喜欢的可能是过程式/面向对象式,为什么一尝试函数式就那么不习惯,不喜欢。
难道这样写才算“提高代码可读性”
if(a){
fn1();
}else{
fn2();
}
这样写就“降低代码可读性”
a ? fn1() : fn2();
3, 我承认我们应该写更良好风格的代码,我也曾经深受自己代码风格不良好之苦并幡然醒悟,但上面这个问题的本质,真的是追求更具可读性的代码风格吗?
顺便提下,其实回复 clue,tangjikey,ccyingfu时也说了附件中有chain的“易读版”,“最易读版”。这里贴出
/**
* chain 最易读版
* @param {Object} obj
*/
function singleChain(obj){
function chain(){
if (arguments.length == 0){
return chain.obj;
}
var methodName = arguments[0], methodArgs = [].slice.call(arguments,1);
chain.obj[methodName].apply(chain.obj,methodArgs);
return chain;
}
chain.obj = obj;
return chain;
}
组织代码的风格千千万万,按需权衡。
最后,感谢您的见解!
楼主不必发火,我没有给你带任何帽子的目的:)其实我说说的“可读性”是针对api的使用者,而不是针对api的具体实现,也就是说我们的关注点在于相比
chain(obj)(method1,arg1)(method2,arg2)(method3,arg3)
下面这种风格
obj.method1(arg1).method2(arg2).method3(arg3)
更容易阅读,也更容易理解,不会打断读者的思维,不是么?
当然,话说回来,对于初学者来说,多多了解不同的实现方式那是非常必要的,这方面的推荐去研究Prototype.js的源码,里面对高阶函数的运用可以称得上“炉火纯青”,另外,它的OO类模拟机制是非常新颖的,真让人眼前一亮:)
15 楼
zhouyrt
2010-09-03
笨笨狗 写道
其实,这是一个降低代码可读性的典型反面教材……
如果嫌在每个方法最后返回this是重复代码,那大可以实现一个wrap函数,用AOP的思路来对需要链式调用的方法进行包装:
function chain(obj, methods){
for(var i=0; i<methods.length; i++){
var m = methods[i];
obj[m] = (function(old){
return function(){
old.apply(obj, arguments);
return obj;
}
})(obj[m])
}
}
有了上面的包装函数,就可以这样使用:
function Test(){}
Test.prototype = {
methodA: function(){
alert('methodA');
},
methodB: function(arg){
alert(arg);
}
}
var test = new Test();
//声明需要链式调用的方法
chain(test, ['methodA', 'methodB']);
//try it:)
test.methodB('chain').methodA()
抛砖引玉,你还可以让chain去修改构造函数(比如这里的Test)的prototype,这样只需要设置一次,所有的实例都具有链式调用的能力了,是不是和rails中的dsl有点类似呢?呵呵……
总之,我们在写代码或者设计API的时候,首要的原则就是要保证代码的可读性,SICP里有句话说的好:“程序是写给人看的,机器顺便执行”。
如果嫌在每个方法最后返回this是重复代码,那大可以实现一个wrap函数,用AOP的思路来对需要链式调用的方法进行包装:
function chain(obj, methods){
for(var i=0; i<methods.length; i++){
var m = methods[i];
obj[m] = (function(old){
return function(){
old.apply(obj, arguments);
return obj;
}
})(obj[m])
}
}
有了上面的包装函数,就可以这样使用:
function Test(){}
Test.prototype = {
methodA: function(){
alert('methodA');
},
methodB: function(arg){
alert(arg);
}
}
var test = new Test();
//声明需要链式调用的方法
chain(test, ['methodA', 'methodB']);
//try it:)
test.methodB('chain').methodA()
抛砖引玉,你还可以让chain去修改构造函数(比如这里的Test)的prototype,这样只需要设置一次,所有的实例都具有链式调用的能力了,是不是和rails中的dsl有点类似呢?呵呵……
总之,我们在写代码或者设计API的时候,首要的原则就是要保证代码的可读性,SICP里有句话说的好:“程序是写给人看的,机器顺便执行”。
To 笨笨狗
首先,谢谢您给我戴上“降低代码可读性的典型反面教材”的帽子。既然是教材,虽然是反面的,仍然可以给旁人以警惕作用。
其次,我想说的是
1,代码可读性与精简的代码并不必然关系,可以慢慢多琢磨下。
2, 代码可读性与代码风格也不必然关系,多数喜欢的可能是过程式/面向对象式,为什么一尝试函数式就那么不习惯,不喜欢。
难道这样写才算“提高代码可读性”
if(a){
fn1();
}else{
fn2();
}
这样写就“降低代码可读性”
a ? fn1() : fn2();
3, 我承认我们应该写更良好风格的代码,我也曾经深受自己代码风格不良好之苦并幡然醒悟,但上面这个问题的本质,真的是追求更具可读性的代码风格吗?
顺便提下,其实回复 clue,tangjikey,ccyingfu时也说了附件中有chain的“易读版”,“最易读版”。这里贴出
/**
* chain 最易读版
* @param {Object} obj
*/
function singleChain(obj){
function chain(){
if (arguments.length == 0){
return chain.obj;
}
var methodName = arguments[0], methodArgs = [].slice.call(arguments,1);
chain.obj[methodName].apply(chain.obj,methodArgs);
return chain;
}
chain.obj = obj;
return chain;
}
组织代码的风格千千万万,按需权衡。
最后,感谢您的见解!
14 楼
笨笨狗
2010-09-02
其实,这是一个降低代码可读性的典型反面教材……
如果嫌在每个方法最后返回this是重复代码,那大可以实现一个wrap函数,用AOP的思路来对需要链式调用的方法进行包装:
function chain(obj, methods){
for(var i=0; i<methods.length; i++){
var m = methods[i];
obj[m] = (function(old){
return function(){
old.apply(obj, arguments);
return obj;
}
})(obj[m])
}
}
有了上面的包装函数,就可以这样使用:
function Test(){}
Test.prototype = {
methodA: function(){
alert('methodA');
},
methodB: function(arg){
alert(arg);
}
}
var test = new Test();
//声明需要链式调用的方法
chain(test, ['methodA', 'methodB']);
//try it:)
test.methodB('chain').methodA()
抛砖引玉,你还可以让chain去修改构造函数(比如这里的Test)的prototype,这样只需要设置一次,所有的实例都具有链式调用的能力了,是不是和rails中的dsl有点类似呢?呵呵……
总之,我们在写代码或者设计API的时候,首要的原则就是要保证代码的可读性,SICP里有句话说的好:“程序是写给人看的,机器顺便执行”。
如果嫌在每个方法最后返回this是重复代码,那大可以实现一个wrap函数,用AOP的思路来对需要链式调用的方法进行包装:
function chain(obj, methods){
for(var i=0; i<methods.length; i++){
var m = methods[i];
obj[m] = (function(old){
return function(){
old.apply(obj, arguments);
return obj;
}
})(obj[m])
}
}
有了上面的包装函数,就可以这样使用:
function Test(){}
Test.prototype = {
methodA: function(){
alert('methodA');
},
methodB: function(arg){
alert(arg);
}
}
var test = new Test();
//声明需要链式调用的方法
chain(test, ['methodA', 'methodB']);
//try it:)
test.methodB('chain').methodA()
抛砖引玉,你还可以让chain去修改构造函数(比如这里的Test)的prototype,这样只需要设置一次,所有的实例都具有链式调用的能力了,是不是和rails中的dsl有点类似呢?呵呵……
总之,我们在写代码或者设计API的时候,首要的原则就是要保证代码的可读性,SICP里有句话说的好:“程序是写给人看的,机器顺便执行”。
13 楼
lz12366
2010-09-02
费解啊 发现自己js学的还是不好
12 楼
icedblog
2010-09-02
挺巧妙的~
但看上去有点繁琐
但看上去有点繁琐
11 楼
libmw
2010-08-31
我来写个小小的注释吧
/**
* 精简版
* @param {Object} obj
*/
function chain(obj){
//执行chain直接返回一个方法(类),这样执行chain(obj)('method1',4)就相当于执行这个方法,参数是('method1',4)
return function(){
//定义Self = 本方法的调用者
var Self = arguments.callee;
//给调用者一个属性 即obj参数,这样每次链式调用的时候就可以获得最初的那个obj,而这个obj正好是被链式调用的那个方法,这里是classB
Self.obj = obj;
//一个参数都没有,这是链式调用结束的时候发生的事情,即:...('method3',6)()这里的最后一个括号,此时返回最初的那个obj,这里是classB
if(arguments.length==0){
return Self.obj;
}
/*执行Self.obj[arguments[0]]
比如我们第一次链式调用的时候:('method1',4)
这里我们通过 Self.obj[arguments[0]] 取得了method1方法,
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1)); 代表把Self.obj[arguments[0]]当做Self.obj的一个方法执行,
参数是后面的[].slice.call(arguments,1)
[].slice.call(arguments,1) 截取arguments数组,从索引第一个截取到最后
*/
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
//返回Self
return Self;
}
}
function ClassB(){
this.prop1 = null;
this.prop2 = null;
this.prop3 = null;
}
ClassB.prototype = {
method1 : function(p1){
this.prop1 = p1;
},
method2 : function(p2){
this.prop2 = p2;
},
method3 : function(p3){
this.prop3 = p3;
}
}
var obj = new ClassB();
chain(obj)('method1',4)('method2',5)('method3',6); // obj -> prop1=4,prop2=5,prop3=6
var result = chain(obj)('method1',4)('method2',5)('method3',6)(); // result -> prop1=4,prop2=5,prop3=6
/**
* 精简版
* @param {Object} obj
*/
function chain(obj){
//执行chain直接返回一个方法(类),这样执行chain(obj)('method1',4)就相当于执行这个方法,参数是('method1',4)
return function(){
//定义Self = 本方法的调用者
var Self = arguments.callee;
//给调用者一个属性 即obj参数,这样每次链式调用的时候就可以获得最初的那个obj,而这个obj正好是被链式调用的那个方法,这里是classB
Self.obj = obj;
//一个参数都没有,这是链式调用结束的时候发生的事情,即:...('method3',6)()这里的最后一个括号,此时返回最初的那个obj,这里是classB
if(arguments.length==0){
return Self.obj;
}
/*执行Self.obj[arguments[0]]
比如我们第一次链式调用的时候:('method1',4)
这里我们通过 Self.obj[arguments[0]] 取得了method1方法,
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1)); 代表把Self.obj[arguments[0]]当做Self.obj的一个方法执行,
参数是后面的[].slice.call(arguments,1)
[].slice.call(arguments,1) 截取arguments数组,从索引第一个截取到最后
*/
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
//返回Self
return Self;
}
}
function ClassB(){
this.prop1 = null;
this.prop2 = null;
this.prop3 = null;
}
ClassB.prototype = {
method1 : function(p1){
this.prop1 = p1;
},
method2 : function(p2){
this.prop2 = p2;
},
method3 : function(p3){
this.prop3 = p3;
}
}
var obj = new ClassB();
chain(obj)('method1',4)('method2',5)('method3',6); // obj -> prop1=4,prop2=5,prop3=6
var result = chain(obj)('method1',4)('method2',5)('method3',6)(); // result -> prop1=4,prop2=5,prop3=6
10 楼
goddkiller
2010-08-30
<div class="quote_title">clue 写道</div>
<div class="quote_div">
<div class="quote_title">zhouyrt 写道</div>
<div class="quote_div">
<p> </p>
<h3>
二、对象传入后每次调用返回函数自身</h3>
<p> </p>
<pre name="code" class="js">/**
* chain 精简版
* @param {Object} obj
*/
function chain(obj){
return function(){
var Self = arguments.callee; Self.obj = obj;
if(arguments.length==0){
return Self.obj;
}
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
return Self;
}
}
</pre>
<p> </p>
</div>
<p> </p>
<p>第二种方式还是第一次见,很巧妙的用法</p>
<p> </p>
<p>不过可以简化一下,不使用callee,直接利用闭包:</p>
<pre name="code" class="js">function chain(obj){
var fn = function(method){
if(arguments.length <= 0){
return fn;
}
var args = Array.prototype.slice.call(arguments, 1);
obj[method].apply(obj, args);
return fn;
}
return fn;
}</pre>
<p> PS:那个[].slice的用法还真是。。。够短,不过总觉得凭白无故创建一个数组只为借它的一个方法用用,有点……</p>
</div>
<p>可以Array.prototype.slice......</p>
<div class="quote_div">
<div class="quote_title">zhouyrt 写道</div>
<div class="quote_div">
<p> </p>
<h3>
二、对象传入后每次调用返回函数自身</h3>
<p> </p>
<pre name="code" class="js">/**
* chain 精简版
* @param {Object} obj
*/
function chain(obj){
return function(){
var Self = arguments.callee; Self.obj = obj;
if(arguments.length==0){
return Self.obj;
}
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
return Self;
}
}
</pre>
<p> </p>
</div>
<p> </p>
<p>第二种方式还是第一次见,很巧妙的用法</p>
<p> </p>
<p>不过可以简化一下,不使用callee,直接利用闭包:</p>
<pre name="code" class="js">function chain(obj){
var fn = function(method){
if(arguments.length <= 0){
return fn;
}
var args = Array.prototype.slice.call(arguments, 1);
obj[method].apply(obj, args);
return fn;
}
return fn;
}</pre>
<p> PS:那个[].slice的用法还真是。。。够短,不过总觉得凭白无故创建一个数组只为借它的一个方法用用,有点……</p>
</div>
<p>可以Array.prototype.slice......</p>
9 楼
蔡华江
2010-08-30
以前写个一个invoke方法,很是类似于第二个方法,只是一个返回的运算结果,而一个是调用对象callee。
楼主方法在链式调用功能更强大,更适合于无返回参数的运算
楼主方法在链式调用功能更强大,更适合于无返回参数的运算
8 楼
ghyghoo8
2010-08-28
这个……理解上有难度。。
7 楼
zhouyrt
2010-08-28
To: clue,tangjikey,ccyingfu
附件中有“易读版”,“最易读版”的chain。
附件中有“易读版”,“最易读版”的chain。
6 楼
ccyingfu
2010-08-28
我在第二种方式上解理起来.....表示压力很大。
我经常用的是第一种。
我经常用的是第一种。
5 楼
tangjikey
2010-08-27
第一个还好理解,第二个Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1)); 这句直接看晕了。
4 楼
zhouyrt
2010-08-27
cloudgamer 写道
使用起来能更舒服就好了
例如
var result = chain(obj).method1(4).method2(5).method3(6);
要实现估计要对obj的方法进行重构 还要判断方法本身有没有return
例如
var result = chain(obj).method1(4).method2(5).method3(6);
要实现估计要对obj的方法进行重构 还要判断方法本身有没有return
谢.
3 楼
cloudgamer
2010-08-27
使用起来能更舒服就好了
例如
var result = chain(obj).method1(4).method2(5).method3(6);
要实现估计要对obj的方法进行重构 还要判断方法本身有没有return
例如
var result = chain(obj).method1(4).method2(5).method3(6);
要实现估计要对obj的方法进行重构 还要判断方法本身有没有return
2 楼
clue
2010-08-27
<div class="quote_title">zhouyrt 写道</div>
<div class="quote_div">
<p> </p>
<h3>
二、对象传入后每次调用返回函数自身</h3>
<p> </p>
<pre name="code" class="js">/**
* chain 精简版
* @param {Object} obj
*/
function chain(obj){
return function(){
var Self = arguments.callee; Self.obj = obj;
if(arguments.length==0){
return Self.obj;
}
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
return Self;
}
}
</pre>
<p> </p>
</div>
<p> </p>
<p>第二种方式还是第一次见,很巧妙的用法</p>
<p> </p>
<p>不过可以简化一下,不使用callee,直接利用闭包:</p>
<pre name="code" class="js">function chain(obj){
var fn = function(method){
if(arguments.length <= 0){
return fn;
}
var args = Array.prototype.slice.call(arguments, 1);
obj[method].apply(obj, args);
return fn;
}
return fn;
}</pre>
<p> PS:那个[].slice的用法还真是。。。够短,不过总觉得凭白无故创建一个数组只为借它的一个方法用用,有点……</p>
<div class="quote_div">
<p> </p>
<h3>
二、对象传入后每次调用返回函数自身</h3>
<p> </p>
<pre name="code" class="js">/**
* chain 精简版
* @param {Object} obj
*/
function chain(obj){
return function(){
var Self = arguments.callee; Self.obj = obj;
if(arguments.length==0){
return Self.obj;
}
Self.obj[arguments[0]].apply(Self.obj,[].slice.call(arguments,1));
return Self;
}
}
</pre>
<p> </p>
</div>
<p> </p>
<p>第二种方式还是第一次见,很巧妙的用法</p>
<p> </p>
<p>不过可以简化一下,不使用callee,直接利用闭包:</p>
<pre name="code" class="js">function chain(obj){
var fn = function(method){
if(arguments.length <= 0){
return fn;
}
var args = Array.prototype.slice.call(arguments, 1);
obj[method].apply(obj, args);
return fn;
}
return fn;
}</pre>
<p> PS:那个[].slice的用法还真是。。。够短,不过总觉得凭白无故创建一个数组只为借它的一个方法用用,有点……</p>
发表评论
-
JavaScript获取图片的原始尺寸
2016-04-20 10:30 1591页面里的img元素,想要 ... -
JavaScript中奇葩的假值
2016-03-14 17:43 1157通常在以下语句结构中需要判断真假 if分支语句 whi ... -
世界上最短的数字判断代码
2016-03-14 16:21 1576我们知道JavaScript提供了typeof运算符,因此最 ... -
getBoundingClientRect在IE9/10里的bug
2015-01-12 08:30 1646getBoundingClientRect可以获得页面中某个 ... -
JavaScript中的直接量与初始器的区别
2014-11-08 06:09 1625很多代码优化及公司规范都会提到 写对象不应该 var ... -
JavaScript中的不可见数据类型
2014-11-02 11:08 1288JS提供了一些内置对象、函数和构造器供我们编程,如Math ... -
ES5严格模式
2014-10-08 18:20 1248严格模式(Strict mode)是由ECMA-262规范 ... -
JavaScript生成GUID的算法
2014-07-16 14:25 3012全局唯一标识符(GUID,Globally Unique ... -
JavaScript中点号“.”的多义性
2014-06-07 19:42 1654点号「.」在JavaScript中 ... -
冗余换性能-从Backbone的triggerEvents说开了去
2014-02-19 11:03 950Backbone是一个优秀的前端MVC库,它的代码质量必定 ... -
JavaScript中delete操作符不能删除的对象
2013-11-27 13:21 1303ES3 中,delete在8.6.2.5及11.4.1有介 ... -
JavaScript中instanceof对于不同的构造器可能都返回true
2013-11-19 11:13 1209我们知道 instanceof 运算符用来检查对象是否为某 ... -
JavaScript里模拟sleep
2013-10-16 07:52 1543有几种方式,但都不完美 一、不断循环,直到达到指定时间 ... -
参数有中包含空格且使用Post提交时须将空格转换成加号
2013-10-14 08:07 5204jQuery的serialize模块中有个r20正则 ... -
JavaScript中“基本类型”之争
2013-10-04 20:58 1121前端面试中常被问到的问题之一就是“JavaScript的基本 ... -
ES3和ES5关于计算顺序的问题(ES5先计算函数ES3则是参数)
2013-09-13 23:35 1310从cmc那看到的,分享给园友。以下是一个怪异的代码,谁 ... -
一道关于"/g"笔试题
2013-07-26 07:13 1052正则里“g”表示全局(global)的意思,比如当替换字符串 ... -
JavaScript原型继承的陷阱
2013-05-27 20:51 1394JavaScript默认采用原型 ... -
JavaScript中__proto__与prototype的关系
2013-05-21 10:38 1456这里讨论下对象的内 ... -
JavaScript中__proto__与prototype的关系
2013-05-21 10:01 3这里讨论下对象的内 ...
相关推荐
JavaScript中的链式调用是一种常见的编程技巧,尤其在处理对象属性和方法时,可以使代码更加简洁、易读。链式调用的核心思想是通过在每次方法调用后返回对象自身,使得可以连续调用多个方法而无需重复指定对象名。在...
链式调用是一种常见的设计模式,在许多库和框架中都有应用,尤其是在JavaScript中。链式调用允许开发者通过返回当前对象的方法调用来串联多个方法调用,从而构建简洁且易于阅读的代码。例如: ```javascript ...
链式调用在 JavaScript 语言界很常见,如 jQuery 、 Promise 等,都是使用的链式调用。链式调用可以让我们在进行连续操作时,写出更简洁的代码。 new Promise((resolve, reject) => { resolve(); }) .then(() =...
链式调用在JavaScript语言中很常见,如jQuery、Promise等,都是使用的链式调用,当我们在调用同一对象多次其属性或方法的时候,我们需要多次书写对象进行.或()操作,链式调用是一种简化此过程的一种编码方式,使代码...
在JavaScript中实现链式调用的核心是每个方法都返回对象本身,即使用return this;语句。 要实现链式调用,我们首先需要了解如何构造一个对象,并为其定义一系列的方法。我们可以利用JavaScript的原型继承...
C#与JAVASCRIPT函数的相互调用 C#调用JAVASCRIPT函数的调用 JAVASCRIPT调用C#函数的调用
在JavaScript中,链式调用是一种常见的编程技巧,它允许开发者连续调用一个对象上的多个方法,而无需在每个方法调用后创建新的变量来存储中间结果。这种技术在许多库和框架中,尤其是jQuery中被广泛应用,极大地提高...
JavaScript链式调用是一种常见的编程技巧,特别是在DOM操作和对象操作中,它可以使得代码更加简洁、易读。本文将深入探讨JavaScript链式调用的概念、实现方式以及如何在一个已有的库或框架中应用。 首先,链式调用...
在JavaScript编程中,链式调用是一种常见的编程技巧,它允许开发者连续调用对象的方法而无需在每次调用后创建新的引用。这种技术在构建可读性高、简洁的代码时非常有用,尤其是在处理对象属性和方法时。本文将探讨两...
通过上述分析,可以了解到如何在JavaScript中利用原型继承和方法返回值的技巧来实现链式调用。这样的实现方式在编写客户端脚本时能够带来更加简洁和直观的API,从而提高代码的开发和维护效率。实际开发中,许多流行...
在JavaScript中调用WSDL服务,通常需要以下步骤: 1. **获取WSDL定义**:这通常涉及到一个后端代理或者使用支持WSDL解析的库。例如,`Zepo SOAP`库允许你提供WSDL URL,然后解析并构建相应的SOAP服务客户端。 2. *...
本文实例讲述了Javascript面向对象程序设计链式调用。分享给大家供大家参考,具体如下: 1.链式调用: jquery可能是目前大家最常用到的js框架了,也习惯了如下的调用方式: $('.someclass').show().css('xxx','xxxx'...
在IT领域,C#与JavaScript两种语言的相互调用是一个重要的技术点,尤其在Web开发中,这种跨语言调用可以极大地提升应用的灵活性和功能的丰富性。根据提供的文件信息,我们可以深入探讨C#与JavaScript相互调用的几种...
JavaScript如何调用WCF,很实用
在JavaScript中就可以调用`android.showToast()`了。 4. **安全注意事项** 调用JavaScript时需要注意安全问题。不要随意暴露敏感的Android方法给JavaScript,因为这可能导致应用被恶意利用。`@...
以下是一个示例代码,展示了如何在JavaScript中实现这一功能。 首先,我们注意到在示例中,JavaScript调用Web服务的函数`ajaxRequest()`负责发起请求。该函数的第3行定义了Web服务的URL,这里是`...
JavaScript中的函数对象调用模式是编程中至关重要的概念,它涉及到函数作为一等公民、作用域、闭包、原型链等多个核心知识点。这篇博客通过深入分析JavaScript中的函数调用模式,帮助开发者更好地理解和掌握这些概念...