1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
---
title: Comparación (==)
slug: Web/JavaScript/Reference/Operators/Equality
tags:
- JS
- JavaScript
- Operador de comparacion
- Operadores
- Referências
translation_of: Web/JavaScript/Reference/Operators/Equality
original_slug: Web/JavaScript/Referencia/Operadores/Comparacion
---
<div>{{jsSidebar("Operators")}}</div>
<p>El operador de comparacion (<code>==</code>) comprueba si sus dos operandos son iguales y devuelve un resultado booleano. A diferencia del operador de igualdad estricta (<code>===</code>), es que este convierte y compara operandos que son de diferentes tipos.</p>
<div>{{EmbedInteractiveExample("pages/js/expressions-equality.html")}}</div>
<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
<h2 id="Sintaxis">Sintaxis</h2>
<pre class="syntaxbox notranslate">x == y
</pre>
<h2 id="Descripción">Descripción</h2>
<p>Los operadores de igualdad (<code>==</code>y <code>!=</code>) Utilizan el algoritmo de comparación de igualdad abstracta para comparar dos operandos. Esto se puede resumir a grandes rasgos como:</p>
<ul>
<li>Si los operandos ambos son objetos, devuelve <code>true </code>solo si ambos operandos hacen referencia al mismo objeto.</li>
<li>Si un operando es <code>null</code>y el otro <code>undefined</code>, devuelve verdadero(<code>true</code>).</li>
<li>Si los operandos son de diferente tipos, intenta convertirlos al mismo tipo antes de comparar:
<ul>
<li>Al comparar un número con una cadena, convierte la cadena en un valor numérico.</li>
<li>Si uno de los operandos es booleano, convierte el operando booleano en 1 si es verdadero y en 0 en el caso de falso.</li>
<li>Si uno de los operandos es un objeto y el otro es un número o una cadena, convierte el objeto en una primitiva utilizando los métodos <code>valueOf()</code>y <code>toString()</code> del objeto.</li>
</ul>
</li>
<li>Si los operandos tienen el mismo tipo, se comparan de la siguiente manera:
<ul>
<li><code>String</code>: devuelve verdadero solo si ambos operandos tienen los mismos caracteres y en el mismo orden.</li>
<li><code>Number</code>: devuelve verdadero solo si ambos operandos tienen el mismo valor. <code>+0</code> y <code>-0</code> se tratan como el mismo valor. Si alguno de los operandos es <code>NaN</code>, devuelve falso.</li>
<li><code>Boolean</code>: retorna verdadero solo si ambos operandos son verdaderos o falsos.</li>
</ul>
</li>
</ul>
<p>La diferencia más notable entre este operador y el operador de igualdad estricta (<code>===</code>) es que el operador de igualdad estricta no realiza la conversión de tipos. </p>
<h2 id="Ejemplos">Ejemplos</h2>
<h3 id="Comparación_sin_conversión_de_tipo">Comparación sin conversión de tipo</h3>
<pre class="brush: js notranslate">1 == 1; // true
"Hola" == "Hola"; // true</pre>
<h3 id="Comparación_con_conversión_de_tipos">Comparación con conversión de tipos</h3>
<pre class="brush: js notranslate">"1" == 1; // true
1 == "1"; // true
0 == false; // true
0 == null; // false
0 == undefined; // false
0 == !!null; // true, Operador Logico NOT
0 == !!undefined; // true, Operador Logico NOT
null == undefined; // true
const number1 = new Number(3);
const number2 = new Number(3);
number1 == 3; // true
number1 == number2; // false</pre>
<h3 id="Comparación_de_objetos">Comparación de objetos</h3>
<pre class="brush: js notranslate">const object1 = {"key": "value"}
const object2 = {"key": "value"};
object1 == object2 // false
object2 == object2 // true</pre>
<h3 id="Comparar_String_y_objetos_String">Comparar String y objetos String</h3>
<p>Tenga en cuenta que las cadenas construidas con <code>new String() </code>son objetos. Si compara uno de estos con un String literal, el objeto String se convertirá en un <code>String</code> literal y se comparará el contenido. Sin embargo, si ambos operandos son objetos de tipo String, entonces se comparan como objetos y deben hacer referencia al mismo objeto para que la comparación sea exitosa:</p>
<pre class="brush: js notranslate">const string1 = "Hola";
const string2 = String("Hola");
const string3 = new String("Hola");
const string4 = new String("Hola");
console.log(string1 == string2); // true
console.log(string1 == string3); // true
console.log(string2 == string3); // true
console.log(string3 == string4); // false
console.log(string4 == string4); // true</pre>
<h3 id="Comparación_de_fechas_y_cadenas">Comparación de fechas y cadenas</h3>
<pre class="brush: js notranslate">const d = new Date('December 17, 1995 03:24:00');
const s = d.toString(); // Por ejemplo: "Sun Dec 17 1995 03:24:00 GMT-0800 (Hora estándar del Pacífico)"
console.log(d == s); //true</pre>
<h2 id="Especificaciones">Especificaciones</h2>
<table class="standard-table">
<thead>
<tr>
<th scope="col">Especificaciones</th>
</tr>
</thead>
<tbody>
<tr>
<td>{{SpecName('ESDraft', '#sec-equality-operators', 'Equality operators')}}</td>
</tr>
</tbody>
</table>
<h2 id="Compatibilidad_con_Navegadores">Compatibilidad con Navegadores</h2>
<p>{{Compat("javascript.operators.equality")}}</p>
<h2 id="Ver_también">Ver también</h2>
<ul>
<li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Inequality">Inequality operator</a></li>
<li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Strict_equality">Strict equality operator</a></li>
<li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Strict_inequality">Strict inequality operator</a></li>
</ul>
|
