jQuery基础10-延迟对象 和 回调函数

1.延迟对象

 延迟对象: var def=$.Deferred()
   def.done(fn,[fn])                  //  当延迟成功时调用一个函数或者数组函数。(回调执行是依照添加的顺序)
   def.fail(fn,[fn])                     //  当延迟失败时调用一个函数或者数组函数。(回调执行是依照添加的顺序)
   def.then(d,f,[,p])1.7*             //  添加处理程序被调用时，递延对象得到解决或者拒绝。
   def.always(al,[al])                //  当递延对象是解决或拒绝时被调用添加处理程序。
   def.reject(a)                        //   当延迟被拒绝，then()或fail()中添加的函数按添加顺序被调用。可根据给定的参数调用任何失败的 回调函数。

   def.rejectWith(c,[a])          //   同reject(),并将函数a中的this指向c对象。
   def.resolve(args)              //   当延迟被解决，then()或fail()中添加的函数按添加顺序被调用。可根据给定的参数调用任何完成的回调函数。
   def.resolveWith(c,[a])       //   同resolve(),并将函数a中的this指向c对象。
   def.promise([ty],[ta])          //   返回一个动态生成的Promise对象用来观察当某种类型的所有行动绑定到集合，排队与否还是已经完成。
   def.pipe([d],[f],[p])1.7*           //  筛选器和/或链Deferreds的实用程序方法。
   def.notify(args)1.7+               //  调用一个给定args的递延对象上的进行中的回调 
   def.notifyWith(c,[a])1.7+          //  同notify(),并将函数 a 中的this指向 c 对象。
   def.progress(proCal)1.7+           //  当Deferred对象时生成进度通知时添加被访问处理程序。
   def.state()1.7                         //  确定一个Deferred对象的当前状态。

 //使用.done方法,一旦jQuery.get方法返回一个来自延迟的对象的jqXHR对象，附加一个成功回调.
$.get("test.php").done(function() { 
    alert("$.get 成功");                       //延迟成功
}).fail(function(){
    alert("$.get 失败");                       //延迟失败
});


function a1(){ alert(1)};
function a2(){ alert(2)};
function a3(){ alert(3)};

 //$.get("test.php").then(fn1,fn2,fn3)   参数都是可选，延迟成功执行fn1,失败执行fn2,递延时执行fn3
$.get("test.php").then(a1,a2,a3);                  //弹出：2  (失败)

$.get("test.php").then(a1,a2,a3).reject(a2);              //拒绝延迟时执行 a2
$.get("test.php").then(a1,a2,a3).rejectWith({},a2);       //a2中的 this = {}

$.get("test.php").always(a1);                             //递延对象是解决或拒绝时被调用a1


 //一个集合上使用promise，而没有动画解决的promise
var odiv = $( "<div />" );
odiv.promise().done(function( arg1 ) {
    alert( this === odiv &;&; arg1 === odiv );         //true
});


//def.pipe(fn1,fn2,fn3);   
//参数都是可选，fn1当递延得到解决时调用，fn2当递延得被拒绝时调用,fn3一个可选的函数会在延迟调用被拒绝时被调用
//过滤解决值
var def= $.Deferred(),
filtered = def.pipe(function( value ) {
      return value * 2;
});
 
def.resolve( 5 );
filtered.done(function( value ) {
     alert( value );                              //10      
});

 //过滤器拒值:
var def = $.Deferred(),
    filtered = def.pipe( null, function( value ) {
      return value * 3;
    });

def.reject( 6 );
filtered.fail(function( value ) {
  alert( value );                                 //18
});;

 //链任务:
var request = $.ajax( url, { dataType: "json" } ),
    chained = request.pipe(function( data ) {
      return $.ajax( url2, { data: { user: data.userId } } );
    });

chained.done(function( data ) {
    // data retrieved from url2 as provided by the first request
});

 

2.回调函数

   回调函数：var cal=$.Callbacks();
    cal.add(callbacks)                //   1.7+回调列表中添加一个回调或回调的集合。
    cal.fire(args)                //   1.7+调用回调列表中的回调。
    cal.fireWith([c] [,a])                //   1.7+同 fire() ,将函数 a 中的this指向 对象c。
    cal.remove(callbacks)                //   1.7+删除回调或回调回调列表的集合。
    cal.empty()                //   1.7+从列表中删除所有的回调。
    cal.disable()                //   1.7+禁用回调列表中的回调。
    cal.fired()                //   1.7+是否用给定的参数调用所有的回调。
    cal.has(callback)                //   1.7+确定是否提供的回调列表。
    cal.lock()                //   1.7+锁定在其当前状态的回调列表。
    cal.locked()                //   1.7+确定是否已被锁定的回调列表。
    $.callbacks(flags)                //   1.7+一个多用途的回调列表对象，提供了强大的的方式来管理回调函数列表。 

function run1(v){
    console.log("run1:"+v);
}

function run2(v){
    console.log("run2:"+v);
}

var cal=$.Callbacks();
cal.add(run1);                 //添加一个回调

console.log(cal.fired() );     //false
cal.fire("aaa");               //"run1:aaa"    (调用回调)
console.log(cal.fired() );     //true          (回调被调用)

cal.add(run2);                 //添加另一个回调
cal.fire("aaa");               //"run1:aaa" "run2:aaa"   (调用回调,执行所有回调)

cal.empty();                   //删除所有回调
 //等价下面：
cal.remove( run1,run2 );       //删除2个回调
cal.fire("aaa");               //(空)

function run3(){
    console.log(this.name);
}
cal.add(run3); 
cal.fire();                           //undefined
cal.fireWith({name:"aaa"},run3);      //"aaa"      ( run3中的this={name:"aaa"} )

console.log(cal.has(run3))            //true       ( 回调集合中包含 run3 )

cal.disable();                        //禁用回调
cal.fireWith({name:"aaa"},run3);      //(空)

console.log(cal.has(run3))             //false     ( 回调集合中不包含 run3 )

lock() / locked()

function run(v){
    console.log("run:"+v);
}

var cal=$.Callbacks();
cal.add(run); 
cal.fire("aaa");             //"run:aaa"
cal.fire("bbb");             //"run:bbb"

console.log ( cal.locked() );    //false (回调没有被锁定)

cal.lock();                  //锁定回调，使其状态不再改变
cal.fire("ccc");             // (空)

console.log ( cal.locked() );    //true (回调被锁定)  

 $.callbacks(x) 
   once:            //  确保这个回调列表只执行一次(像一个递延 Deferred).
   memory:          //  保持以前的值和将添加到这个列表的后面的最新的值立即执行调用任何回调 (像一个递延 Deferred).
   unique:          //  确保一次只能添加一个回调(所以有没有在列表中的重复).
   stopOnFalse:     //  当一个回调返回false 时中断调用,默认情况下，回调列表将像事件的回调列表中可以多次触发。

function run1(v){
    console.log("run1:"+v);
}
function run2(v){
    console.log("run2:"+v);
}

 //传参：once    回调列表只执行一次
var c1=$.Callbacks("once");
c1.add(run1);
c1.fire("aaa");              //"run1:aaa"
c1.add(run2);
c1.fire("bbb");              //(空，不再执行)

jQuery基础1-简介、语法

jQuery基础2-选择器

jQuery基础3-筛选（过滤、查找、串联）

jQuery基础4-dom元素操作

jQuery基础5-事件

jQuery基础6-动画效果

jQuery基础7-Ajax请求

jQuery基础8-event事件对象

jQuery基础9-工具函数

jQuery基础10-延迟对象 和 回调函数