Come aggiungere metodi a un prototipo di un oggetto (JSON)?

Question

Diciamo che ricevo alcuni oggetti JSON dal mio server, ad es. alcuni dati per un oggetto Person:

{firstName: "Bjarne", lastName: "Fisk"} 

Ora, voglio alcuni metodi in cima a tali dati, per esempio per il calcolo del fullName:

fullName: function() { return this.firstName + " " + this.lastName; } 

In modo che posso

var personData = {firstName: "Bjarne", lastName: "Fisk"}; 
var person = PROFIT(personData); 
person.fullName(); // => "Bjarne Fisk" 

Quello che fondamentalmente vorrei fare qui, è quello di aggiungere un metodo per il prototipo dell'oggetto. Il metodo fullName() è generale, quindi non deve essere aggiunto all'oggetto dati stesso. Come ..:

personData.fullName = function() { return this.firstName + " " + this.lastName; } 

... causerebbe un sacco di ridondanza; e probabilmente "inquinano" l'oggetto dati.

Qual è l'attuale modo migliore di aggiungere tali metodi a un semplice oggetto dati?

EDIT:

Leggermente fuori tema, ma se il problema di cui sopra può essere risolto, sarebbe possibile fare qualche bella pseudo pattern matching come questo:

if (p = Person(data)) { 
    console.log(p.fullName()); 
} else if (d = Dog(data)) { 
    console.log("I'm a dog lol. Hear me bark: "+d.bark()); 
} else { 
    throw new Exception("Shitty object"); 
} 

Person e Dog sarà aggiungere i metodi se l'oggetto data ha gli attributi corretti. In caso contrario, restituire false (ad esempio, i dati non corrispondono a non corrispondono a corrispondenza/conformità).

DOMANDA BONUS: Qualcuno sa di una libreria che utilizza o abilita questo (cioè lo rende facile)? È già uno schema javascript? Se è così, come è chiamato; e hai un link che elabora? Grazie :)

Answer 1

Supponendo che il tuo oggetto provenga da una libreria JSON che analizza l'output del server per generare un oggetto, in generale non avrà nulla di particolare nel suo prototipo; e due oggetti generati per diverse risposte del server non condivideranno una catena di prototipi (oltre a Object.prototype, ovviamente;))

Se si controllano tutti i luoghi in cui una "Persona" viene creata da JSON, si potrebbero fare le cose viceversa: creare un oggetto Person "vuoto" (con un metodo come fullName nel suo prototipo) ed estenderlo con l'oggetto generato dal JSON (usando $ .extend, _.extend, o qualcosa di simile).

var p = { first : "John", last : "Doe"}; 

function Person(data) { 
    _.extend(this, data); 
} 

Person.prototype.fullName = function() { 
    return this.first + " " + this.last; 
} 

console.debug(new Person(p).fullName()); 

Answer 2

Non penso che sia comune il trasporto di metodi con i dati, ma sembra una grande idea.

Questo progetto consente di codificare le funzioni insieme ai dati, ma non è considerato standard e richiede la decodifica con la stessa libreria, naturalmente.

https://github.com/josipk/json-plus 

Answer 3

Se hai a che fare con i dati JSON pianura poi il prototipo di ogni oggetto persona sarebbe semplicemente Object.prototype.Al fine di farne un oggetto con un prototipo di Person.prototype si sarebbe prima di tutto bisogno di un Person costruttore e prototipo (supponendo che si sta facendo Javascript OOP in modo tradizionale):

function Person() { 
    this.firstName = null; 
    this.lastName = null; 
} 
Person.prototype.fullName = function() { return this.firstName + " " + this.lastName; } 

allora si sarebbe bisogno di un modo per trasformare un oggetto semplice in un oggetto Person, ad es se si ha una funzione chiamata mixin che semplicemente copiato tutte le proprietà da un oggetto all'altro, si potrebbe fare questo:

//example JSON object 
var jsonPerson = {firstName: "Bjarne", lastName: "Fisk"}; 

var person = new Person(); 
mixin(person, jsonPerson); 

Questo è solo un modo di risolvere il problema, ma dovrebbe spera darvi alcune idee.

---

Aggiornamento: Ora che Object.assign() è disponibile nei browser moderni, è possibile utilizzare che invece di scrivere la propria funzione mixin. C'è anche uno shim per far funzionare Object.assign() sui browser più vecchi; vedi https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign#Polyfill.

Answer 4

Gli oggetti anonimi non hanno un prototipo. Perché non basta avere questo:

function fullName(obj) { 
    return obj.firstName + ' ' + obj.lastName; 
} 

fullName(person); 

Se è assolutamente necessario utilizzare una chiamata di metodo, invece di una chiamata di funzione, si può sempre fare qualcosa di simile, ma con un oggetto.

var Person = function (person) { this.person = person; } 
Person.prototype.fullName = function() { 
    return this.person.firstName + ' ' + this.person.lastName; 
} 
var person = new Person(personData); 
person.fullName(); 

Answer 5

Probabilmente non dovresti farlo.

JSON consente di serializzare uno stato, non un tipo. Quindi nel tuo caso d'uso, si dovrebbe fare qualcosa di simile:

var Person = function (data) { 
    if (data) { 
     this.firstName = data.firstName; 
     this.lastName = data.lastName; 
    } 
}; 

Person.prototype.fullName = function () { 
    return this.firstName + ' ' + this.lastName; 
}; 

// 

var input = '{"firstName":"john", "lastName":"Doe"}'; 
var myData = JSON.parse(input); 
var person = new Person(myData); 

Answer 6

In altre parole si vuole cambiare prototipo (classe pseudonimo) di oggetto esistente. Tecnicamente si può fare in questo modo:

var Person = { 
    function fullName() { return this.firstName + " " + this.lastName; } 
}; 

// that is your PROFIT function body: 
personData.__proto__ = Person ; 

Dopo di che, se si ottengono true su personData instanceof Person

Answer 7

C'è un'altra possibilità qui. JSON.parse accetta un secondo parametro, che è una funzione utilizzata per rianimare gli oggetti rilevati, dai nodi foglia al nodo radice. Quindi, se riesci a riconoscere i tuoi tipi in base alle loro proprietà intrinseche, puoi costruirli in una funzione di reviver. Ecco un esempio molto semplice di farlo:

var MultiReviver = function(types) { 
    // todo: error checking: types must be an array, and each element 
    //  must have appropriate `test` and `deserialize` functions 
    return function(key, value) { 
     var type; 
     for (var i = 0; i < types.length; i++) { 
      type = types[i]; 
      if (type.test(value)) { 
       return type.deserialize(value); 
      } 
     } 
     return value; 
    }; 
}; 

var Person = function(first, last) { 
    this.firstName = first; 
    this.lastName = last; 
}; 
Person.prototype.fullName = function() { 
    return this.firstName + " " + this.lastName; 
}; 
Person.prototype.toString = function() {return "Person: " + this.fullName();}; 
Person.test = function(value) { 
    return typeof value.firstName == "string" && 
      typeof value.lastName == "string"; 
}; 
Person.deserialize = function(obj) { 
    return new Person(obj.firstName, obj.lastName); 
}; 

var Dog = function(breed, name) { 
    this.breed = breed; 
    this.name = name; 
} 
Dog.prototype.species = "canine"; 
Dog.prototype.toString = function() { 
    return this.breed + " named " + this.name; 
}; 
Dog.test = function(value) {return value.species === "canine";}; 
Dog.deserialize = function(obj) {return new Dog(obj.breed, obj.name);}; 


var reviver = new MultiReviver([Person, Dog]); 

var text = '[{"firstName": "John", "lastName": "Doe"},' + 
      '{"firstName": "Jane", "lastName": "Doe"},' + 
      '{"firstName": "Junior", "lastName": "Doe"},' + 
      '{"species": "canine", "breed": "Poodle", "name": "Puzzle"},' + 
      '{"species": "canine", "breed": "Wolfhound", "name": "BJ"}]'; 

var family = JSON.parse(text, reviver) 
family.join("\n"); 

// Person: John Doe 
// Person: Jane Doe 
// Person: Junior Doe 
// Poodle named Puzzle 
// Wolfhound named BJ 

Questo dipende da voi essere in grado di riconoscere in modo inequivocabile i tipi di. Ad esempio, se ci fosse un altro tipo, anche un sottotipo di Persona, che aveva anche proprietà firstName e lastName, questo non avrebbe funzionato. Ma potrebbe coprire alcuni bisogni.

Answer 8

Non è necessario utilizzare i prototipi per associare un metodo personalizzato nell'oggetto barebone.

Ecco un esempio elegante che non inquinano il codice evitando codice ridondante

var myobj = { 
    title: 'example', 
    assets: 
    { 
    resources: ['zero', 'one', 'two'] 
    } 
} 

var myfunc = function(index) 
{ 
    console.log(this.resources[index]); 
} 

myobj.assets.giveme = myfunc 

myobj.assets.giveme(1); 

Esempio disponibile in https://jsfiddle.net/bmde6L0r/

Answer 9

Utilizzare il nuovo-ish Object.setPrototypeOf(). (È supportato da IE11 e da tutti gli altri browser ora.)

Si potrebbe creare una classe/prototipo che comprendeva i metodi che si desidera, come il tuo fullName(), e poi

Object.setPrototypeOf(personData, Person.prototype); 

Come l'avviso (a pagina MDN linkato sopra) suggerisce, questa funzione è non essere usato alla leggera, ma ha senso quando si cambia il prototipo di un oggetto esistente, e questo è ciò che sembra essere dopo.