bizarreries JavaScript : ce que vous devez savoir

JavaScript est un langage puissant et flexible, mais il présente également quelques bizarreries qui peuvent surprendre même les développeurs expérimentés. Comprendre ces comportements étranges peut vous aider à écrire du code plus robuste et sans bug. Dans cet article, nous explorerons certaines des bizarreries les plus notables de JavaScript.

1. Tapez Coercition

JavaScript convertit automatiquement les types dans certaines situations, ce qui peut conduire à des résultats inattendus.

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 n'est pas égal à NaN

NaN signifie "Not-a-Number" et est utilisé pour représenter une valeur qui n'est pas un nombre valide. Fait intéressant, NaN n’est pas égal à lui-même.

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

3. Le type d'opérateur

L'opérateur typeof peut renvoyer des résultats inattendus.

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. Ajout de tableaux

L'ajout de deux tableaux peut produire des résultats surprenants en raison de la coercition de type.

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. Arithmétique à virgule flottante

JavaScript utilise l'arithmétique à virgule flottante, ce qui peut entraîner des problèmes de précision.

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

6. L'opérateur Double égal (==)

L'opérateur == effectue une coercition de type avant la comparaison, ce qui peut conduire à des résultats inattendus. Il est généralement préférable d'utiliser l'opérateur d'égalité stricte (===).

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

7. Portée trompeuse avec var

Les variables déclarées avec var sont limitées à une fonction et non à un bloc, ce qui peut entraîner un comportement inattendu.

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. L'objet global

Dans le navigateur, cela fait référence à l'objet fenêtre global en mode non strict. Cela peut provoquer des comportements surprenants.

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)

Conclusion

JavaScript est un langage polyvalent et puissant, mais il est important d'être conscient de ses bizarreries et de ses particularités. En comprenant ces comportements étranges, vous pouvez éviter les pièges courants et écrire un code plus fiable. Continuez à explorer et à expérimenter JavaScript pour approfondir votre compréhension de ces aspects et d’autres aspects intéressants du langage.

---

Connaissez-vous d’autres bizarreries en Javascript ? Écrivez-les dans les commentaires.

Connaissez-vous les méthodes de base en Javascript ? Consultez mon article ici pour en savoir plus !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!