Kas yra atidėtų objektų?

jQuery 1.5 prideda laukiančius objektus. Kokie jie ir ką jie daro?

115
01 февр. Mohammad Ali Akbari nustatytas vasario 01 d 2011-02-01 21:54 '11 at 21:54 2011-02-01 21:54
@ 4 atsakymai

Atidėtas objektas

Kaip ir jQuery 1.5, laukiantis objektas suteikia galimybę užregistruoti keletą atgalinių atsiliepimų atgalinio tikrinimo eilėje, prireikus iškviesti atgalinio ryšio eiles ir perduoti bet kokios sinchroninės ar asinchroninės funkcijos sėkmės ar gedimo būseną.

Atidėtas metodas:

  • atidėtas.done ()
    • Pridėkite tvarkyklių, kuriuos reikia iškviesti, kai objektas atidedamas.
  • deferred.fail ()
    • Pridėkite tvarkyklių, kurie vadinami, kai objektas atidedamas.
  • atidėtas.
    • Nustatykite, ar objektas buvo atmestas.
  • atidėtas.
    • Nustatykite, ar objektas buvo atidėtas.
  • atidėtas.
    • Atmeskite objektą su vėlavimu ir skambinkite bet kuriuo failo atkūrimu su pateiktais argumentais.
  • atidėtas.
    • Atmeskite objektą su vėlavimu ir skambinkite bet kokiu nepavykusiu ryšiu su nurodytu kontekstu ir args.
  • atidėtas.
    • Leiskite objektui sustabdyti ir su pateiktais argumentais skambinti bet kokiems įvykiams.
  • deferred.resolveWith ()
    • Ištaisykite laukiančio objekto ir skambinkite bet kokiu atliktu ryšiu su pateiktu kontekstu ir args.
  • atidėtas.
    • Leisti arba atmesti papildomus tvarkytojus, kuriuos reikia skambinti, kai objektas atidedamas.

Atidėti veiksmu:

 $.get("test.php").done( function(){ alert("$.get succeeded"); } ); $.get("test.php") .done(function(){ alert("$.get succeeded"); }) .fail(function(){ alert("$.get failed!"); }); 

Atrodo, kad esamos „ajax“ () skambučiai gali būti suvaržyti, nepateikiami nustatymuose:

 var jqxhr = $.ajax({ url: "example.php" }) .success(function() { alert("success"); }) .error(function() { alert("error"); }) .complete(function() { alert("complete"); }); 

Darbo pavyzdys „ Eric Hynds“ tinklaraščio įraše : http://jsfiddle.net/ehynds/Mrqf8/


jqXHR

Kaip ir jQuery 1.5, $ .ajax () metodas grąžina jXHR objektą, kuris yra XMLHTTPRequest objekto viršelis. Daugiau informacijos rasite $ .ajax jXHR skyriaus įrašuose


JQUERY 1.5 RELEASED :

ATLIEKAMI OBJEKTAI

Kartu su „Ajax“ modulio perrašymu įdiegta nauja funkcija, kuri taip pat buvo paskelbta: „ Atidėtas objektas“ . Ši API leidžia jums dirbti su grąžinamosiomis vertėmis, kurios gali būti ne iš karto (pvz., Grąžinimo rezultatas) iš asinchroninio Ajax užklausos). Be to, tai suteikia jums galimybę pridėti keletą įvykių tvarkytojų (kažkas anksčiau nebuvo įmanoma „Ajax“ API).

Be to, galite sukurti savo laukiančius objektus naudodami jQuery.Deferred. Daugiau informacijos apie šią API galima rasti atidėto objekto .

Ericas Hindsas parašė gerą pamoką apie laukiančio „jQuery“ naudojimą 1.5 .

96
01 февр. atsakymas duotas medžiotojui vasario 01 d 2011-02-01 21:55 '11 at 21:55 2011-02-01 21:55

Užuot pasakęs, ką jis daro, aš jums parodysiu, ką jis daro ir paaiškina.

JQuery 1.5 susieto šaltinio kopija su anotacija, paaiškinančia, ką ji daro. Manau, kad komentarai dažniausiai yra teisingi.

Tai gali būti naudinga.

 // promiseMethods. These are the methods you get when you ask for a promise. // A promise is a "read-only" version // fullMethods = "then done fail resolve resolveWith reject rejectWith isResolve isRejected promise cancel".split(" ") // As you can see it removes resolve/reject so you can't actaully trigger a // anything on the deferred object, only process callbacks when it "finishes". promiseMethods = "then done fail isResolved isRejected promise".split(" "), // Create a simple deferred (one callbacks list)  _Deferred: function () { var // callbacks list callbacks = [], // stored [ context , args ] // stores the context  args that .resolve was called with fired, // to avoid firing when already doing so firing, // flag to know if the deferred has been cancelled // in Deferred cancel gets called after the first resolve call cancelled, // the deferred itself deferred = { // done( f1, f2, ...) done: function () { if (!cancelled) { var args = arguments, i, length, // elem in callback list elem, // type of elem in callback list type, // cached context  args for when done is called // after resolve has been _fired; // If resolve has been called already if (fired) { // mark it locally _fired = fired; // set fired to 0. This is neccesary to handle // how done deals with arrays recursively // only the original .done call handles fired // any that unwrap arrays and call recursively // dont handle the fired. fired = 0; } // for each function append it to the callback list for (i = 0, length = args.length; i < length; i++) { elem = args[i]; type = jQuery.type(elem); // if argument is an array then call done recursively // effectively unwraps the array if (type === "array") { // def.done([f1, f2, f3]) goes to // def.done(f1, f2, f3) through the apply deferred.done.apply(deferred, elem); } else if (type === "function") { // if its a function add it to the callbacks callbacks.push(elem); } } // if it already been resolved then call resolveWith using // the cahced context and arguments to call the callbacks // immediatly if (_fired) { deferred.resolveWith(_fired[0], _fired[1]); } } return this; }, // resolve with given context and args resolveWith: function (context, args) { // if its been cancelled then we can't resolve // if it has fired then we can't fire again // if it currently firing then we can't fire. This check is // there because of the try finally block. It ensures we // cant call resolve between the try  finally in the catch phase. if (!cancelled  !fired  !firing) { firing = 1; // try block because your calling external callbacks // made by the user which are not bugfree. // the finally block will always run no matter how bad // the internal code is. try { while (callbacks[0]) { callbacks.shift().apply(context, args); } // cache the content and arguments taht have been called // and set firing to false. } finally { fired = [context, args]; firing = 0; } } return this; }, // resolve with this as context and given arguments // just maps to resolveWith, this sets the this scope as normal // maps to this.promise which is the read only version of Deferred. resolve: function () { deferred.resolveWith(jQuery.isFunction(this.promise) ? this.promise() : this, arguments); return this; }, // Has this deferred been resolved? // checks whether it firing or if it has fired. isResolved: function () { return !!(firing || fired); }, // Cancels the action. To be used internally cancel: function () { cancelled = 1; callbacks = []; return this; } }; return deferred; },  // Full fledged deferred (two callbacks list) Deferred: function (func) { // the main deferred which deals with the success callbacks var deferred = jQuery._Deferred(), // the failure deferred which deals with the rejected callbacks failDeferred = jQuery._Deferred(), // the read only promise is cached. promise; // Add errorDeferred methods, then and promise jQuery.extend(deferred, { // def.then([f1, f2, ...], [g1, g2, ...] is a short hand for // def.done([f1, f2, ...]) // def.fail([g1, g2, ...]) then: function (doneCallbacks, failCallbacks) { // fail exists here because this code will only run after // deferred has been extended. deferred.done(doneCallbacks).fail(failCallbacks); return this; }, // map def.fail to the second underlying deferred callback list // map all the other methods for rejection/failure to the underlying // failDeffered object so that Deferred has two callback lists stored // internally. fail: failDeferred.done, rejectWith: failDeferred.resolveWith, reject: failDeferred.resolve, isRejected: failDeferred.isResolved, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object // no clue what to do with "i" promise: function (obj, i  ) { // if no argument is passed then just extend promise if (obj == null) { // if cached return the cache. if (promise) { return promise; } // set promise  arg to be {} promise = obj = {}; } // for each promiseMethods in the read only promise list i = promiseMethods.length; while (i--) { // set the deferred method on the object obj[promiseMethods[i]] = deferred[promiseMethods[i]]; } // returns the "read-only" deferred without // resolve, resolveWith, reject  rejectWith. // So you cant "resolve" it but only add "done" functions return obj; } }); // Make sure only one callback list will be used // if either resolve or reject is called cancel both. // this means that the one that has been called cant be called again // and the other one will never be called. So only the done or the fail // methods will ever be called deferred.then(failDeferred.cancel, deferred.cancel); // Don't mess with cancel! // Unexpose cancel delete deferred.cancel; // Call given func if any // function argument to be called. This was passed in. Allows you to // handle the deferred object after creating a new one, both as this scope // and as a new argument. if (func) { func.call(deferred, deferred); } return deferred; },  // Deferred helper when: function (object) { var args = arguments, length = args.length, // If you pass in a deferred object then set deferred to be the promise // if you pass in anything else then set deferred to be a new deferred deferred = length <= 1  object  jQuery.isFunction(object.promise) ? object : jQuery.Deferred(), // cache the promise promise = deferred.promise(), // store an array resolveArray; // if multiple objects are passed in if (length > 1) { // create an arrey to store of values. resolveArray = new Array(length); // for each object that we wait on jQuery.each(args, function (index, element) { // when that object resolves then jQuery.when(element).then(function (value) { // store value in the array or store an array of values in it resolveArray[index] = arguments.length > 1 ? slice.call(arguments, 0) : value; // if length === 1 then we finished calling them all if (!--length) { // resolve the deferred object with the read only promise // as context and the resolved values array as the argument deferred.resolveWith(promise, resolveArray); } // if any fail then we reject or deferred }, deferred.reject); }); // if deferred was newly created but there was only one argument then // resolve it immediatly with the argument. } else if (deferred !== object) { deferred.resolve(object); } // return the read-only deferred. return promise; }, 
12
02 февр. atsakymą pateikė Raynos 02 vasaris. 2011-02-02 00:04 '11 prie 0:04 2011-02-02 00:04

Ištaisykite mane, jei aš klystu, tačiau neseniai jis paspaudė ant manęs, kad jis iš esmės yra asinchroninis darbas. Pažadas yra sutarties rezultatas, užtikrinantis, kad ... kažką gausite, bet neužtikrinsite, kada jį gausite.

9
07 сент. Atsakymas, kurį pateikė George R 07 Sep 2011-09-07 02:57 '11 at 2:57 2011-09-07 02:57

Dirbdami „Javascript“, susiduriame su situacija, kai funkcijų skambučiai yra asinchroniniai. Tai reiškia, kad „Calee“ funkcija (leisti, X) siūlas nelaukia vadinamos asinchroninės funkcijos (pvz., Y). Tipiškas pavyzdys yra tada, kai skambina į serverį, kad gautume duomenis iš duomenų bazės ar HTML puslapio. Jei šie skambučiai nebuvo asinchroniniai, vartotojo sąsaja įstrigo laukdama, kol serveris atsakys. Šis asinchroninis simbolis sukelia problemą, kai norite kažką atlikti užsakyme, pvz., Norite spausdinti kažką po Y (asynch), paleisdami arba atnešdami duomenis. Čia jQuery suteikia mums nustatytą objektą. Iš esmės, jQuery rūpinosi visais šablonais, kuriuos paprastai rašome, kad išspręstume šią situaciją. Štai paprastas pavyzdys:

  $.ajax({ ... }).done(function(){ //write here what you wish to do when this ajax call is success }).fail(function(){ //write here what you wish to do on failure of this ajax call }); //see more on jQuery Deferred page 

Galite parašyti savo atidėtą (asinchroninę) funkciją.

 function DoSomethingTimeConsumingAsynch(){ var deferred = $.Deferred(); _.defer(function(){ //I am using underscore, you can also use setTimeout ... deferred.resolve();//When the process is done successfully ... deferred.reject(); //When the process has failed }); return deferred; } //HEre how to use your own asynch function DoSomethingTimeConsumingAsynch() .done(function(){ //this will be invoked on success }) .fail(function(){ //this will be invoked on failure }) 

Tikiuosi, kad tai padėjo.

3
26 янв. Atsakymą pateikė hadaytullah 26 sausis 2016-01-26 13:13 '16 at 13:13 2016-01-26 13:13

Kiti klausimai, susiję su „ arba „ Užduoti klausimą“