Esiste uno schema comune consigliato per la memorizzazione delle chiamate ajax?

Question

Sto lavorando con alcuni dati governativi pubblicati tramite Socrata'sSODA api.

Questa API fornisce un modo per recuperare le righe tramite una chiamata REST. L'API consente una parametrizzazione limitata della query: in pratica puoi eseguire una ricerca a tutto testo e nient'altro. Non riesco a trovare un modo per modellare i dati restituiti, ad esempio restituire solo determinate colonne dei dati.

Come risultato, in sostanza posso solo ottenere tutte le righe e tutte le colonne di ogni vista dati. Questo è ok, immagino, ma mi piacerebbe metterlo nella cache - memoize per usare il termine di sottolineatura.

Esiste uno schema per la memoizzazione delle chiamate ajax con jQuery?

---

EDIT: Per dare un'idea di cosa sto parlando, ecco quello che sto facendo al momento.

function onclick(event) { 
    var $t = $(event.currentTarget); 
    var itemId = $t.attr('data-itemid'); 
    var url = getRestUrl(itemId); 
    if (typeof datacache[itemId] === "undefined") { 
     $.ajax({ 
      url  : url, 
      cache  : true, 
      type  : "GET", 
      dataType : "json", 
      error  : function(xhr,status,error) { 
       raiseError(error); 
      }, 
      success : function(response, arg2, xhr) { 
       datacache[itemId] = response; 
       doSomethingWithTheData(url, itemId); 
      }}); 
    } 
    else { 
     doSomethingWithTheData(url, itemId); 
    } 
} 

// then, doSomethingWithTheData() simply references datacache[itemId] 

Questo sembra come se fosse il più veloce anche se non ho misurato esso. Quello che voglio veramente sapere è, c'è un modello comune che fa qualcosa del genere, che posso impiegare, in modo che chiunque legga il codice vedrà immediatamente cosa sto facendo ??

Answer 1

Potreste essere in grado di fare una cosa del genere si fa con le ricerche di completamento automatico (questo è molto dalla memoria, ma si ottiene l'idea):

var searchCache = {}, searchXhr = null; 

function Search(term) { 

    if (term in searchCache) { 
     return doSomethingWithTheData(searchCache[term]); 
    } 

    if (searchXhr != null) { 
     searchXhr.abort(); 
    } 

    searchXhr = $.ajax({ 
     url  : url, 
     cache  : true, 
     type  : "GET", 
     dataType : "json", 
     error  : function(xhr, status, error) { 
      raiseError(error); 
     }, 
     success : function(response, arg2, xhr) { 
      searchCache[term] = response; 
      if (xhr == searchXhr) { 
       doSomethingWithTheData(response); 
       searchXhr = null; 
      } 
     } 
    }); 

} 

Answer 2

Io non sono necessariamente i migliori esperti per la domanda Javascript, ma potrei essere in grado di aiutarti con l'uso di SODA.

Se si desidera maggiore flessibilità nelle query e si può eseguire un POST HTTP, è possibile utilizzare la sintassi delle query per eseguire una query più mirata: http://dev.socrata.com/querying-datasets. La nostra sintassi delle query è piuttosto complessa, ma posso aiutarti a capire come strutturare la tua query se colpisci qualche ostacolo.

Sfortunatamente, dal momento che richiederebbe un POST, sarà necessario uscire dal lockbox cross-domain XHR passando attraverso un proxy o qualcosa di simile.

Inoltre, siamo a conoscenza di una sintassi completamente nuova che ti consentirà di specificare le query come parametri URL, così sarai in grado di eseguire richieste semplici come /resources/agencies?acronym=CIA o /resources/agencies?$where='budget > 10000000'. Dovrebbe essere davvero fantastico.

Answer 3

Si memorizzeranno solo le richieste ajax che si sa non cambieranno, ad esempio il SDF di Facebook. Sembra che nel tuo esempio tu stia richiedendo qualcosa di relativo all'interfaccia utente che potrebbe essere inappropriato per la cache? Altrimenti, potresti provare qualcosa del tipo:

var store = {};

/** 
* Memoized $.getScript 
* 
* Cache one script response per url 
* Reference, see http://msdn.microsoft.com/en-us/magazine/gg723713.aspx 
* 
* @example $.memoizedGetScript(url).then(successCallback, errorCallback); 
* @param {String} url 
* @param {Function} callback (optional) 
* @returns {*} 
*/ 
$.memoizedGetScript = function(url, callback) { 
    var callback = callback || {}; 

    store.cachedScripts = {}; 

    if (!store.cachedScripts[url]) { 
     store.cachedScripts[url] = $.Deferred(function(d) { 
      $.getScript(url).then(
       d.resolve(), 
       d.reject() 
      ); 
     }).promise(); 
    } 

    return store.cachedScripts[url].done(callback); 
};