Wie zu verstehen, wenn (Name in {}) in Javascript?

Question

begegne ich eine js Funktion Schnipsel, die Liste als

each = function(obj, fun) { 
    if (typeof fun != "function") { 
     return obj 
    } 
    if (obj) { 
     var return_value; 
     if (obj.length === undefined) { 
      for (var name in obj) { 
       if (name in {}) { // how to undertand this line, what's purpose? 
        continue 
       } 
       return_value = fun.call(obj[name], obj[name], name); 
       if (return_value == "break") { 
        break 
       } 
      } 
     } else { 
      for (var i = 0, 
      length = obj.length; i < length; i++) { 
       return_value = fun.call(obj[i], obj[i], i); 
       if (return_value == "break") { 
        break 
       } 
      } 
     } 
    } 
    return obj 
}; 

Vielen Dank für Ihre Antwort :)

Answer 1

In ist ein spezieller Operator folgt, die true zurück, wenn die angegebene Eigenschaft in das angegebene Objekt ist .

Von https://developer.mozilla.org/en/JavaScript/Reference/Operators/Special_Operators/in_Operator

Jedes Objekt, einschließlich {}, erbt Eigenschaften von Object.prototype. Die if hier macht die Schleife weiter, wenn name eine dieser geerbten Eigenschaften ist.

Beispiel: console.log('toString' in {}); Protokolle true. console.log('customProperty' in {}); meldet falsch.

Answer 2

Was es tut, ist zu sehen, ob dieser Eigenschaftsname in einem leeren Objekt existiert. Zum Beispiel filtert es toString heraus (auf Implementierungen, die über toString und in nicht buggy sind; IE ist).

Es kann ein Versuch sein, um Leute zu arbeiten, die Sachen zum Object.prototype hinzufügen (was eine sehr, sehr schlechte Idee ist). Zum Beispiel:

Object.prototype.foo = "bar"; // <== VERY BAD IDEA 
alert({}.foo); // alerts "bar" 

function Thingy(a, b) { 
    this.a = a; 
    this.b = b; 
} 
Thingy.prototype.x = 42; 

var t = new Thingy(1, 2); 

Wenn ich will t kopieren, einschließlich der vererbten x Eigentum von Thingy aber nicht einschließlich der foo Eigenschaft es von Object erbt, könnte ich das if (name in {}) verwenden diejenigen zu überspringen.

Wohlgemerkt, es ist nicht eine sehr intelligente Art und Weise, das zu tun, da es wird scheitern, wenn ich dies tun:

var t = new Thingy(1, 2); 
t.foo = "charlie"; 

Jetzt t hat seine eigenefoo, die vermutlich hätte ich gewünscht haben zu kopieren .

würde eine genauere Überprüfung sein: nur diejenigen herauszufiltern

dest = {}; 
blank = {}; // No need to recreate it on every iteration 
for (name in src) { 
    if (src.hasOwnProperty(name) || !(name in blank)) { 
     dest[name] = src[name]; 
    } 
} 

Das wird die vererbt werden, oder zumindest könnte, von Object vererbt werden. Aber selbst das ist fehlerhaft; Was passiert, wenn es einen Wert für die Eigenschaft erbt, aber nicht den Wert von Object (z. B. etwas in der Mitte   — Thingy vielleicht   — hat Object 's Standard überschrieben)?

Sie können also diesen Code, den Sie geerbt haben, wahrscheinlich umgestalten, wahrscheinlich in Bezug auf die Verwendung von hasOwnProperty und sicherstellen, dass nichts in Ihrer Anwendung Dinge auf Object.prototype setzt.

Answer 3

Die in operator gibt true zurück, wenn im zweiten Operanden eine Eigenschaft mit dem Bezeichner des ersten Operanten existiert und andernfalls falsch. So prüft name in {}, ob es eine Eigenschaft mit dem Namen des Werts name gibt.

Dies scheint wahrscheinlich seltsam, da {} scheint keine Eigenschaften zu haben. Aber ein einfaches Objekt erbt einige der Eigenschaften von Object.prototype. So gibt "toString" in {} True zurück, da es Object.prototype.toString gibt. Es gibt auch die hasOwnProperty-Methode geerbt von Object.prototype.hasOwnProperty, die stattdessen verwendet werden kann.