¿Existe un patrón común recomendado para memorizar llamadas ajax?

Question

Estoy trabajando con algunos datos del gobierno publicados a través de Socrata'sSODA api.

Esta API proporciona una forma de recuperar filas mediante una llamada REST. La API permite la parametrización limitada de la consulta; básicamente, puede hacer una búsqueda de texto completo, y nada más. No puedo encontrar la forma de dar forma a los datos devueltos, por ejemplo, solo devuelvo ciertas columnas de los datos.

Como resultado, básicamente solo puedo obtener todas las filas y todas las columnas de cada vista de datos. Esto está bien, supongo, pero me gustaría almacenarlo en la memoria caché - para memorizarlo para usar el término de subrayado.

¿Hay algún patrón para la memorización de llamadas ajax con jQuery?

---

EDITAR: Para darle una idea de lo que estoy hablando, esto es lo que estoy haciendo actualmente.

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] 

Este parece como que es más rápido aunque no he medido. Lo que realmente quiero saber es ¿Existe un patrón común que haga algo como esto, que yo pueda emplear, para que todos los que lean el código vean inmediatamente lo que estoy haciendo?

Answer 1

Usted puede ser capaz de hacer algo como se hace con las búsquedas de autocompletar (esto es en gran medida de la memoria, pero usted consigue la 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

No estoy necesariamente el mejor experto para la pregunta de Javascript, pero podría ayudarte con tu uso de SODA.

Si está buscando más flexibilidad en sus consultas, y puede hacer un HTTP POST, puede usar nuestra sintaxis de consulta para hacer una consulta más específica: http://dev.socrata.com/querying-datasets. Nuestra sintaxis de consulta es bastante compleja, pero puedo ayudarlo a encontrar la forma de estructurar su consulta si encuentra inconvenientes.

Desafortunadamente, dado que eso requeriría un POST, tendrá que salir de la caja de seguridad entre dominios XHR pasando por un proxy o algo similar.

Además, FYI, estamos trabajando en una sintaxis completamente nueva que te permitirá especificar consultas como parámetros de URL, por lo que podrás realizar solicitudes simples como /resources/agencies?acronym=CIA o /resources/agencies?$where='budget > 10000000'. Debería ser bastante impresionante.

Answer 3

Solo almacenaría en caché las solicitudes ajax que sabe que no cambiarán, como el SDF de Facebook, por ejemplo. Parece que en su ejemplo, ¿está solicitando algo relacionado con la interfaz de usuario que podría no ser apropiado para el caché? De lo contrario, podría intentar algo como esto:

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); 
};