Rimozione e riattaccamento delle proprietà mappate alle funzioni dagli oggetti javascript

Question

Ho un'applicazione lato client esistente che fa uso di oggetti javascript che assomigliano a questo:

var myObject = {
   Id: 1,
   Name: 'Foo',
   Property1: 123,
   Property2: 'ABC',
   MyMethod: function() { ///do something },
   MyMethod2: function() { /// do something else }
};

Ora sto cercando di provare a mantenere questi oggetti usando un servizio come Firebase.A Firebase non piacciono le proprietà che contengono le funzioni, quindi voglio sapere se esiste un modo "semplice" per eliminare le funzioni offensive quando si salva in Firebase e quindi ricollegarle al recupero senza dover creare copie di ciascuno degli oggetti.

Answer 1

Un modello abbastanza comune è quello di avere una funzione costruttore con le funzioni pertinenti ad essa collegate e di avere quel costruttore che accetta una versione raw dell'oggetto che usa per popolare se stesso e una funzione "toRaw" o simile che ti dà la copia raw.

Biru:

function Thingy(raw) {
    var name;
    for (name in raw) {
        if (raw.hasOwnProperty(name)) {
            this[name] = raw[name];
        }
    }
}
Thingy.prototype.MyMethod = function() { /* ... */ };
Thingy.prototype.MyMethod2 = function() { /* ... */ };
Thingy.prototype.toRaw = function() {
    var raw, name, value;
    for (name in this) {
        if (this.hasOwnProperty(name)) {
            value = this[name];
            if (typeof value !== "function") {
                if (value.toRaw) {
                    raw[name] = value.toRaw();
                } else {
                    raw[name] = this[name];
                }
            }
        }
    }
};

Quindi quando si salva su Firebase:

write(myObject.toRaw());

...e quando si legge da Firebase:

var obj = new Thingy(read());

Una gestione più complicata comporterebbe l'inserimento di un memo sull'oggetto raw per dirti se una delle proprietà dell'oggetto sta, di per sé, usando questo modello, quindi sai di chiamare il costruttore per esso piuttosto che copiarlo.(L'occhio dell'aquila noterà che l'esempio sopra è asimmetrico, consente toRaw sulle proprietà durante la serializzazione in toRaw, ma non quando deserializing in Thingy.)