compilatore di chiusura di google e json

Question

Ho una stringa JSON che analizzo e quindi accedo alle proprietà dell'oggetto con la notazione dot. Tuttavia, nel compilatore di chiusura di google, la notazione a punti (MyObject.PropertyName) avvisa che la proprietà non è definita.

Per ora, la soluzione che sto utilizzando è quella di convertire il mio codice in notazione parentesi (MyObject['PropertyName']). Questo rimuove l'avviso ma impedisce anche al compilatore di fare il suo lavoro. D'altra parte, quando scrivo JSON.stringify(MyObject), il server riceve una stringa con nomi di proprietà comprensibili.

Quindi la mia domanda è: come utilizzare al meglio il compilatore google in modalità avanzata quando si lavora con oggetti json che sono deserializzati e serializzati in fase di runtime.

Answer 1

Se l'unico codice JavaScript che si sta per scrivere è l'accesso a JSON esterno, quindi sconfigge il punto di utilizzo del compilatore. Tuttavia, se hai anche una piccola quantità di JavaScript che funziona oltre a analizzare il tuo json in modelli di dominio, allora il compilatore può essere utile.

Nel nostro parser accediamo ai nostri dati tramite notazione della parentesi così possiamo ottenere i dati correttamente. Da lì inseriamo i dati nei nostri modelli, che utilizziamo. notazione su Questi vengono ribattezzati selvaggiamente, ci danno il controllo del tipo e tutta quella bontà.

Modifica >> Per i dati, utilizzo lo XHRManager. Questa è una classe seriamente carina. Quando ricevo un evento di dati da quel pool, lo gestisco come segue.

/** 
* @private 
* @param {goog.events.Event} evt The event recieved from the XhrIo. 
*/ 
mypath.MyClass.prototype.onDataRecieved_ = function(evt) { 
    if (evt.type != 'complete') return; 
    var xhrIo = evt.target; 
    var data = xhrIo.getResponseJson(); 
    //do somethign! 
}; 

Devo avvertirvi, la mia gestione XHRManager lascia ancora un bel po 'a desiderare. Ho solo rifattorizzato il mio codice la scorsa settimana per iniziare a usarlo.

Per l'analisi mi fare questo: (Questo è un certo roba grezza dalla mia base di codice, in modo da ignorare alcuni del brutto.)

our.class.path.ContestJsonParser.prototype.setContestProperties = 
    function(contest, element) { 
    contest.setName(element['description']); 
    /** 
    * @type {!number} 
    */ 
    var timeAsInt = element['startTime']; 
    contest.setScheduledStartTime(timeAsInt); 
    var clockModel = contest.getClockModel(); 
    if (goog.isDefAndNotNull(element['period'])) { 
    clockModel.setMatchState(element['period']['periodName']); 
    clockModel.setStateStartTime(element['period']['periodStartTime']); 
    } 
    //TODO (Johan) this needs to change today to consider the rest of the stats 
    //information 
    var stats = element['statistics']; 
    if (goog.isObject(stats) && goog.isDefAndNotNull(stats['score'])) { 
    var score = stats['score']; 
    contest.setMatchScore(score['home'], score['away']); 
    } else { 
    contest.setMatchScore(undefined, undefined); // clears score. 
    } 
}; 

Answer 2

Che, fondamentalmente, hanno due scelte:

1. uso degli oggetti accesso dell'array usando la stringa letterale (ovvero MyJsonObject['PropertyName']) questa è la soluzione più semplice.
2. creare un file esterno che descriva le proprietà nell'oggetto JSON e quindi utilizzare la notazione dot (ovvero MyJsonObject.PropertyName). Ciò richiede più manutenzione ma consente al compilatore di digitare controllare le proprietà se si forniscono annotazioni di tipo nella descrizione esterna.

Answer 3

EDIT: la direttiva @expose è stato deprecato

---

Google Closure Compiler consente di specificare le direttive sulle modalità di compilazione deve essere fatto attraverso le annotazioni .

See: https://developers.google.com/closure/compiler/docs/js-for-compiler

correttamente utilizzando @expose e @type è possibile conservare il nome di una proprietà nel codice.

È possibile decodificare in modo sicuro una stringa JSON in un oggetto e accedere a tale oggetto utilizzando la notazione punto. Potrai anche specificare per restringere i dati.

-

Facciamo un esempio:

Si desidera analizzare un array di oggetti. Ogni oggetto rappresenta una "dimensione" , con le proprietà w per la larghezza e h per l'altezza.

Dichiarare un prototipo per la dimensione oggetto e espongono sue proprietà w e h

function size() {} 

/** @expose */ 
size.prototype.w = 0; 
/** @expose */ 
size.prototype.h = 0; 

poi si vuole mettere il JSON analizzato i dati in un array chiamato dati.

Utilizzando @type si dichiara che i dati sta per tenere un serie di oggetto di tipo dimensioni.

function main() 
{ 
    /** @type {Array.<size>} */ 
    var data; 

    // string built up just for example purposes 
    var response = '[{"w": 10, "h": 20}]'; 

    // parse the array 
    var data = JSON.parse(response); 

    // access data with dot notation! 
    console.log(data[0].w+ " "+ data[0].h); 
} 

main();