1- ## Equality and Comparisons
1+ ## Igualdad y Comparación
22
3- JavaScript has two different ways of comparing the values of objects for equality.
3+ JavaScript posee 2 maneras diferentes para comparar valores entre objetos para comprobar igualdad.
44
5- ### The Equality Operator
5+ ### El Operador de Igualdad
66
7- The equality operator consists of two equal signs : ` == `
7+ El operador de igualdad consiste en 2 signos es igual : ` == `
88
9- JavaScript features * weak typing * . This means that the equality operator
10- ** coerces ** types in order to compare them .
9+ JavaScript utiliza * tipado débil * . Esto significa que el operador de igualdad
10+ ** obliga ** una conversión de tipos para poder compararlos .
1111
1212 "" == "0" // false
1313 0 == "" // true
@@ -19,20 +19,20 @@ JavaScript features *weak typing*. This means that the equality operator
1919 null == undefined // true
2020 " \t\r\n" == 0 // true
2121
22- The above table shows the results of the type coercion, and it is the main reason
23- why the use of ` == ` is widely regarded as bad practice. It introduces
24- hard-to-track-down bugs due to its complicated conversion rules .
22+ La tabla anterior muestra los resultados de la conversión de tipos, éste es el motivo principal
23+ de por qué el uso de ` == ` es ampliamente considerado una mala práctica. Introduce errores
24+ difíciles de identificar debido a la complejidad de sus reglas de conversión .
2525
26- Additionally, there is also a performance impact when type coercion is in play ;
27- for example, a string has to be converted to a number before it can be compared
28- to another number .
26+ Además, existe un impacto en el rendimiento cuando entra en juego la conversión de tipos ;
27+ por ejemplo, una cadena debe ser convertida a número antes de poder ser comparada
28+ con otro número .
2929
30- ### The Strict Equality Operator
30+ ### El Operador de Igualdad Estricto
3131
32- The strict equality operator consists of ** three ** equal signs : ` === ` .
32+ El operador de igualdad estricto consiste en ** tres ** signos es igual : ` === ` :
3333
34- It works exactly like the normal equality operator, except that strict equality
35- operator does ** not ** perform type coercion between its operands .
34+ Funciona exactamente igual que el operador de igualdad, excepto que el operador de igualdad
35+ estricto ** no ** utiliza conversión de tipos entre sus operandos .
3636
3737 "" === "0" // false
3838 0 === "" // false
@@ -44,28 +44,28 @@ operator does **not** perform type coercion between its operands.
4444 null === undefined // false
4545 " \t\r\n" === 0 // false
4646
47- The above results are a lot clearer and allow for early breakage of code. This
48- hardens code to a certain degree and also gives performance improvements in case
49- the operands are of different types .
47+ Los resultados anteriores son mucho más claros y permiten una detección de errores temprana.
48+ Esto permite un código más sólido en cierto grado y también mejora el rendimiento
49+ en el caso que los operandos sean de tipos diferentes .
5050
51- ### Comparing Objects
51+ ### Comparando Objetos
5252
53- While both ` == ` and ` === ` are stated as ** equality ** operators, they behave
54- differently when at least one of their operands happens to be an ` Object ` .
53+ Aunque ` == ` como ` === ` son considerados operadores de ** igualdad ** , se comportan
54+ de maneras diferentes cuando al menos uno de sus operandos es ` Object ` .
5555
5656 {} === {}; // false
5757 new String('foo') === 'foo'; // false
5858 new Number(10) === 10; // false
5959 var foo = {};
6060 foo === foo; // true
6161
62- Here, both operators compare for ** identity ** and ** not ** equality; that is, they
63- will compare for the same ** instance ** of the object, much like ` is ` in Python
64- and pointer comparison in C.
62+ En este caso, los dos operadores comparan por ** referencia ** y ** no ** por igualdad; esto es,
63+ comparan por la misma ** instancia ** del objeto, parecido
64+ al operador ` is ` en Python y la comparación entre punteros en C.
6565
66- ### In Conclusion
66+ ### En Conclusión
6767
68- It is highly recommended to only use the ** strict equality ** operator. In cases
69- where types need to be coerced, it should be done [ explicitly ] ( #types.casting )
70- and not left to the language's complicated coercion rules .
68+ Es altamente recomendable usar sólo el operador de ** igualdad estricta ** . En los casos
69+ donde los tipos de datos necesitan ser convertidos, debe hacerse [ explícitamente ] ( #types.casting )
70+ y no dejárselo a las complicadas reglas de conversión del lenguaje .
7171
0 commit comments