Analizar la cadena JSON en un prototipo de objeto particular en JavaScript

Sé cómo analizar una cadena JSON y convertirla en un objeto JavaScript. Puede usar JSON.parse()en navegadores modernos (e IE9 +).

Eso es genial, pero ¿cómo puedo tomar ese Objeto JavaScript y convertirlo en un Objeto JavaScript particular (es decir, con un cierto prototipo)?

Por ejemplo, suponga que tiene:

function Foo()
{
   this.a = 3;
   this.b = 2;
   this.test = function() {return this.a*this.b;};
}
var fooObj = new Foo();
alert(fooObj.test() ); //Prints 6
var fooJSON = JSON.parse({"a":4, "b": 3});
//Something to convert fooJSON into a Foo Object
//....... (this is what I am missing)
alert(fooJSON.test() ); //Prints 12

Nuevamente, no me pregunto cómo convertir una cadena JSON en un objeto JavaScript genérico. Quiero saber cómo convertir una cadena JSON en un objeto "Foo". Es decir, mi Objeto ahora debería tener una función 'prueba' y propiedades 'a' y 'b'.

ACTUALIZACIÓN Después de investigar un poco, pensé en esto ...

Object.cast = function cast(rawObj, constructor)
{
    var obj = new constructor();
    for(var i in rawObj)
        obj[i] = rawObj[i];
    return obj;
}
var fooJSON = Object.cast({"a":4, "b": 3}, Foo);

¿Eso funcionará?

ACTUALIZACIÓN Mayo de 2017 : La forma "moderna" de hacerlo es a través de Object.assign, pero esta función no está disponible en IE 11 o en navegadores Android anteriores.

Las respuestas actuales contienen mucho código enrollado a mano o de biblioteca. Esto no es necesario.

1. Use JSON.parse('{"a":1}')para crear un objeto plano.

2. Use una de las funciones estandarizadas para configurar el prototipo:

   • Object.assign(new Foo, { a: 1 })
   • Object.setPrototypeOf({ a: 1 }, Foo.prototype)

Vea un ejemplo a continuación (este ejemplo usa el objeto JSON nativo). Mis cambios se comentan en CAPITALES:

function Foo(obj) // CONSTRUCTOR CAN BE OVERLOADED WITH AN OBJECT
{
    this.a = 3;
    this.b = 2;
    this.test = function() {return this.a*this.b;};

    // IF AN OBJECT WAS PASSED THEN INITIALISE PROPERTIES FROM THAT OBJECT
    for (var prop in obj) this[prop] = obj[prop];
}

var fooObj = new Foo();
alert(fooObj.test() ); //Prints 6

// INITIALISE A NEW FOO AND PASS THE PARSED JSON OBJECT TO IT
var fooJSON = new Foo(JSON.parse('{"a":4,"b":3}'));

alert(fooJSON.test() ); //Prints 12

¿Desea agregar la funcionalidad de serialización / deserialización JSON, verdad? Entonces mira esto:

quieres lograr esto:

toJson () es un método normal.
fromJson () es un método estático.

implementación :

var Book = function (title, author, isbn, price, stock){
    this.title = title;
    this.author = author;
    this.isbn = isbn;
    this.price = price;
    this.stock = stock;

    this.toJson = function (){
        return ("{" +
            "\"title\":\"" + this.title + "\"," +
            "\"author\":\"" + this.author + "\"," +
            "\"isbn\":\"" + this.isbn + "\"," +
            "\"price\":" + this.price + "," +
            "\"stock\":" + this.stock +
        "}");
    };
};

Book.fromJson = function (json){
    var obj = JSON.parse (json);
    return new Book (obj.title, obj.author, obj.isbn, obj.price, obj.stock);
};

Uso :

var book = new Book ("t", "a", "i", 10, 10);
var json = book.toJson ();
alert (json); //prints: {"title":"t","author":"a","isbn":"i","price":10,"stock":10}

var book = Book.fromJson (json);
alert (book.title); //prints: t

Nota: Si lo desea, puede cambiar todas las definiciones de propiedades como this.title, this.author, etc por var title, var author, etc y añadir captadores a ellos para llevar a cabo la definición de UML.

Una publicación de blog que me pareció útil: comprender los prototipos de JavaScript

Puede meterse con la propiedad __proto__ del objeto.

var fooJSON = jQuery.parseJSON({"a":4, "b": 3});
fooJSON.__proto__ = Foo.prototype;

Esto permite que fooJSON herede el prototipo de Foo.

Sin embargo, no creo que esto funcione en IE ... al menos por lo que he leído.

¿Me falta algo en la pregunta o por qué nadie mencionó el reviverparámetro JSON.parsedesde 2011?

Aquí hay un código simplista para la solución que funciona: https://jsfiddle.net/Ldr2utrr/

function Foo()
{
   this.a = 3;
   this.b = 2;
   this.test = function() {return this.a*this.b;};
}


var fooObj = new Foo();
alert(fooObj.test() ); //Prints 6
var fooJSON = JSON.parse(`{"a":4, "b": 3}`, function(key,value){
if(key!=="") return value; //logic of course should be more complex for handling nested objects etc.
  let res = new Foo();
  res.a = value.a;
  res.b = value.b;
  return res;
});
// Here you already get Foo object back
alert(fooJSON.test() ); //Prints 12

PD: Su pregunta es confusa: >> Eso es genial, pero ¿cómo puedo tomar ese Objeto JavaScript y convertirlo en un Objeto JavaScript particular (es decir, con un cierto prototipo)? contradice el título, donde pregunta sobre el análisis JSON, pero el párrafo citado pregunta sobre el reemplazo del prototipo de objeto de tiempo de ejecución JS.

Se podría usar un enfoque alternativo Object.create. Como primer argumento, pasa el prototipo, y para el segundo pasa un mapa de nombres de propiedades a los descriptores:

function SomeConstructor() {
  
};

SomeConstructor.prototype = {
  doStuff: function() {
      console.log("Some stuff"); 
  }
};

var jsonText = '{ "text": "hello wrold" }';
var deserialized = JSON.parse(jsonText);

// This will build a property to descriptor map
// required for #2 argument of Object.create
var descriptors = Object.keys(deserialized)
  .reduce(function(result, property) {
    result[property] = Object.getOwnPropertyDescriptor(deserialized, property);
  }, {});

var obj = Object.create(SomeConstructor.prototype, descriptors);

Me gusta agregar un argumento opcional al constructor y llamar Object.assign(this, obj), luego manejar cualquier propiedad que sea objeto o matriz de objetos en sí:

constructor(obj) {
    if (obj != null) {
        Object.assign(this, obj);
        if (this.ingredients != null) {
            this.ingredients = this.ingredients.map(x => new Ingredient(x));
        }
    }
}

En aras de la exhaustividad, aquí hay una línea simple con la que terminé (no tuve necesidad de verificar las propiedades no Foo):

var Foo = function(){ this.bar = 1; };

// angular version
var foo = angular.extend(new Foo(), angular.fromJson('{ "bar" : 2 }'));

// jquery version
var foo = jQuery.extend(new Foo(), jQuery.parseJSON('{ "bar" : 3 }'));

Creé un paquete llamado json-dry . Admite referencias (circulares) y también instancias de clase.

Debe definir 2 nuevos métodos en su clase ( toDryen el prototipo y unDrycomo método estático), registrar la clase ( Dry.registerClass) y listo.

Si bien, esto no es técnicamente lo que desea, si conoce de antemano el tipo de objeto que desea manejar, puede usar los métodos de llamada / aplicación del prototipo de su objeto conocido.

puedes cambiar esto

alert(fooJSON.test() ); //Prints 12

a esto

alert(Foo.prototype.test.call(fooJSON); //Prints 12

Combiné las soluciones que pude encontrar y las compilé en una genérica que puede analizar automáticamente un objeto personalizado y todos sus campos de forma recursiva para que pueda usar métodos prototipo después de la deserialización.

Una suposición es que definió un archivo especial que indica que es tipo en cada objeto que desea aplicar su tipo automáticamente ( this.__typeen el ejemplo).

function Msg(data) {
    //... your init code
    this.data = data //can be another object or an array of objects of custom types. 
                     //If those objects defines `this.__type', their types will be assigned automatically as well
    this.__type = "Msg"; // <- store the object's type to assign it automatically
}

Msg.prototype = {
    createErrorMsg: function(errorMsg){
        return new Msg(0, null, errorMsg)
    },
    isSuccess: function(){
        return this.errorMsg == null;
    }
}

uso:

var responseMsg = //json string of Msg object received;
responseMsg = assignType(responseMsg);

if(responseMsg.isSuccess()){ // isSuccess() is now available
      //furhter logic
      //...
}

Función de asignación de tipo (funciona de forma recursiva para asignar tipos a cualquier objeto anidado; también itera a través de matrices para encontrar cualquier objeto adecuado):

function assignType(object){
    if(object && typeof(object) === 'object' && window[object.__type]) {
        object = assignTypeRecursion(object.__type, object);
    }
    return object;
}

function assignTypeRecursion(type, object){
    for (var key in object) {
        if (object.hasOwnProperty(key)) {
            var obj = object[key];
            if(Array.isArray(obj)){
                 for(var i = 0; i < obj.length; ++i){
                     var arrItem = obj[i];
                     if(arrItem && typeof(arrItem) === 'object' && window[arrItem.__type]) {
                         obj[i] = assignTypeRecursion(arrItem.__type, arrItem);
                     }
                 }
            } else  if(obj && typeof(obj) === 'object' && window[obj.__type]) {
                object[key] = assignTypeRecursion(obj.__type, obj);
            }
        }
    }
    return Object.assign(new window[type](), object);
}

La respuesta actualmente aceptada no estaba funcionando para mí. Necesita usar Object.assign () correctamente:

class Person {
    constructor(name, age){
        this.name = name;
        this.age = age;
    }

    greet(){
        return `hello my name is ${ this.name } and i am ${ this.age } years old`;
    }
}

Normalmente crea objetos de esta clase:

let matt = new Person('matt', 12);
console.log(matt.greet()); // prints "hello my name is matt and i am 12 years old"

Si tiene una cadena json que necesita analizar en la clase Persona, hágalo así:

let str = '{"name": "john", "age": 15}';
let john = JSON.parse(str); // parses string into normal Object type

console.log(john.greet()); // error!!

john = Object.assign(Person.prototype, john); // now john is a Person type
console.log(john.greet()); // now this works

Las respuestas de Olivers son muy claras, pero si está buscando una solución en angular js, he escrito un buen módulo llamado Angular-jsClass que facilita esta tarea, tener objetos definidos en notación literal siempre es malo cuando apunta a un gran proyecto pero diciendo que los desarrolladores enfrentan un problema que exactamente BMiner dijo, cómo serializar un json para prototipos o objetos de notación de constructor

var jone = new Student();
jone.populate(jsonString); // populate Student class with Json string
console.log(jone.getName()); // Student Object is ready to use

https://github.com/imalhasaranga/Angular-JSClass