Buscamos por distintos espacios y de este modo mostrarte la solución a tu dilema, si tienes alguna pregunta puedes dejar la inquietud y respondemos sin falta, porque estamos para servirte.
Solución:
JSON no tiene funciones como tipos de datos. Solo puede serializar cadenas, números, objetos, matrices y valores booleanos (y null)
Podrías crear el tuyo propio toJson método, solo pasando los datos que realmente tienen que ser serializados:
Person.prototype.toJson = function()
return JSON.stringify(age: this.age);
;
Similar para deserializar:
Person.fromJson = function(json)
var data = JSON.parse(json); // Parsing the json string.
return new Person(data.age);
;
El uso sería:
var serialize = p1.toJson();
var _p1 = Person.fromJson(serialize);
alert("Is old: " + _p1.isOld());
Para reducir la cantidad de trabajo, podría considerar almacenar todos los datos que deben serializarse en una propiedad de “datos” especial para cada Person ejemplo. Por ejemplo:
function Person(age)
this.data =
age: age
;
this.isOld = function ()
return this.data.age > 60 ? true : false;
entonces serializar y deserializar es simplemente llamar JSON.stringify(this.data) y establecer los datos de una instancia sería instance.data = JSON.parse(json).
Esto mantendría la toJson y fromJson métodos simples pero tendrías que ajustar tus otras funciones.
Nota al margen:
Debes agregar el isOld método al prototipo de la función:
Person.prototype.isOld = function()
De lo contrario, cada instancia tiene su propia instancia de esa función que también aumenta la memoria.
escribí serializar porque me enfrenté al mismo problema que tú.
puedes encontrarlo en https://github.com/erossignon/serialijse
Puede usarse en nodejs o en un navegador y puede servir para serializar y deserializar un conjunto complejo de objetos de un contexto (nodejs) a otro (navegador) o viceversa.
var s = require("serialijse");
var assert = require("assert");
// testing serialization of a simple javascript object with date
function testing_javascript_serialization_object_with_date()
var o =
date: new Date(),
name: "foo"
;
console.log(o.name, o.date.toISOString());
// JSON will fail as JSON doesn't preserve dates
try
var jstr = JSON.stringify(o);
var jo = JSON.parse(jstr);
console.log(jo.name, jo.date.toISOString());
catch (err)
console.log(" JSON has failed to preserve Date during stringify/parse ");
console.log(" and has generated the following error message", err.message);
console.log("");
var str = s.serialize(o);
var so = s.deserialize(str);
console.log(" However Serialijse knows how to preserve date during serialization/deserialization :");
console.log(so.name, so.date.toISOString());
console.log("");
testing_javascript_serialization_object_with_date();
// serializing a instance of a class
function testing_javascript_serialization_instance_of_a_class()
function Person()
this.firstName = "Joe";
this.lastName = "Doe";
this.age = 42;
Person.prototype.fullName = function ()
return this.firstName + " " + this.lastName;
;
// testing serialization using JSON.stringify/JSON.parse
var o = new Person();
console.log(o.fullName(), " age=", o.age);
try
var jstr = JSON.stringify(o);
var jo = JSON.parse(jstr);
console.log(jo.fullName(), " age=", jo.age);
catch (err)
console.log(" JSON has failed to preserve the object class ");
console.log(" and has generated the following error message", err.message);
console.log("");
// now testing serialization using serialijse serialize/deserialize
s.declarePersistable(Person);
var str = s.serialize(o);
var so = s.deserialize(str);
console.log(" However Serialijse knows how to preserve object classes serialization/deserialization :");
console.log(so.fullName(), " age=", so.age);
testing_javascript_serialization_instance_of_a_class();
// serializing an object with cyclic dependencies
function testing_javascript_serialization_objects_with_cyclic_dependencies()
var Mary = name: "Mary", friends: [] ;
var Bob = name: "Bob", friends: [] ;
Mary.friends.push(Bob);
Bob.friends.push(Mary);
var group = [ Mary, Bob];
console.log(group);
// testing serialization using JSON.stringify/JSON.parse
try
var jstr = JSON.stringify(group);
var jo = JSON.parse(jstr);
console.log(jo);
catch (err)
console.log(" JSON has failed to manage object with cyclic deps");
console.log(" and has generated the following error message", err.message);
// now testing serialization using serialijse serialize/deserialize
var str = s.serialize(group);
var so = s.deserialize(str);
console.log(" However Serialijse knows to manage object with cyclic deps !");
console.log(so);
assert(so[0].friends[0] == so[1]); // Mary's friend is Bob
testing_javascript_serialization_objects_with_cyclic_dependencies();
Soy el autor de https://github.com/joonhocho/seri.
Seri es JSON + compatibilidad con clases personalizadas (anidadas).
Simplemente necesita proporcionar toJSON y fromJSON para serializar y deserializar cualquier instancia de clase.
Aquí hay un ejemplo con objetos de clase anidados:
import seri from 'seri';
class Item
static fromJSON = (name) => new Item(name)
constructor(name)
this.name = name;
toJSON()
return this.name;
class Bag
static fromJSON = (itemsJson) => new Bag(seri.parse(itemsJson))
constructor(items)
this.items = items;
toJSON()
return seri.stringify(this.items);
// register classes
seri.addClass(Item);
seri.addClass(Bag);
const bag = new Bag([
new Item('apple'),
new Item('orange'),
]);
const bagClone = seri.parse(seri.stringify(bag));
// validate
bagClone instanceof Bag;
bagClone.items[0] instanceof Item;
bagClone.items[0].name === 'apple';
bagClone.items[1] instanceof Item;
bagClone.items[1].name === 'orange';
Espero que ayude a resolver su problema.
Nos puedes añadir valor a nuestro contenido colaborando tu experiencia en las notas.