ToSource trasformando in una soluzione completa di serializzazione

ProblemaSi desidera una correzione di trasformare toSource in una soluzione completa di serializzazione. Theory Mozilla ha sviluppato un metodo molto intelligente chiamato toSource. Utilizzando toSource, è possibile serializzare lo stato di un oggetto in un buffer. Si consideri il seguente esempio di dichiarazione di tipo.

 Fonte: / website / ROOT / articles ajax / javascript / DefinedClass funzione tosource.html () (this.localvalue = 10; this.localmethod = function (param) (info ( "DefinedClass.localmethod", "mi ha chiamato");))

Il tipo DefinedClass ha definito un metodo localmethod e un membro localvalue dati. Quando il tipo viene creata un'istanza, il tipo di un'istanza toSource ha un metodo che può essere chiamato, come illustrato nel seguente codice sorgente.

 Fonte: / website / ROOT / articles ajax / javascript / tosource.html cls DefinedClass var = new (); cls.prototypemethod.value = 100; info ( "mozilla_tosource", cls.toSource ());

ToSource quando viene chiamato, il buffer seguente viene generato:

(Localvalue: 10, localmethod: (function (param) (info ( "DefinedClass.localmethod", "mi ha chiamato ");}))

Il buffer è generata una forma serializzata di un'istanza di oggetto. Manca la serializzazione è la definizione del tipo. Quando l'istanza dell'oggetto è ri-creato, ricreato è lo stato dell'oggetto. Eppure questo non è completamente vero, perché la seguente dichiarazione prototipo è mancato da toSource.

 Fonte: / website / ROOT / articles ajax / javascript / tosource.html DefinedClass.prototype.prototypevalue = StaticClass new ();

Tutto ciò che viene dichiarato attraverso la proprietà DefinedClass.prototype è mancato da parte l'attuazione toSource. Mancanti le proprietà ei metodi di base ha un senso se il buffer toSource dovesse contenere un riferimento al tipo che ha creato l'istanza. Eppure non vi è alcun riferimento con i metodi mancanti e le proprietà, e non il supporto su qualsiasi browser diverso da Mozilla / Firefox. Allora, qual è l'uso di toSource? Il metodo toSource di per sé è limitato, ma l'idea che sta dietro toSource è buona. Vogliamo che la possibilità di serializzare un oggetto per il consumo dopo, e come verrà dimostrato in articoli più tardi, la serializzazione è la chiave per l'attuazione object-oriented varie tecniche, come ad esempio mixins. Come illustrato dalla realizzazione di Mozilla di toSource, serializzazione può avere diverse sfaccettature . Prima di iniziare l'implementazione di serializzazione, let's identificare i diversi contesti di serializzazione:

• Serializzazione Plain vanilla come toSource: La serializzazione di default fornito da Mozilla non è disponibile in altri browser. Per le applicazioni Web che fanno uso toSource, ci deve essere una implementazione per gli altri browser. Non serializzare le proprietà prototipo è utile quando si desidera serializzare le informazioni supplementari, e non le informazioni di base.

• Serializzazione dichiarazione esempio Full: Una serializzazione completa esempio si ha quando tutti i metodi, le proprietà e membri di dati vengono convertiti in un buffer che, una volta eseguito, completamente ri-creare l'oggetto. Quando l'istanza viene ricreato, le sue informazioni di tipo originale è perduto.

• Serializzazione grado di Stato: A differenza di altri serializzazioni, serializzazione di Stato è la generazione di un buffer che contiene solo lo stato di un oggetto, le dichiarazioni di funzione non vengono generati. Il codice JavaScript Object Notation (JSON) il protocollo è un esempio di uno stato di istanza di serializzazione solo. Durante la serializzazione dello Stato esempio, i membri di dati definiti nella proprietà prototipo sono inclusi.

• Serializzazione assegnazione di variabili: Una serializzazione integrale dichiarazione esempio include tutti lo stato di un'istanza di un oggetto, ma le proprietà funzionali sono mancanti perché non hanno usato spesso. Se una proprietà funzione viene utilizzata, quindi lo stato serializzato deve essere assegnato a una variabile, altrimenti è molto difficile attribuire proprietà funzione.

• Object-oriented di serializzazione: Serializzazione object-oriented è un'estensione della serializzazione plain vanilla. La ragione per la definizione di un oggetto-serializzazione orientato è quello di consentire la separazione di classe di dati specifici e ad esempio i dati specifici. Utilizzando la serializzazione objectoriented, un oggetto può essere serializzato e ri-creato con comportamento predefinito diverso. Ognuno dei contesti è un sapore specifico di serializzazione. La caratteristica comune tra tutti i contesti è che serializzare le stesse informazioni e filtrare ciò che non è necessario. Ad esempio, i filtri di serializzazione plain vanilla su qualsiasi proprietà riferimento prototipo. Filtri di serializzazione di Stato tutte le funzioni, ma scorre proprietà a cui fa riferimento prototipo. Solution Come primo passo, creeremo un generale "serializzare tutto" attuazione. L'attuazione serializzare tutto includerà funzionalità di filtro e la generazione di funzionalità di uscita di controllo. Utilizzando la serializzazione generale richiede un po 'di comprensione del processo di serializzazione, in modo che il fine-tuning è possibile. In una seconda fase, ci attuare specifici contesti serializzazione con l'implementazione di un filtro adeguati.

Serializzazione di tutto ciò che significa l'iterazione tutto ciò che è memorizzato nella istanza di oggetto, e poi chiedere il chiamante, se va bene per serializzare le informazioni. Da un livello elevato, la funzione di serializzare tutto è implementato come segue. Nel serializzare funzionalità di tutto, due pezzi di funzionalità sono stati tagliati fuori per motivi di chiarezza e si distinguono dai commenti

/ / Rimosso per motivi di chiarezza. Fonte: / website / root / scripts / Common.js serialize: function (obj, callback) (var buffer = "("; virgola var = function () (virgola = function () (return "";) return "";) var quoteProperties = ""; canProcessFilter var = function () (return true;) functionPropertyCallback var = function () () callingStack var; if (typeof (arguments [2]) == "undefined") (callingStack = new Array () ; callingStack.push ( "cls");) else (callingStack = argomenti [2];) if (callback) (/ / rimosso per motivi di chiarezza per) (proprietà in obj) (if (canProcessFilter (obj [proprietà], obj, proprietà)) (switch (typeof (obj [proprietà])) (/ / rimosso per motivi di chiarezza))) buffer + = ")"; return buffer;)

Serializzare la funzione ha due parametri, ma per certi contesti (spiegato in seguito) vi è un terzo parametro. Il terzo parametro è stato lasciato in modo da non confondere coloro che vogliono utilizzare la funzione. Il primo parametro, obj, rappresenta l'istanza dell'oggetto che viene serializzato. Il secondo parametro, callback, rappresenta la modalità di personalizzazione che vengono chiamati quando i dati vengono serializzati. Fino a quando il ciclo è iniziato ad usare per parola chiave, le variabili sono inizializzate. Essi sono definiti come segue:

• buffer: Questa variabile è usata per creare il testo completo che rappresenta l'oggetto serializzato.

• virgola: La variabile utilizza la tecnica descritta nell'articolo 2-7 per determinare se una virgola è necessario quando si crea il JavaScript serializzato formato oggetto. Come riferimento, ogni dichiarazione di proprietà in un formato serializzato oggetto (ad esempio, (prop1: true;, prop2: false)) è separata con una virgola. La funzione implementa una tecnica in cui la prima volta che viene chiamato, non una virgola è necessario, ma per ogni chiamata, successivamente, una virgola è necessario. Senza usare la tecnica di cui all'articolo 2-7, un blocco di decisione e di bandiera sarebbe necessario.

QuoteProperties •: Questa variabile indica se il buffer contiene un doppio apice. La citazione è utilizzato durante la serializzazione l'oggetto in formato JSON.

CanProcessFilter •: Questa variabile è una funzione di callback che viene chiamata per ogni valore della proprietà trovata. Il callback restituisce true per serializzare la proprietà o false per ignorare la proprietà. Il callback ha tre parametri: la proprietà, il riferimento attuale proprietà, obj, l'oggetto viene serializzato e propertyIdentifier, l'identificatore di stringa della proprietà.

• functionPropertyCallback: Questa variabile è una funzione di callback che viene chiamato quando l'iterazione le proprietà di una funzione. Le proprietà della funzione non può essere memorizzato nella variabile buffer perché il formato serializzato non consente per la definizione delle proprietà di funzione. Le proprietà di una funzione deve essere assegnato dopo la definizione del buffer JavaScript serializzato oggetto. È per questo che la serializzazione completa di un oggetto JavaScript richiede una definizione della variabile.

CallingStack •: Per assegnare una proprietà funzione incorporata all'interno di un'altra dichiarazione oggetto JavaScript, è necessario il riferimento serializzato oggetto (ad esempio, variable.embeddedobj. Function.value). Per creare il riferimento, una pila viene utilizzato, in cui ogni elemento dello stack è un riferimento a un oggetto. Dopo le dichiarazioni, le proprietà dell'oggetto sono iterato (per (property. ..) in un ciclo. Prima di spiegare i dettagli del loop, I'll coprire la mancanza di inizializzazione di callback.

 Fonte: / website / root / scripts / Common.js if (callback) (if (callbacks.canProcessFilter) (canProcessFilter = callbacks.canProcessFilter;) if (callbacks.functionPropertyCallback) (functionPropertyCallback = callbacks.functionPropertyCallback;) if (callbacks.variablename) ( callingStack.pop (); callingStack.push (callbacks.variablename);) if (callbacks.quoteProperties) (if (callbacks.quoteProperties == true) (quoteProperties = "\" ";)))

Il chiamante della serializzazione non ha bisogno di fornire un valore per i callback. Se nessun valore viene fornito, una serializzazione di default di tutto ciò che si presume, salvo le proprietà di funzione. Le proprietà funzione non vengono serializzati perché non vi è alcun modo nel formato JavaScript serializzato oggetto di associare una proprietà funzione con la funzione. Più il codice sarà spiegato tra breve. La serializzazione ha quattro funzioni di callback:

• canProcessFilter: Usato per determinare se la proprietà può essere serializzato.

FunctionPropertyCallback •: chiamato ogni volta che una proprietà funzione è serializzato.

VariableName •: rappresenta l'identificatore variabile utilizzata quando una serializzazione di una variabile viene generato.

QuoteProperties •: Rappresenta un valore che se impostato su true genera virgolette intorno al identificatore di proprietà. Ciò è in genere utilizzato quando si genera un formato per la serializzazione JSON. Ora che abbiamo esaminato i dati di inizializzazione, passiamo ad esaminare la logica di serializzazione. Il ciclo è responsabile per serializzare l'istanza dell'oggetto, e le modalità del ciclo sono stati abbreviati. In questa fase, ti spiego la strategia complessiva. In JavaScript, ogni metodo e membro di dati è possibile accedere a un oggetto utilizzando la notazione seguente:

obj.datamember = ...

Questa notazione è il modo più comune di accedere a un metodo o un membro di dati durante la scrittura del codice sorgente. Ai fini di serializzazione non, la notazione è utile perché il programmatore è tenuto a conoscere ciò che i singoli metodi e membri di dati sono. Ai fini di serializzazione, la riflessione è necessaria. Riflessione in JavaScript è un processo in due fasi:

1. Gli identificatori valore stringa di proprietà sono disponibili servendosi di un censimento e iterata utilizzando un ciclo (ad esempio, per (di proprietà in obj)).

2. L'effettiva proprietà si accede tramite una notazione array, in cui la matrice è l'istanza dell'oggetto e l'indice è l'identificatore di valore stringa di proprietà (ad esempio, obj [proprietà]).

Come ogni proprietà viene iterato, la serializzazione query prima se la proprietà deve essere serializzato chiamando la funzione di callback canProcessFilter. Se la proprietà può essere serializzato, quindi un'istruzione switch che i test si chiama il tipo della proprietà. Typeof restituisce la funzione di sei diversi identificativi, cinque dei quali sono di interesse (non siamo interessati a non definito, come definito non deve essere serializzato). I dettagli della dichiarazione switch sono i seguenti.

 Fonte: / website / root / scripts / Common.js switch (typeof (obj [proprietà])) (case "boolean": buffer + = virgola () + quoteProperties + proprietà + quoteProperties + ":" + [oggetto di proprietà]; break; funzione di "caso": buffer + = virgola () + quoteProperties + proprietà + quoteProperties + ":" + obj [proprietà]. toString (); callingStack.push (Interno); functionPropertyCallback (obj [proprietà], obj, proprietà, callback , callingStack); callingStack.pop (); break; caso "numero": buffer + = virgola () + quoteProperties + proprietà + quoteProperties + ":" + obj [proprietà]; break; oggetto "caso": callingStack.push ( proprietà); buffer + = virgola () + quoteProperties + proprietà + quoteProperties + ":" + ops.serialize (obj [proprietà], callback, callingStack); callingStack.pop (); break; stringa "caso": buffer + = virgola () + quoteProperties + proprietà + quoteProperties + ":" + [oggetto di proprietà]; break;)

Per l'attuazione del l'istruzione switch, il numero di tipi, string, boolean e hanno una implementazione semplice serializzazione. La serializzazione di tali tipi di seguire la convenzione [identificatore di proprietà]: [valore della proprietà]. funzione e oggetto sono più complicate. Quando un oggetto viene rilevato, quindi una serializzazione JavaScript oggetto incorporato si verifica e la funzione ops.serialization è chiamato in modo ricorsivo. Il risultato della serializzazione è un valore della proprietà che viene aggiunto al buffer di essere restituito al chiamante. Le parti restanti del serializzare funzione di aggiungere una parentesi graffa di chiudere la serializzazione e riprendere il buffer generato al chiamante. La serializzazione presentata è completa, e ciascuno dei contesti utilizza la funzione di serializzazione di generare un proprio buffer generato. Prendiamo in considerazione la attuazione della funzione Serializer.toSource, che imita la serializzazione Mozilla toSource. Ciò significa che qualsiasi funzione o membro di dati definiti come parte della proprietà prototipo non viene elaborato. Ciò che viene chiesto è quello di determinare se un immobile deve essere serializzato utilizzando un filtro. L'attuazione completa del Serializer.toSource segue.

 Fonte: / website / root / scripts / jaxson / commons.js Serializer.toSource = function (obj) (return ops.serialize (obj, (currProcessedObject: null, iterPrototype: null, canProcessFilter: function (proprietà, currObj, propertyIdentifier) (if ( this.currProcessed! = currObj) (GetPrototypeObject (currObj, una funzione (prototipo) (this.iterPrototype = prototipo;)); this.currProcessed = currObj;) if (typeof (iterPrototype) == "object") (for (prototypeIdentifier in iterPrototype) (if (prototypeIdentifier == propertyIdentifier) (return false;))) return true;)));)

Per l'attuazione del Serialize.

toSource è una singola chiamata metodo, ed è a ops.serialize. Per impostazione predefinita, ops.serialize si serializzare tutto, e che dovrebbe essere evitato. Per essere in grado di distinguere tra una proprietà di istanza e una proprietà definita dalla proprietà prototipo, l'attuazione di canProcessFilter ha per capire quali proprietà sono associate con l'istanza. Nella implementazione del metodo canProcessFilter è un riferimento a GetPrototypeObject. GetPrototypeObject è una comodità funzione utilizzata per recuperare la proprietà prototipo associati con l'oggetto. I coprire la realizzazione del GetPrototypeObject poco. Per il momento, andiamo concentrarsi su ciò che accade nel filtro. Ops.serialize quando viene chiamato, itereràsu le proprietà del toSerialize dell'oggetto. Quando una proprietà viene recuperato, la funzione definita dall'utente canFilterProcess filtro viene chiamato. canFilterProcess ha come secondo parametro l'oggetto a cui la prima-to-be-proprietà serializzato appartiene.

 Fonte: / website / root / scripts / jaxson / commons.js funzione GetPrototypeObject (obj, callback) (if (typeof (obj.constructor) == "function") (var funcMatch = / funzione \ s (.*) \ (/; Var result = obj.constructor.toString (). Match (funcMatch); if (result! = Null) (if (typeof (callback) == "function") (var iterobj; if (typeof (result [1]) == "string") (eval ( "prototypePropery var =" + result [1] + ". prototipi;"); callback (prototypePropery, risultato [1]);)))))

Per l'attuazione del GetPrototypeObject, la prima prova è la verifica che la proprietà obj.constructor esiste realmente. Se la funzione non esiste, allora non c'è costruttore, e non c'è bisogno di continuare. Se la funzione non esiste, quindi una espressione regolare viene usata per estrarre il nome della funzione. L'espressione regolare l'esempio di codice è riportato in grassetto ed è riconosciuta come una espressione regolare a causa delle barre. Quando si utilizza espressioni regolari nel contesto di una stringa, la funzione di match viene chiamata e restituisce i risultati delle partite. Se ci sono dei risultati, allora è situato un identificatore che può essere utilizzato per fare riferimento alla proprietà prototype. Ma un buffer di testo e non un oggetto si trova. Il buffer di testo deve essere convertito in un oggetto, mediante l'istruzione eval. Il buffer in modo dinamico eseguito assegnerà il dichiarati localmente prototypeProperty fare riferimento alla proprietà prototype. Poi utilizzando un blocco di codice, la proprietà dell'oggetto e il codice identificativo vengono passati al chiamante. Un altro contesto è la serializzazione di un'istanza di un oggetto che include solo le funzioni dello Stato e non. Senza ancora vedere il codice, è possibile intuire che il filtro fa. I test codice filtro se la proprietà di essere filtrato è un oggetto funzione. Se la proprietà è un oggetto funzione, allora la proprietà non deve essere filtrata. E, in effetti, è così che il codice del filtro è scritto, come mostrato nel listato seguente.

 Fonte: / website / root / scripts / jaxson / commons.js Serializer.toSourceState = function (obj) (return ops.serialize (obj, (canProcessFilter: function (proprietà, obj, propertyIdentifier) ( if (typeof (proprietà) == "function") (return false;) else (return true;))));)

Il codice in grassetto mostra come verificare il tipo di oggetto utilizzando l'operatore typeof. Un altro contesto è la serializzazione di Stato alla notazione JSON. Serializzazione di JSON è come la serializzazione di uno stato, tranne che gli identificatori di proprietà sono le virgolette intorno a loro. Il codice di serializzazione è identico al codice di serializzazione di Stato, salvo che il membro quoteProperties dati è impostata su true.

 Fonte: / website / root / scripts / jaxson / commons.js Serializer.toSourceJSON = function (obj) (return ops.serialize (obj, ( quoteProperties: true,canProcessFilter: function (proprietà, obj, propertyIdentifier) (if (typeof (proprietà) == "function") (return false;) else (return true;))));)

Dopo aver esaminato i precedenti tre contesti di serializzazione, probabilmente stai pensando che il codice è relativamente simile, ma i risultati sono molto diversi. Questo è un esempio di come i blocchi di codice può essere utilizzato per separare l'iterazione generale, da un trattamento specifico. Serializzazione un altro contesto che si può usare che è simile a toSource è serializzazione con un riferimento. Il contesto di questa serializzazione è il seguente. Si sta creando un sistema in cui un tipo funge da funzionalità di base. Dopo aver istanziato il tipo, le personalizzazioni vengono eseguiti. Poi si decide di serializzare l'oggetto, ma si desidera serializzare solo le personalizzazioni, per il fatto che quando l'oggetto viene ricreato su un altro computer o un programma, si desidera una funzionalità di base diverso da utilizzare. Così, la stessa classe potrebbero operare con funzionalità di base diversi. La soluzione è quella di non serializzare le proprietà prototipo e quindi generare un buffer che crea il tipo.

Nota Io non spiegano l'attuazione degli altri tipi di contesto serializzazione perché non mostrano alcuna nuove tecniche. I riguardare soltanto come usare GetPrototypeObject in un contesto diverso e più complicato il codice del filtro. Se siete interessati a saperne di più, date un'occhiata al codice di prova nel file / website / ROOT / articles ajax / javascript / tosource.html, e in particolare il jaxson_tosource_oo metodo di prova. Serializzazione in JavaScript sembra essere una cosa semplice , e il metodo toSource appare estremamente utile. Eppure, come discusso in questo articolo, toSource è incompleta. Quando si scrive codice JavaScript per serializzare, mantenere i seguenti punti in mente:

• Serializzazione in JavaScript mezzi per generare un buffer che è formattato nel formato JavaScript Object.

• In questo articolo, non abbiamo studiare il modo per ri-creare l'oggetto serializzato. Ciò è dovuto al fatto di fare in modo che solo è necessario superare il buffer per l'istruzione eval e assegnando i risultati di

eval a una variabile.

• Serializzazione ha molti contesti diversi. Il ops.serialize funzione implementa una serializzazione molto generale che deve essere specializzato.

• Quando la serializzazione, non ci sono informazioni di tipo. Per avere informazioni sul tipo, è necessario estrarre e poi riporlo da qualche parte. Ricordo che JavaScript è un prototipo basato su linguaggio di programmazione, e sono diversi tipi di JavaScript nel concetto rispetto ai tipi in linguaggi come C # e Java.

• tecniche di questo articolo di serializzazione mostrano come definire un algoritmo che utilizza blocchi di codice per separare un blocco generale del codice di iterazione da un blocco di codice specifico contesto.

---

Disclaimer:Il nostro sito non è responsabile per il contenuto di questo articolo. Webarticles è una risorsa gratuita di informazioni.
Importante: Questo articolo "Turning toSource in una soluzione completa di serializzazione" è stato tradotto da un software automatico. Ci dispiace per eventuali errori di ortografia che possono essersi verificati. Grazie per la vostra comprensione.

---