Ottimizzazione del codice JavaScript che mette in minuscolo i nomi di proprietà JSON

Question

Io lavoro su un'applicazione Web che riceve dati JSON con nomi di proprietà maiuscole. Ho bisogno che quei nomi di proprietà siano in minuscolo, quindi sto usando una funzione per ricorrere ricorsivamente attraverso l'oggetto JSON e convertirli in lettere minuscole.

Il problema è che le mie risposte JSON possono diventare molto grandi. Voglio che la funzione funzioni bene anche se deve elaborare JSON con 60.000 nomi di proprietà e vari livelli di nidificazione.

La funzione lettere minuscole è:

FN = function (obj) 
{var ret = null; 
    if (typeof(obj) == "string" || typeof(obj) == "number") 
     return obj; 
    else if (obj.push) 
     ret = []; 
    else 
     ret = {}; 
    for (var key in obj) 
     ret[String(key).toLowerCase()] = FN(obj[key]); 
    return ret; 
}; 

E io l'esecuzione di alcune analisi comparativa qui: http://jsfiddle.net/emw89/7/

Gli orologi di prova di cui sopra in a ~ 570MS sulla mia macchina.

C'è qualcosa che posso fare per migliorare le prestazioni di questa funzione?

Modifica: ho chiuso il mio IE, ho riaperto IE e ho eseguito nuovamente il benchmark jsfiddle - ora è arrivato a ~ 180ms per me. Il mio IE era rimasto aperto per un paio di giorni consecutivi fino a quel momento, quindi forse questo è ciò che ha causato una performance così scarsa. Ad ogni modo, sono ancora interessato se c'è un modo per ottimizzare ulteriormente questa funzione. Ogni volta che il tempo trascorso in più per l'elaborazione di JSON aggiunge direttamente al tempo trascorso di ogni richiesta AJAX.

Answer 1

var lowerCache = {}; 

FN = function (obj) 
{ 
    if (typeof(obj) === "string" || typeof(obj) === "number") 
     return obj; 

     var l = obj.length; 
    if (l) { 
     l |= 0; 
     var result = []; 
     result.length = l; 
     for (var i = 0; i < l; i++) { 
      var newVal = obj[i]; 
      result[i] = typeof(newVal) === "string" ? newVal : FN(newVal); 
     } 
     return result; 
    } else { 
    var ret = {}; 
    for (var key in obj) { 

     var keyStr = typeof(key) === "string" ? key : String(key); 
     var newKey = lowerCache[keyStr]; 
     if (newKey === undefined) { 
      newKey = keyStr.toLowerCase(); 
      lowerCache[keyStr] = newKey; 
     } 

     var newVal = obj[key]; 
     ret[newKey] = typeof(newVal) === "string" ? newVal : FN(newVal); 
    } 
    return ret; 
    } 
}; 

100% più veloce.

Answer 2

Lo farei con la semplice regex replace.

1. Usa JSON per convertire oggetto stringa
2. Sostituire tutti gli oggetti con lo stesso nome proprio minuscolo nuovo
3. stringa convertire in oggetto

esempio

var obj = { SENAD: "meskin" }; 

var str = JSON.stringify(obj); 

function lCase(xxx) 
{ 
    pattern = /\"([a-z0-9_-]{0,})\"\:/gi; 
    return xxx.replace(pattern, function() { return arguments[0].toLowerCase() }); 
} 
str = lCase(str); 

var newObj = JSON.parse(str); 
alert(newObj.senad); 
console.log(str); 

Spero che questo aiuti.

Answer 3

Se si elaborano oggetti JSON di grandi dimensioni con IE (o qualsiasi altro browser, ma IE è più probabile che sputi il ​​dummy), si consiglia di elaborare il json/array in blocchi.

buona spiegazione di questo processo può essere trovato qui http://oreilly.com/server-administration/excerpts/even-faster-websites/writing-efficient-javascript.html (scorrere fino alla "Patterns Timer a diventare" voce)