Pièges dans le problème de conversion implicite du test-JS écrit frontal

Lorsque nous rédigeons des questions de test écrit, nous rencontrons souvent des questions impliquant des conversions implicites, telles que

"1" + 2
obj + 1
[] == ![] 
[null] == false

=== et ==

=== sont appelés opérateurs stricts, les objets Le type pointe vers la même adresse ou la même valeur de type d'origine (valeur numérique, chaîne, valeur booléenne) ; == est appelé l'opérateur d'égalité. Si non défini et nul sont égaux, le type d'objet sera toujours. être comparés et référencés. L'opérateur == traite la valeur d'origine et son objet enveloppé comme égaux, mais l'opérateur === les traite comme inégaux. All obj.a==null (équivalent à obj.a=== null || obj.a ===undefined).

L'opérateur d'égalité est un piège qui provoque souvent une conversion implicite en JS. Il apparaît également souvent dans nos questions d'entretien. Cependant, dans le développement réel, afin d'éviter des problèmes inutiles, nous exigeons l'utilisation d'opérateurs stricts. Mais encore faut-il comprendre.

Si vous souhaitez comprendre la conversion implicite JS, vous devez d'abord commencer avec trois points de connaissances.

Types primitifs

Les types primitifs (types de base, types de données primitifs, types de données primitifs) sont des données qui ne sont ni des objets ni des méthodes. En JavaScript, il existe 7 types : string，number，bigint，boolean，null，undefined，symbol (ECMAScript 2016新增).

valeur fausse (valeur virtuelle)

valeur fausse (valeur virtuelle) est une valeur reconnue comme fausse dans un contexte booléen. Il n'y a que sept valeurs fausses dans. JavaScript.

1. false false Mot-clé
2. 0 Valeur zéro
3. 0n Lorsque BigInt est utilisé comme valeur booléenne, suivez ses règles car une valeur numérique 0n est une valeur fausse. .
4. Une chaîne vide (la longueur de la chaîne est nulle). Les chaînes en JavaScript peuvent être définies avec des guillemets doubles "", des guillemets simples '' ou des littéraux de modèle ``.
5. null null - valeur manquante
6. indéfini non défini - valeur d'origine
7. NaN NaN - valeur non numérique

En particulier, sauf ceci Tous sept objets ont de vraies valeurs, telles que new Number et new Boolean.

let b = new Boolean(false);i
f(b){
//会执行到这里。
}

Quatre règles de conversion majeures

• règle toString : Opérations de conversion d'autres types de valeurs en types de chaîne

  • null => "null"
  • indéfini => "indéfini"
  • true => "true" false=>"false"
  • 10 = > "10" "1e21"=> "1e+21"
  • [1,2,3] => "1,2,3"
  • Objet objet=> ; "[Object Object]" appelle en fait la méthode toString

• Règle ToPrimitive : l'opération de conversion d'un tableau de type objet en un type primitif

  • Lorsque le type d'objet doit être converti en un type primitif, il recherchera d'abord la méthode valueOf de l'objet. Si la méthode valueOf renvoie une valeur du type d'origine, le résultat de ToPrimitive est. cette valeur
  • Si valueOf n'existe pas ou Si la méthode valueOf renvoie une valeur qui n'est pas un type primitif, elle essaiera d'appeler la méthode toString de l'objet, ce qui signifie qu'elle suivra les règles ToString de l'objet, puis utilisez la valeur de retour de toString comme résultat de ToPrimitive
  • Date est d'abord toString puis ValueOf
  • Si le type d'origine ne peut pas être obtenu après toString et ValueOf, il sera lancé pour juger de l'égalité, addition et soustraction Uncaught TypeError: Cannot convert object to primitive value

• Règle ToNumber

  • null=> 0
  • non défini =>NaN
  • "123"=>123 "12ssd"=>NaN ""=>0
  • false => 0 vrai=>1
  • Array, objet ToPrimitive

• Règles ToBoolean

  • Les sept valeurs fausses (valeurs virtuelles) en js sont faux et les autres sont vrais

Conversion implicite

Avec la compréhension des points de connaissance ci-dessus, nous pouvons supprimer la conversion implicite JS d'un seul coup fonce.

• == 的过程（优先换成数字、字符串）

1. 首先看==前后有没有NaN，有的话都是返回false。NaN不等于任何值，包括其本身
2. 布尔值会转成数字类型，true转成1，false转成0
3. 数字和字符串比较，字符串会转成数字
4. undefined和null除了和undefined或null相等，和其他相比都是false
5. 数字或者字符串和对象相比，对象使用ToPrimitive规则转换。
6. 当两个操作数都是对象时，JavaScript会比较其内部引用，当且仅当他们的引用指向内存中的相同对象（区域）时才相等，即他们在栈内存中的引用地址相同。

• +的过程（优先换成字符串、数字）

1. 如果至少有一个操作数是对象，它会被转换成原始值（字符串，数字或布尔）；
2. 转换之后，如果至少有一个操作数是字符串类型，第二个操作数会被转换成字符串，并且会执行连接。
3. 在其他的情况下，两个操作数都会转换成数字并执行算数加法运算。

• -的过程（转换成数字） 这个就很简单了，全部用ToNumber规则转换成数字

检测学习成果

我们根据以上所学看几个笔试题。如果你都知道结果，就不用看我的废解释了。

[] == [] 
[] == ![] 
[null] == false

第一个，==左右都是对象，比较引用地址，这个两个不同的实例，肯定不相等啊。 第二个，！的优先级高于==，所以先 [] 是真值，求非当让是false了，转成数字0，==左是对象右是数字，对象使用ToPrimitive规则转换成""，再用ToNumber规则就转成0了，判断为相等。 第三个，[null]ToPrimitive再ToNumber规则就转成0，false也转成0。

var  a = 1;
var  b = "3";

var obj1 = {
    i:1,
    toString:function() {
        return "1";
    },
    valueOf:function() {
        return 1;
    }
};
var obj2 = {
    i:1,
    toString:function() {
        return "2";
    }
};
var obj3 = {
    i:1,
    valueOf:function() {
        return 3;
    }
};
var obj = {
    i:1,
};
var objE = {
    i:1,
    valueOf:function() {
        return [];
    },
    toString:function() {
        return {};
    }
};


a+b  
a + obj  
a + objE 

a+obj1  
a+obj2  
a+obj3  

b+obj1  
b+obj2  
b+obj3  

a==obj2  
a==obj1

这道题比较简单你只要熟练掌握我上面说的那几个知识点可以了。下面直接写出结果啦。

a + b    //"13"
a + obj  //"1[object Object]"
a + objE //Uncaught TypeError: Cannot convert object to primitive value

a+obj1  //2
a+obj2  //"12"
a+obj3  // 4

b+obj1  //"31"
b+obj2  //"32"
b+obj3  //“33”

a==obj2  //false
a==obj1  //true

最后提一个比较奇葩的题目。

定义一个变量a，使得下面的表达式结果为true

  a == 1 && a == 2 && a == 3

这里我简单提示下，a要是一个对象，重写valueOf方法，让它每次隐式转换的时候，调用时i++。

valueOf()在Object上默认返回的是对象不是原始类型，它会再调用toString。所以只要重写toString也可以。

如果还是没有思路，你们可以去看下这道题的文章原文从一道面试题说起—js隐式转换踩坑合集。

推荐教程：《JS教程》

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!