Conversions implicites en JavaScript et synthèse (recommandé)

Les règles de comparaison et de conversion entre les différents types de données en JavaScript sont les suivantes :

1. Comparaison des objets et des valeurs booléennes

Lors de la comparaison entre un objet et une valeur booléenne, l'objet est d'abord converti en chaîne, puis en nombre, et la valeur booléenne est directement convertie en nombre.

[] === true; //false [] converti en chaîne '', puis en nombre 0, true converti en nombre1donc c'est faux

2. Comparaison objet et chaîne

Lors de la comparaison entre un objet et une chaîne, l'objet est converti en chaîne puis comparé avec la chaîne.

[1,2,3] === '1,2,3' // true [1,2,3] converti en '1,2,3' puis et '1,2,3' donc le résultat est true;

3. Comparaison objet et nombre

Lors de la comparaison entre un objet et un nombre, l'objet est d'abord converti en chaîne, puis en nombre, puis comparé avec le nombre.

[1] === 1; // true `L'objet est d'abord converti en chaîne puis en nombre, puis comparé avec [1] => '1' => 1 Donc le résultat est true

4. Comparaison chaîne et nombre

Lors de la comparaison entre une chaîne et un nombre, la chaîne est convertie en nombre avant la comparaison.

'1' === 1 // true

5. Comparaison chaîne et booléenne

Lors de la comparaison entre une chaîne et une valeur booléenne, les deux sont converties en nombre avant la comparaison.

'1' === true; // true

6. Comparaison booléenne et nombre

Lors de la comparaison entre une valeur booléenne et un nombre, la valeur booléenne est convertie en nombre avant la comparaison.

true === 1 // true

Beaucoup de débutants en JavaScript sont confus par ces règles de conversion, mais en réalité, la règle est simple, vous pouvez vous souvenir de ce graphique ci-dessous

如图，quand deux types différents sont comparés, s'ils ne sont pas de la même type, ils sont convertis en type correspondant comme indiqué dans le graphique, par exemple, si un objet et un booléen sont comparés, l'objet => la chaîne => le nombre, le booléen => le nombre.
De plus, regardons certains qui nécessitent une attention "spéciale".

Regardons un problème intéressant

[] == false;
![] == false;

Les deux résultats sont true, le premier est, l'objet => la chaîne => le nombre 0 false converti en nombre 0, ce qui devrait être correct,
Si la deuxième avant a un ! supplémentaire, elle est directement convertie en valeur booléenne puis inversée. Lors de la conversion en valeur booléenne, les valeurs vides (''), NaN, 0, null, undefined retournent toutes true. Donc ! [] cette [] => true, inversé pour false, donc [] == false retourne true.

Il y a encore quelques choses à retenir, comme :

undefined == null //true undefined et null comparent retourner true, et comparés avec d'autres valeurs retourner false
Number(null) //0

J'ai vu un tel code : (!(~++--++*++++++*~+[]]] = sb, est-ce que vous pouvez croire, à l'époque, j'ai beaucoup été surprise.

Lorsque je l'ai découvert pour la première fois, JavaScript m'a beaucoup dérangement, c'est précisément à cause de son 'changement', voici un résumé :

7. Types de données JS: Number, Boolean, String, Undefined, Null, Symbol (es6Nouveau type (note : Array est un type spécial d'Object)

　　　　Le typeof retourne7Types de données : number boolean string object undefined object function

MDN présente JavaScript ainsi : JavaScript est un langage de type faible ou dynamique. Cela signifie que vous n'avez pas besoin de déclarer le type d'une variable à l'avance, le type est déterminé automatiquement pendant l'exécution du programme. Cela signifie également que vous pouvez utiliser la même variable pour stocker des données de différents types

8. Voici quelques exemples de conversions implicites courantes :

　　Types de base :

　　　Opérateur (+,-,*,/,%）Conversion de type lors de l'opération

　　　　"+Opérateur : " 　　

　　　　　　Résumé : Lors de l'opérateur deaddition, String et d'autres types sont convertis en String ; dans d'autres cas, ils sont convertis en type Number, notez que undefined est converti en Number pour 'NaN', toute addition de Number avec NaN donne NaN.

　　　　　　　　　Lors des autres opérateurs, les types de base sont convertis en Number, les types String qui contiennent des caractères, par exemple : '1a' ,'a1' est converti en NaN comme undefined.

　　　　　　tip：(1)NaN ne s'égalise à aucune valeur, y compris elle-même, donc pour déterminer si une valeur est NaN, il suffit d'utiliser "!==".　　

　　　　　　　　（2) Les valeurs converties en Boolean pour false sont : null, 0, '', undefined, NaN, false　　

　　　　　　　　（3）number（） et parseInt（） peuvent tous convertir un objet en type Number, la fonction Number est beaucoup plus stricte que la fonction parseInt. En règle générale, si un caractère ne peut pas être converti en nombre, toute la chaîne sera convertie en NaN.　　

　　Type Object

　　　　Lorsque l'object est opéré avec des types de base :

var obj = {
  toString: function(){
    return 6;
  },
  valueOf: function(){
    return 5;
  }
};
var obj1 = {
  valueOf: function(){
    return 'a';
  },
  toString: function(){
    return 'b';
  }
};

　　　　　　　　　　　　Lorsque l'on traite obj,obj1 Lors du passage de Number() et String()

　　　　　　　　　　　　Résumé : Le type Number appelle d'abord valueOf(), le type String appelle d'abord toString(), si le résultat est une valeur primitive, il est retourné, sinon, continuez à utiliser toString ou valueOf, continuez à calculer, si le résultat n'est pas une valeur primitive, une erreur de type est levée;　

　　　　Voyons le cas suivant :

Pourquoi {} + [] = 0 &63; Parce que JavaScript considère le premier {} comme un bloc de code vide lors de l'exécution, donc c'est équivalent à +[] = 0. Il y a aussi {} +5 = 5, de même.

Résumé :

1. Les erreurs de type peuvent être cachées par la conversion de type.

2. “+”peut être utilisé à la fois pour la concaténation de chaînes et pour l'addition arithmétique, cela dépend de ses opérandes, si l'un d'eux est une chaîne, alors c'est une concaténation de chaînes.

3. Les objets se convertissent en nombres via la méthode valueOf, et en chaînes via la méthode toString.

4. Les objets qui ont une méthode valueOf doivent définir une méthode toString correspondante pour retourner la forme en chaîne de la valeur égale.

5. Lorsque vous détectez des variables non définies, vous devez utiliser typeof ou la comparaison avec undefined, et ne pas utiliser directement l'opérateur de vérité.

Résumé

Voici quelques conversions implicites et résumés (recommandés) de JavaScript que l'éditeur vous présente, j'espère qu'ils vous seront utiles. Si vous avez des questions, n'hésitez pas à laisser des messages, l'éditeur vous répondra à temps. Merci également de votre soutien au tutoriel d'interjection !

Déclaration : Le contenu de cet article est partagé sur Internet, la propriété intellectuelle appartient à ses auteurs respectifs, le contenu est téléchargé par les utilisateurs d'Internet, ce site Web ne détient pas de propriété, n'a pas été traité par l'édition humaine et n'assume pas de responsabilité juridique connexe. Si vous trouvez du contenu susceptible de violer les droits d'auteur, veuillez envoyer un e-mail à : notice#w3Déclaration : Le contenu de cet article est tiré du réseau, la propriété intellectuelle appartient à ses auteurs respectifs, le contenu est contribué et téléchargé par les utilisateurs d'Internet, ce site Web ne détient pas de propriété, n'a pas été traité par l'édition humaine et n'assume pas de responsabilité juridique connexe. Si vous trouvez du contenu susceptible de violer les droits d'auteur, veuillez envoyer un e-mail à : notice#w

Tutoriel de base