Disappearing funzione di oggetto?

Question

C'è una ragione per le funzioni oggetto da disinserire o cancellato o semplicemente non applicato per qualsiasi ragione a tutti che non è intenzionale?

Sto mantenimento del codice qualcun'altro e passati attraverso molte volte. Io uso Google Chromes debugger impressionante e anche TextMate. Questi aiutarmi a trovare l'origine dell'errore relativamente veloce.

Il problema che ho ora è che ho un oggetto: i tipi. Questo oggetto contiene ... tipo. E questi tipi hanno funzioni e altre variabili ad essi connessi.

Per qualche ragione nel mezzo del codice, questo tipo è stato approvato da milioni di riferimento di volte, probabilmente. Quando si tratta di una certa parte delle parti di codice di esso, sembrano essere scomparsi. Puff! Ed è andato ..!

Qualcuno ha un indizio (diverso da quello che viene rimosso da qualche altra parte in precedenza nel codice, sto già cercando per questo)

Esempio

In questo momento sto semplicemente aggiungendo le funzioni al volo. Non gradire però, si sentono un po 'fuori controllo del codice:

if(identifier.kind.hasOwnProperty('getWarning')) {
    identifier.kind.getWarning = CLEANROOM.types[kind].getWarning;
}

Answer 1

No, le proprietà degli oggetti non sarà misteriosamente sparire per nessun motivo - almeno, non estingue i bug di attuazione, che dovrebbe essere facilmente esclusa vedendo se la stessa cosa accade in Internet Explorer, Chrome e Firefox, che hanno i loro proprie (e molto diversi) implementazioni di Javascript.

Se uno di questi strati avviene indirettamente , però, che è un altro discorso. Ad esempio, se ad un certo punto qualcosa è serializzazione l'oggetto in una stringa JSON e poi ricostituzione, il risultato sarà un oggetto con quasi tutti gli oggetti con dati associati a loro, ma nessuno di quelli con funzioni legate ad essi. Ma questo non sta passando un riferimento intorno, che è la serializzazione e deserializzazione.

La stessa cosa potrebbe accadere se qualcosa sta facendo una copia in questo modo:

dest = {};
for (name in src) {
    value = src[name];
    if (typeof value !== "function") {
        dest[name] = value;
    }
}

per es., Qualcosa facendo un dato Copia in sola. Può anche accadere di meno, ovviamente, se qualcosa fa questo:

function clone(src) {
    dest = {};
    for (name in src) {
        if (src.hasOwnProperty(name)) {
            dest[name] = src[name];
        }
    }
    return dest;
}

Che fa una copia "superficiale" dell'oggetto, copiando solo le proprietà che si è fissata su di esso, in sé, e ignorando tutte le proprietà che riceve dal suo prototipo. La maggior parte (ma da tutti alcun modo) delle proprietà oggetti ereditano dai loro prototipi tendono per essere funzioni, e quindi il risultato di questo può sembrare un dato Copia in sola. Esempio:

function Thingy() {
}
Thingy.prototype.foo = function() {
}
var t = new Thingy();
t.bar = 42;
// `t` has a `foo` function bound to it, indirectly through its prototype,
// and a `bar` property with the value 42
var x = clone(t);
// `x` does *not* have a `foo` function, but it does have a `bar` property,

Naturalmente, è possibile anche proprietà felicemente eliminazione dagli oggetti che fanno riferimento a funzioni:

for (name in obj) {
    if (typeof obj[name] === "function" && obj.hasOwnProperty(name)) {
        delete obj[name];
    }
}

Ma ancora una volta, che non è implicita, che è esplicito. Ma se è nascosto in una funzione operaio da qualche parte, sarebbe abbastanza facile da perdere.