JavaScript-Macken: Was Sie wissen müssen

JavaScript ist eine leistungsstarke und flexible Sprache, weist aber auch einige Eigenheiten auf, die selbst erfahrene Entwickler überraschen können. Wenn Sie diese seltsamen Verhaltensweisen verstehen, können Sie robusteren und fehlerfreien Code schreiben. In diesem Artikel werden wir einige der bemerkenswertesten Kuriositäten in JavaScript untersuchen.

1. Geben Sie Zwang ein

JavaScript konvertiert Typen in bestimmten Situationen automatisch, was zu unerwarteten Ergebnissen führen kann.

console.log(1 + '1'); // '11' - Number 1 is coerced to a string
console.log(1 - '1'); // 0 - String '1' is coerced to a number
console.log(true + true); // 2 - true is coerced to 1
console.log('' == 0); // true - Empty string is coerced to 0
console.log([] == 0); // true - Empty array is coerced to 0

2. NaN ist nicht gleich NaN

NaN steht für „Not-a-Number“ und wird verwendet, um einen Wert darzustellen, der keine gültige Zahl ist. Interessanterweise ist NaN nicht sich selbst gleich.

console.log(NaN === NaN); // false
console.log(Number.isNaN(NaN)); // true - Correct way to check for NaN

3. Der Typ des Operators

Der Typoperator kann einige unerwartete Ergebnisse zurückgeben.

console.log(typeof null); // 'object' - This is a long-standing bug in JavaScript
console.log(typeof []); // 'object' - Arrays are technically objects in JavaScript
console.log(typeof function(){}); // 'function' - Functions have their own type

4. Arrays hinzufügen

Das Zusammenfügen zweier Arrays kann aufgrund von Typzwang zu überraschenden Ergebnissen führen.

console.log([] + []); // '' - Both arrays are coerced to empty strings
console.log([] + {}); // '[object Object]' - Empty array is coerced to empty string, empty object is coerced to string '[object Object]'
console.log({} + []); // 0 - Here, {} is interpreted as an empty block

5. Gleitkomma-Arithmetik

JavaScript verwendet Gleitkomma-Arithmetik, was zu Präzisionsproblemen führen kann.

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3); // false

6. Der Double-Equals-Operator (==).

Der ==-Operator führt vor dem Vergleich eine Typerzwingung durch, was zu unerwarteten Ergebnissen führen kann. Im Allgemeinen ist es besser, den strikten Gleichheitsoperator (===) zu verwenden.

console.log('' == false); // true
console.log(0 == false); // true
console.log('' == 0); // true
console.log(null == undefined); // true

7. Irreführendes Scoping mit var

Mit var deklarierte Variablen sind funktionsbezogen, nicht blockbezogen, was zu unerwartetem Verhalten führen kann.

if (true) {
  var x = 5;
}
console.log(x); // 5 - x is available outside the block

for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 1000);
}
// Output: 3 3 3 - Because var is function-scoped, the same i is referenced

8. Das globale Objekt

Im Browser bezieht sich dies auf das globale Fensterobjekt im nicht-strikten Modus. Dies kann zu überraschenden Verhaltensweisen führen.

function foo() {
  console.log(this); // window (in browser)
}
foo();

const bar = {
  method: function() {
    console.log(this); // bar object
  }
};
bar.method();

const baz = bar.method;
baz(); // window (in browser)

Abschluss

JavaScript ist eine vielseitige und leistungsstarke Sprache, aber es ist wichtig, sich ihrer Eigenheiten und Eigenheiten bewusst zu sein. Wenn Sie diese seltsamen Verhaltensweisen verstehen, können Sie häufige Fallstricke vermeiden und zuverlässigeren Code schreiben. Erforschen und experimentieren Sie weiterhin mit JavaScript, um Ihr Verständnis dieser und anderer interessanter Aspekte der Sprache zu vertiefen.

---

Kennen Sie weitere Besonderheiten in Javascript? Schreib sie in die Kommentare.

Kennen Sie die grundlegenden Methoden in Javascript? Schauen Sie sich meinen Artikel hier an, um mehr zu erfahren!

Das obige ist der detaillierte Inhalt vonJavaScript-Macken: Was Sie wissen müssen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!