Tout d'abord, faisons d'abord quelques questions! Pour unifier, je ne mélange pas ces questions. Dans les questions d'entrevue, je mélange souvent ces questions, ce qui vous rendra plus confus. Afin de le rendre plus pratique pour la démonstration, j'ai écrit quelques questions dans des modules ici, afin que vous puissiez le lire!
Conversion implicite des chaînes d'opérateur
multiplication
console.dir ("--------------------------"); console.dir (5 * "5"); console.dir (5 * "a"); console.dir (5 * nan); console.dir (5 * null); console.dir (5 * non défini); console.dir (5 * 5); console.dir("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------division
console.dir ("----------------------"); console.dir (5 / "5"); console.dir (5 / "a"); console.dir (5 / nan); console.dir (5 / null); console.dir (null / 5); Console.dir (5 / Undefined); Console.dir (5/5); Console.dir (5/0); console.dir (0/5); console.dir (0/0); console.dir ("------------------------"); console.dir ("------------------------------");Prenez le reste et trouvez le modèle
console.dir ("---------------------------"); Console.dir (16% "5"); console.dir (5% "A"); Console.dir (5% NAN); Console.dir (5% nul); console.dir (null% 5); console.dir (5% non défini); console.dir (5% 5); console.dir (5% 0); console.dir (0% 5); console.dir (0% 0); console.dir ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ajout
console.dir ("-----------------------"); console.dir (16+ "5"); console.dir (5+ "a"); console.dir (5 + nan); console.dir (5 + null); console.dir (5 + non défini); console.dir (5 + 5); console.dir ("La somme de deux nombres est" + 5 + 5); console.dir ("La somme de deux nombres est" + (5 + 5)); console.dir("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Soustraction
console.dir ("----------------------"); Console.dir (16- "5"); console.dir (5- "a"); Console.dir (5-NAN); console.dir (5-null); console.dir (5-défini); console.dir (5-5); console.dir (5 true); console.dir (5- "true); console.dir (5-" "); console.dir (" La différence entre deux nombres est "+ 5-5); console.dir (" la différence entre deux nombres est "+ (5-5)); console.dir (" ------------------ "); console.dir (" ------------------ "); console.dir ("-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Opérateurs relationnels
console.dir ("--------------------"); console.dir (16> "5"); console.dir ("16"> "5"); console.dir (5 <"a"); console.dir (5> = nan); console.dir (5 <nan); console.dir (nan> = nan); console.dir (5> = null); console.dir (5> = non défini); console.dir (5> = 5); console.dir (5> = true); console.dir (5> = "true"); console.dir (5> = ""); console.dir ("brique"> "alphabet"); console.dir ("brique"> "alphabet"); console.dir ("---------------------");multiplication
console.dir (5 * "5"); // 25 console.dir (5 * "a"); // nan console.dir (5 * nan); // nan console.dir (5 * null); 0 console.dir (5 * non défini); // nan console.dir (5 * 5); // 25
Parlons du principe de la conversion implicite de la multiplication:
1. Si les deux valeurs sont des nombres, effectuez directement les opérations de multiplication. (Je crois que tout le monde peut le faire, tout comme les mathématiques de l'école primaire, et vous devriez faire attention aux symboles des chiffres). Si la valeur du produit dépasse la plage de représentation numérique d'Ecmascript, puis retournez Infinity (positif infini) ou -infinity (négatif infini)
2. Si un nombre est nan, alors le résultat est nan
3. Si l'infini est multiplié par 0, le résultat est nan
4. Si un opérateur est un nombre et que l'autre n'est pas une valeur numérique, utilisez d'abord la fonction Number () pour le convertir et multiplier la valeur convertie avec le nombre. Si le résultat converti apparaît NAN, alors le résultat est nan.
division
console.dir (5 / "5"); // 1 convertir des caractères en nombres et diviser console.dir (5 / "a"); // nan console.dir (5 / nan); // nan console.dir (5 / null); // infinity null converts with number (), et le résultat est 0, alors 5/0 est la même console infinie.Dir (null / 5); 0 0 console Console.Dir (5 / Undefine
Parlons du principe de conversion implicite de la division:
Semblable à la multiplication, le seul de plus est que le résultat 0/0 est nan
Prenez le reste et trouvez le modèle
La chose la plus courante à utiliser dans le projet est de trouver des nombres étranges et même. Nous utilisons souvent un nombre avec 2 pour calculer l'équilibre. Si le résultat est 0, le nombre est un nombre pair, et si le résultat est 1, le nombre est un nombre impair.
Consultez le sujet ci-dessus:
Console.dir (16% "5"); // 1 convertissez la chaîne 5 en 5 via numéro () puis calculez la console restante.dir (5% "A"); // nan console.dir (5% nan); // nan console.dir (5% nul); // nan convertit null via Number (), le résultat est 0, puis calculez 5% 0, le résultat est nan console.dir (null% 5); // 0 identique à supérieur à 0% 5, le résultat est 0 Console.dir (5% non défini); // nan console.dir (5% 5); // 0 Console.dir (5% 0); // nan console.dir (0% 5); // 0 console.dir (0% 0); // nanconsole.dir (Infinity% Infinity); // nanconsole.dir (5% Infinity); // 5 console.dir (Infinity% 5); // nan
Parlons du principe de la conversion implicite des résidus:
Comme la multiplication, permettez-moi de parler de quelque chose de spécial! Nous connaissons tous les concepts de dividendes et de diviseurs, que nous avons appris à l'école primaire.
1. Le dividende est infini et le dividende est une valeur finie, donc le résultat est nan
2. Le diviseur est une valeur finie, et le diviseur est 0, alors le résultat est nan
3. Résultat de l'infini à l'infini sur l'infini est nan
4. Le dividende est une valeur finie, le dividende est une valeur infinie et le résultat est un diviseur.
5. Le nombre divisé est 0, le résultat est 0
Soustraction
Jetez un œil à l'exemple ci-dessus!
console.dir (16- "5"); // 11 console.dir (5- "a"); // nan console.dir (5-nan); // nan console.dir (5-null); // 5 Console.Dir (5-UNDEFINED); // nan console.dir (5-5); // 0 console.dir (5 true); // 4 console.dir (5- "true"); // nan console.dir (5 - ""); // 5 console.dir (5-infinity); // - Infinity Console.Dir (Infinity-Infinity); // nan console.dir ("La différence entre deux nombres est" + 5-5); Les nombres sont 0Parlons du principe de la conversion implicite de la soustraction:
Tout comme ce qui précède, je ne parlerai pas de la même chose, je vais parler de la soustraction unique.
1. Résultat de l'infinit de l'infinit est nan
2. -Infinity-infinity le résultat est -infinity
3. Le résultat d'un nombre moins l'infini est - Infinity
4. Infinity - (- Infinity) Le résultat est l'infini
5. Si l'opérande est un objet, la valeur de la valeur de l'objet est appelée. Si le résultat est NAN, le résultat est nan. S'il n'y a pas de méthode de valeur, alors appelez la méthode toString () et convertissez la chaîne résultante en une valeur numérique.
Opérateurs relationnels
Les opérateurs relationnels retournent uniformément vrai ou faux
console.dir (16> "5"); // true console.dir ("16"> "5"); // false console.dir (5 <"a"); // false console.dir (5> = nan); // false console.dir (5 <nan); // false console.dir (nan> = nan); // false console.dir (5> = null); // true console.dir (5> = unfined); console.dir (5> = undefined); // false console.dir (5> = 5); // true console.dir (5> = true); // true console.dir (5> = non défini); // false console.dir (5> = 5); // true console.dir (5> = true); // vrai console.dir (5> = true); Console.dir (5> = ""); // true console.dir ("brique"> "alphabet"); // Faux La valeur codant pour la chaîne de B est 66, tandis que la chaîne codante de A est 97. Par conséquent, la lettre binaigne.dir ("Brick"> "Alphabet"); // true La lettre bincase B est plus grande que a, donc c'est vraiParlons du principe de conversion implicite des opérateurs relationnels:
C'est toujours la même chose que ci-dessus, je ne dirai pas la même chose.
Si les deux nombres comparés sont des chaînes, les valeurs codées de chaîne correspondant à la chaîne seront comparées.
Opération d'addition
La raison pour laquelle j'ai finalement dit que la conversion implicite des opérations d'addition est que la conversion implicite des opérations d'addition est différente des précédentes. Tous les symboles de l'opérateur précédent, tant que l'un est un nombre, l'autre utilise également Number () pour convertir les nombres par défaut. L'opération d'addition est différente. Tant que l'une des opérations d'addition est une chaîne, l'autre sera également convertie en une chaîne, puis l'épissage de la chaîne est effectué!
console.dir (16+ "5"); // 156 console.dir (5+ "a"); // 5a console.dir (5 + nan); // nan console.dir (5 + null); // 5 console.dir ('5' + null); // 5null Console.Dir (5 + Undefine console.dir (5 + 5); // 10 console.dir ("la somme de deux nombres est" + 5 + 5); // la somme de deux nombres est 55 console.dir ("la somme de deux nombres est" + (5 + 5)); // la somme de deux nombres est 10Parlons du principe de conversion implicite des opérateurs d'addition:
1. L'un est une chaîne, et l'autre sera également converti en chaîne pour l'épissage. Si l'un est une chaîne et l'autre est nul ou non défini, l'ajout, null ou non défini, appellera la méthode String () pour obtenir la chaîne "NULL" ou "Undefined", puis l'éplice.
2. Si un nombre est ajouté avec null ou non défini, alors null ou non défini est converti en nombre () puis ajouté.
3. Les principes restants sont similaires aux autres, donc je ne dirai pas grand-chose.
Conversion implicite biequal
Exécutez le code suivant une fois, et je crois que vous le comprendrez naturellement ~
var a; console.dir (0 == false); // trueconsole.dir (1 == true); // trueconsole.dir (2 == {valeurof: function () {return 2}}); // trueconsole.dir (a == nan); // falseconsole.dir (nan == nan); // Falseconsole.dir (nan == nan); // Falseconsole. undefined);//falseconsole.dir(1 == undefined);//falseconsole.dir(2 == {toString: function(){return 2}});//trueconsole.dir(undefined == null);//trueconsole.dir(null == 1);//falseconsole.dir({ toString: function () {return 1}, valeurof: function () {return []}} == 1); // trueconsole.dir (1 == "1"); // trueconsole.dir (1 === "1"); // false