Turning toSource dans une solution complète de sérialisation

ProblèmeVous voulez un correctif à son tour toSource dans une solution complète de sérialisation. Théorie Mozilla a développé une méthode très intelligente appelée toSource. Utilisation toSource, il est possible de sérialiser l'état d'un objet dans une mémoire tampon. Prenons l'exemple suivant le type de déclaration.

 Source: / site / ROOT / articles ajax / javascript / DefinedClass fonction tosource.html () (this.localvalue = 10; this.localmethod = function (param) (info ( "DefinedClass.localmethod", "m'a appelé");))

Le type DefinedClass a défini une méthode localmethod et un membre de données localvalue. Si le type est instancié, le type instancié toSource a une méthode qui peut être appelé, comme illustré dans le code source suivant.

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

Lorsque toSource est appelée, le tampon suivant est généré:

(Localvalue: 10, localmethod: (function (param) (info ( "DefinedClass.localmethod", "m'a appelé ");}))

Le tampon générée est une forme sérialisée d'une instance d'objet. Absent de la sérialisation est la définition de type. Lorsque l'instance d'objet est re-créé, recréé, c'est l'état de l'objet. Pourtant, ce n'est pas complètement vrai, parce que la déclaration prototype suivant est manquée par toSource.

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

Tout ce qui est déclaré par la propriété DefinedClass.prototype est manquée par la mise en œuvre toSource. Missing les propriétés de base et les méthodes de sens si le tampon toSource devaient contenir une référence au type qui a créé l'instance. Pourtant, il n'ya aucune référence à des méthodes manquantes et les propriétés, et aucun appui sur n'importe quel navigateur autre que Mozilla / Firefox. Alors, quelle est l'utilisation de toSource? La méthode toSource par elle-même est limité, mais l'idée derrière toSource est bon. Nous voulons que la capacité de sérialiser un objet à la consommation plus tard, et comme il sera démontré dans des articles ultérieurs, la sérialisation est la clé pour objet la mise en œuvre diverses techniques orientées, comme mixins. Comme illustré par la mise en œuvre de Mozilla de toSource, la sérialisation peut avoir différentes facettes . Avant de commencer une mise en œuvre de la sérialisation, nous allons identifier les différents contextes de la sérialisation:

• Plaine de sérialisation comme la vanille toSource: La sérialisation par défaut fourni par Mozilla n'est pas disponible sur les autres navigateurs. Pour les applications Web qui ne toSource utilisation, il doit y avoir une implémentation pour les autres navigateurs. Sérialisation pas les propriétés prototype est utile lorsque vous souhaitez sérialiser les informations supplémentaires et pas les informations de base.

• Composition complète exemple de sérialisation: Un exemple complet de sérialisation, c'est quand toutes les méthodes, les propriétés et les membres de données sont converties en un tampon qui, lorsqu'elle est exécutée, sera complètement re-créer l'objet. Lorsque l'instance est recréé, ses informations de type original est perdu.

• Instance étatique sérialisation: Contrairement à sérialisations autres, de la sérialisation d'État est la génération d'une mémoire tampon qui contient seulement l'état d'un objet; les déclarations de fonctions ne sont pas générées. Le code JavaScript Object Notation (JSON) Le protocole est un exemple d'un Etat par exemple-serialization seulement. Lors de la sérialisation de l'état, par exemple, les membres de données défini dans la propriété prototype sont inclus.

• Cession de sérialisation variable: Un exemple complet de sérialisation déclaration comprend tous de l'état d'une instance d'objet, mais les propriétés de fonction sont manquantes parce qu'elles pas utilisée souvent. Si une propriété fonction est utilisée, alors l'état sérialisé doit être assigné à une variable, sinon, il est très difficile d'affecter des propriétés de fonction.

• Sérialisation orientée-objet: Sérialisation orientée-objet est une extension de la sérialisation plain vanilla. La raison de la définition d'un objet de sérialisation est orientée à permettre la séparation de la classe des données spécifiques et l'instance de données spécifiques. Utilisation de la sérialisation objectoriented, un objet pourrait être sérialisé et re-créé avec le comportement par défaut différentes. Chacune des contextes est une saveur particulière de la sérialisation. La caractéristique commune à tous les contextes, c'est qu'ils sérialiser les mêmes informations et de filtrer ce qui n'est pas nécessaire. Par exemple, plaine de filtres de sérialisation de vanille tout bien référencé par prototype. Les filtres de sérialisation d'Etat en dehors de toutes les fonctions, mais parcourt propriétés référencées par prototype. Solution Dans un premier temps, nous allons créer un «général sérialiser tout» mise en œuvre. La mise en œuvre tout ce sérialiser comprendra des fonctionnalités de filtrage et de contrôle des générations de sortie. Utilisation de la sérialisation général exige un peu de compréhension du processus de sérialisation, de sorte que des ajustements sont encore possibles. Dans un deuxième temps, nous allons mettre en œuvre la sérialisation des contextes spécifiques avec les implémentations de filtrage approprié.

Sérialiser tout ce que signifie tout ce que l'itération est stocké dans l'instance d'objet, et en demandant ensuite à l'appelant s'il est OK pour sérialiser les informations. D'un niveau élevé, la fonction serialize tout est mis en oeuvre comme suit. Dans le sérialiser fonctionnalité tout, deux morceaux de fonctionnalité ont été coupés à des fins de clarté et sont notés par les commentaires

/ / Suppression de clarté. Source: / website / root / scripts / Common.js serialize: function (obj, rappels) (var buffer = "("; virgule var = function () (comma = function () (return ",";) return "";) quoteProperties var = ""; canProcessFilter var = function () (return true;) functionPropertyCallback var = function () (var) callingStack; if (typeof (arguments [2]) == "undefined") (callingStack = new Array () ; callingStack.push ( "cls");) else (callingStack arguments = [2];) if (callbacks) (/ / Suppression de clarté) for (propriété dans obj) (if (canProcessFilter (obj [des biens], obj, property)) (switch (typeof (obj [biens])) (/ / Suppression de clarté))) buffer + = ")"; buffer return;)

Le sérialiser fonction a deux paramètres, mais pour certains contextes (expliqué plus loin) il ya un troisième paramètre. Le troisième paramètre a été laissée de manière à ne pas confondre ces gens qui veulent utiliser la fonction. Le premier paramètre, obj, représente l'instance d'objet qui est sérialisé. Le second paramètre, les rappels, représente les méthodes de personnalisation qui sont appelés lorsque les données sont sérialisés. Jusqu'à la boucle est démarré en utilisant le mot-clé for, les variables sont initialisées. Ils sont définis comme suit:

• tampon: Cette variable est utilisée pour créer le texte complet qui représente l'objet sérialisé.

• virgule: Cette variable utilise la technique décrite dans l'article 2-7 à déterminer si une virgule est nécessaire à la création du format des objets JavaScript sérialisé. À titre de référence, chaque déclaration de propriété dans un format de sérialisation d'objets (par exemple, (prop1: true;, prop2: false)) est séparé par une virgule. La fonction met en oeuvre une technique dans laquelle la première fois, on l'appelle, pas de virgule est nécessaire, mais pour chaque appel par la suite, une virgule est nécessaire. Sans l'aide de la technique dans l'article 2-7, un bloc de décision et le drapeau ne serait nécessaire.

• quoteProperties: Cette variable indique si le tampon contient un guillemet. Les guillemets sont utilisés lors de la sérialisation de l'objet au format JSON.

• canProcessFilter: Cette variable est une fonction de rappel qui est appelée pour chaque valeur des objets trouvés. Le rappel retourne soit vrai pour sérialiser la propriété ou faux d'ignorer la propriété. Le rappel a trois paramètres: la propriété, la référence de la propriété effective; obj, l'objet étant numéroté et propertyIdentifier, l'identificateur de chaîne de la propriété.

• functionPropertyCallback: Cette variable est une fonction de rappel qui est appelée lorsque l'itération sur les propriétés d'une fonction. Les propriétés de la fonction ne peut pas être stockée dans la variable tampon parce que le format feuilleton ne permet pas à la définition des propriétés de la fonction. Les propriétés d'une fonction doit être attribué après la définition de la mémoire tampon de JavaScript objet sérialisé. C'est pourquoi la sérialisation complète d'un objet JavaScript nécessite une définition variable.

• callingStack: Pour attribuer une propriété fonction enchâssée dans une autre déclaration de l'objet JavaScript, vous devez disposer du numéro de série de référence d'objet (par exemple, variable.embeddedobj. Function.value). Pour créer la référence, une pile est utilisé, où chaque élément de la pile est une référence d'objet. Après les déclarations, les propriétés de l'objet sont itérées (pour (property. ..) dans une boucle. Avant d'expliquer les détails de la boucle, je vais couvrir l'initialisation de rappel manquants.

 Source: / 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 = "\" ";)))

L'appelant de la sérialisation n'a pas besoin de fournir une valeur pour les rappels. Si aucune valeur n'est fournie, une sérialisation par défaut de tout ce qui est supposé, à l'exception des propriétés de la fonction. Les propriétés de la fonction ne sont pas numérotés car il n'existe aucun moyen dans le format JavaScript objet sérialisé d'associer une propriété et de la fonction. Plus du code sera expliqué sous peu. La sérialisation a quatre fonctions de rappel:

• canProcessFilter: Permet de déterminer si le bien peut être sérialisé.

• functionPropertyCallback: Appelé à chaque fois une propriété fonction est sérialisé.

• variableName: représente l'identificateur de la variable utilisée quand une sérialisation à une variable est générée.

• quoteProperties: Représente une valeur que lorsqu'elle est définie sur true génère des guillemets autour de l'identification des immeubles. Il est généralement utilisé lors de la génération d'un format de sérialisation pour JSON. Maintenant que nous avons examiné les détails de l'initialisation, passons à l'examen de la logique de sérialisation. La boucle est responsable de la sérialisation de l'instance de l'objet et les détails de la boucle ont été abrégés. A ce stade, je vais vous expliquer la stratégie d'ensemble. En JavaScript, chaque méthode et membre de données peut être consulté sur un objet en utilisant la notation suivante:

obj.datamember = ...

Cette notation est la façon la plus courante d'accéder à une méthode ou un membre de données lors de l'écriture du code source. Aux fins de la sérialisation, la notation n'est pas utile parce que le programmeur doit savoir ce que les méthodes individuelles et les données membres sont. Aux fins de la sérialisation, la réflexion est nécessaire. Réflexion en JavaScript est un processus en deux étapes:

1. Les identificateurs de propriété valeur de la chaîne sont disponibles en utilisant une énumération et réitéré l'aide d'une boucle (par exemple, pour (propriété dans obj)).

2. La propriété effective est accessible en utilisant une notation de type tableau, où le tableau est l'instance d'objet et de l'indice est l'identificateur de valeur de chaîne de propriété (par exemple, obj [biens]).

Comme chaque propriété est réitéré, la sérialisation des requêtes d'abord si le bien doit être sérialisé en appelant la fonction de rappel canProcessFilter. Si la propriété peut être sérialisé, puis une instruction switch est demandé que les essais du type de la propriété. La fonction retourne typeof six identifiants différents, dont cinq sont d'intérêt (nous ne sommes pas intéressés par indéfini, comme non défini ne doit pas être sérialisé). Les détails de l'instruction switch sont les suivantes.

 Source: / website / root / scripts / Common.js switch (typeof (obj [biens])) (case "boolean": tampon + = virgule () + quoteProperties + propriété + quoteProperties + ":" + object [biens]; break; case "fonction": Un tampon + = virgule () + quoteProperties + propriété + quoteProperties + ":" + obj [des biens]. toString (); callingStack.push (propriété); functionPropertyCallback (obj [des biens], obj, les biens, les rappels , callingStack); callingStack.pop (); break; case "numéro": tampon + = virgule () + quoteProperties + propriété + quoteProperties + ":" + obj [biens]; break; case "objet": callingStack.push ( la propriété); buffer + = virgule () + quoteProperties + propriété + quoteProperties + ":" + ops.serialize (obj [propriété], les rappels callingStack); callingStack.pop (); break; case "string": tampon + = virgule () + quoteProperties + propriété + quoteProperties + ":" + object [biens]; break;)

Dans l'exécution de l'instruction switch, le nombre des types, string et Boolean ont une implémentation de sérialisation simple. La sérialisation de ces types de suivre la convention [identifiant biens]: [valeur de la propriété]. la fonction et l'objet sont plus compliquées. Lorsqu'un objet est trouvé, puis une JavaScript incorporé sérialisation objet se produit et la fonction ops.serialization est appelée récursivement. Le résultat de la sérialisation est une valeur de propriété qui est ajouté à la mémoire tampon pour être renvoyé à l'appelant. Les parties restantes de la fonction serialize ajouter une accolade pour fermer la sérialisation et retrouver la mémoire tampon généré à l'appelant. La sérialisation présenté est complet, et chacun des contextes utilise la fonction de sérialisation de générer son propre buffer généré. Considérons la implémentation de la fonction Serializer.toSource, qui imite la sérialisation toSource Mozilla. Cela signifie que toute fonction ou un membre de données définis dans le cadre de la propriété prototype n'est pas traitée. Ce qui est demandé est de déterminer si un bien doit être sérialisé à l'aide d'un filtre. La mise en œuvre complète de Serializer.toSource suit.

 Source: / website / root / scripts / jaxson / commons.js Serializer.toSource = function (obj) (return ops.serialize (obj, (currProcessedObject: null, iterPrototype: null, canProcessFilter: fonction (propriété, currObj, propertyIdentifier) (if ( this.currProcessed! = currObj) (GetPrototypeObject (currObj, fonction (prototype) (this.iterPrototype = prototype;)); this.currProcessed = currObj;) if (typeof (iterPrototype) == "object") (for (prototypeIdentifier dans iterPrototype) (if (prototypeIdentifier == propertyIdentifier) (return false;))) return true;)));)

Dans la mise en œuvre de sérialiser.

toSource est un appel de méthode unique, et c'est à ops.serialize. Par défaut, ops.serialize seront sérialiser tout, et qui devraient être évitées. Pour être en mesure de faire la distinction entre une propriété d'occurrence et une propriété définie par la propriété prototype, la mise en œuvre de canProcessFilter doit découvrir ce que les propriétés sont associées à l'instance. Dans l'implémentation de la méthode canProcessFilter est une référence à GetPrototypeObject. GetPrototypeObject est une commodité de fonction utilisée pour récupérer la propriété prototype associé à l'objet. Je couvre la mise en œuvre de GetPrototypeObject prochainement. Pour le moment, concentrons-nous sur ce qui se passe dans le filtre. Lorsque ops.serialize est appelé, il va parcourir les propriétés de la toSerialize objet. Lorsqu'un bien est récupéré, la fonction de filtre userdefined canFilterProcess est appelée. canFilterProcess a comme second paramètre de l'objet auquel le bientôt-to-be-propriété appartient à sérialisé.

 Source: / website / root / scripts / jaxson / commons.js fonction GetPrototypeObject (obj, callback) (if (typeof (obj.constructor) == "function") (var = funcMatch / fonction \ 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] + ". prototype;"); callback (prototypePropery, result [1]);)))))

Dans la mise en œuvre de GetPrototypeObject, le premier test est la vérification que les biens obj.constructor existe réellement. Si la fonction n'existe pas, alors il n'y a pas de constructeur, et il n'est pas nécessaire pour continuer. Si la fonction existe, alors une expression régulière est utilisée pour extraire le nom de fonction. L'expression rationnelle dans l'exemple de code est indiqué en gras et est reconnu comme une expression régulière en raison des barres obliques. Lors de l'utilisation des expressions régulières dans le cadre d'une chaîne, la fonction de recherche est appelée et renvoie les résultats du match. Si il ya des résultats, puis un identifiant est constaté que peut être utilisé pour faire référence à la propriété prototype. Mais un tampon de texte et non pas un objet est trouvé. Le tampon de texte doit être converti en un objet, en utilisant l'instruction eval. Le tampon dynamiquement exécutés va assigner la prototypeProperty déclarée localement pour faire référence à la propriété prototype. Ensuite, en utilisant un bloc de code, la propriété de l'objet et l'identifiant sont transmis à l'appelant. Un autre contexte est la sérialisation d'une instance d'objet qui ne comprend que l'État et pas de fonctions. Sans le voir encore le code, vous pouvez probablement le deviner ce que le filtre ne. Les tests de code du filtre si la propriété à filtrer est un objet fonction. Si la propriété est un objet de fonction, alors la propriété ne doit pas être filtré. Et, en effet, c'est ainsi que le code du filtre est écrit, comme le montre la liste suivante.

 Source: / website / root / scripts / jaxson / commons.js Serializer.toSourceState = function (obj) (return ops.serialize (obj, (canProcessFilter: fonction (propriété, obj, propertyIdentifier) ( if (typeof (propriété) == "function") (return false;) else (return true;))));)

Le code en gras correspond à la façon de tester le type d'objet en utilisant l'opérateur typeof. Un autre contexte est la sérialisation d'Etat à la notation JSON. Sérialiser en JSON est comme la sérialisation d'un Etat, sauf que les identifiants de propriété leur guillemets autour d'eux. Le code de sérialisation est identique au code de sérialisation État, sauf que le membre quoteProperties de données est définie sur true.

 Source: / website / root / scripts / jaxson / commons.js Serializer.toSourceJSON = function (obj) (return ops.serialize (obj, ( quoteProperties: true,canProcessFilter: fonction (propriété, obj, propertyIdentifier) (if (typeof (propriété) == "function") (return false;) else (return true;))));)

Après avoir examiné les contextes trois derniers sérialisation, vous pensez probablement que le code est relativement similaires, mais les résultats sont très différents. Ceci est un exemple de la façon dont les blocs de code peut être utilisé pour séparer l'itération générale à partir d'un traitement spécifique. Un autre contexte sérialisation que vous utiliserez qui est semblable au toSource est sérialisation à une référence. Le contexte de cette sérialisation est la suivante. Vous créez un système où un type sert de fonctionnalités de base. Après avoir taper le instancié, les personnalisations sont effectuées. Alors vous décidez de sérialiser l'objet, mais vous voulez seulement pour sérialiser les personnalisations, la raison étant que lorsque l'objet est de recréer sur un autre ordinateur ou un programme, vous voulez une fonctionnalité de base différents à utiliser. Ainsi, la même classe pourrait fonctionner avec des fonctionnalités de base différentes. La solution consiste à sérialiser pas les propriétés d'un prototype, puis générer une mémoire tampon qui instancie le type.

Note Je ne l'explique pas l'application de la sérialisation d'autres types de contexte, car ils ne montrent pas de nouvelles techniques. Je ne couvrent que la façon d'utiliser GetPrototypeObject dans un contexte différent et plus le code de filtrage complexe. Si vous êtes intéressé à en savoir plus, jetez un oeil au code de test dans le fichier / site / ROOT / articles ajax / javascript / tosource.html, et en particulier la jaxson_tosource_oo méthode d'essai. Sérialisation en JavaScript semble être une chose simple , et la méthode toSource semble extrêmement utile. Pourtant, comme nous le verrons dans cet article, toSource est incomplète. Lorsque vous écrivez du code JavaScript pour sérialiser, gardez les points suivants à l'esprit:

• Sérialisation en JavaScript moyens de générer une mémoire tampon qui est formatée dans le format JavaScript Object.

• Dans cet article, nous n'avons pas regardé comment re-créer l'objet sérialisé. C'est parce que le faire que nécessite le passage du tampon à l'instruction eval et l'affectation des résultats de

eval pour une variable.

• Sérialisation a de nombreux contextes différents. Le ops.serialize fonction implémente une sérialisation très général qui doit être spécialisé.

• Lors de la sérialisation, il n'y a aucune information de type. Pour avoir des informations de type, vous devez l'extraire et ensuite le stocker quelque part. Rappelez-vous que JavaScript est un prototype de langage de programmation, et les types de JavaScript sont différents dans le concept par rapport à des types dans des langages comme C # et Java.

• Les techniques de sérialisation de cet article montrent comment définir un algorithme qui utilise des blocs de code pour séparer un bloc général d'itération d'un bloc de code propre au contexte spécifique du code.

---

Disclaimer:Notre site n'est pas responsable du contenu de cet article. Webarticles est une ressource d'information gratuite.
Important: Cet article "Le toSource dans une solution de sérialisation complet» a été traduit par un logiciel automatique. Nous nous sentons désolés pour les fautes d'orthographe que mai ont eu lieu. Nous vous remercions de votre compréhension.

---