JavaScript
Coerción variable / conversión

Observaciones

<span id="freezing-point">0</span>

var el = document.getElementById('freezing-point');
var freezingPoint = el.textContent || el.innerText;
var moreHeat = 100;
var boilingPoint = freezingPoint + moreHeat;

var el = document.getElementById('freezing-point');
var freezingPoint = Number(el.textContent || el.innerText);
var boilingPoint = freezingPoint + moreHeat;

Convertir una cadena en un número

Number('0') === 0

Number('0') convertirá la cadena ( '0' ) en un número ( 0 )

Una forma más corta, pero menos clara:

+'0' === 0

El operador unario + no hace nada a los números, pero convierte cualquier otra cosa en un número.
Curiosamente, +(-12) === -12 .

parseInt('0', 10) === 0

parseInt('0', 10) convertirá la cadena ( '0' ) en un número ( 0 ), no olvide el segundo argumento, que es radix. Si no se proporciona, parseInt podría convertir la cadena a un número incorrecto.

Convertir un número en una cadena

String(0) === '0'

String(0) convertirá el número ( 0 ) en una cadena ( '0' ).

Una forma más corta, pero menos clara:

'' + 0 === '0'

Doble Negacion (!! x)

La doble negación !! no es un operador de JavaScript distinto ni una sintaxis especial, sino más bien una secuencia de dos negaciones. Se utiliza para convertir el valor de cualquier tipo a su valor booleano true o false , dependiendo de si es verdadero o falso .

!!1            // true
!!0            // false
!!undefined    // false
!!{}           // true
!![]           // true

La primera negación convierte cualquier valor en false si es verdadero y true si es falso . La segunda negación opera entonces en un valor booleano normal. Juntos se convierten a cualquier valor Truthy true y cualquier valor Falsy a false .

Sin embargo, muchos profesionales consideran que la práctica de usar tal sintaxis es inaceptable y recomiendan alternativas más sencillas de leer, incluso si son más largas para escribir:

x !== 0        // instead of !!x in case x is a number
x != null      // instead of !!x in case x is an object, a string, or an undefined

El uso de !!x se considera una mala práctica debido a las siguientes razones:

1. Estilísticamente, puede parecer una sintaxis especial distinta, mientras que en realidad no hace nada más que dos negaciones consecutivas con conversión de tipo implícita.
2. Es mejor proporcionar información sobre los tipos de valores almacenados en variables y propiedades a través del código. Por ejemplo, x !== 0 dice que x es probablemente un número, mientras que !!x no transmite tal ventaja a los lectores del código.
3. El uso de Boolean(x) permite una funcionalidad similar y es una conversión de tipo más explícita.

Conversión implícita

JavaScript intentará convertir automáticamente las variables a tipos más apropiados al usarlas. Por lo general, se recomienda hacer conversiones explícitamente (ver otros ejemplos), pero aún así vale la pena saber qué conversiones tienen lugar implícitamente.

"1" + 5 === "15" // 5 got converted to string.
1 + "5" === "15" // 1 got converted to string.
1 - "5" === -4 // "5" got converted to a number.
alert({}) // alerts "[object Object]", {} got converted to string.
!0 === true // 0 got converted to boolean
if ("hello") {} // runs, "hello" got converted to boolean.
new Array(3) === ",,"; // Return true. The array is converted to string - Array.toString();

Algunas de las partes más complicadas:

!"0" === false // "0" got converted to true, then reversed.
!"false" === false // "false" converted to true, then reversed.

Convertir un número a un booleano

Boolean(0) === false

Boolean(0) convertirá el número 0 en un false booleano.

Una forma más corta, pero menos clara:

!!0 === false

Convertir una cadena a un booleano

Para convertir una cadena a uso booleano

Boolean(myString)

o la forma más corta pero menos clara

!!myString 

Todas las cadenas, excepto la cadena vacía (de longitud cero) se evalúan como true como booleanas.

Boolean('') === false   // is true
Boolean("") === false   // is true
Boolean('0') === false  // is false
Boolean('any_nonempty_string') === true // is true

Entero para flotar

En JavaScript, todos los números se representan internamente como flotadores. Esto significa que simplemente usar su entero como un flotador es todo lo que se debe hacer para convertirlo.

Flotar a entero

Para convertir un flotante en un entero, JavaScript proporciona múltiples métodos.

La función de floor devuelve el primer entero menor o igual que el flotador.

Math.floor(5.7); // 5

La función ceil devuelve el primer entero mayor o igual que el flotador.

Math.ceil(5.3); // 6

La función round redondea el flotador.

Math.round(3.2); // 3
Math.round(3.6); // 4

Math.trunc(3.7); // 3

Math.floor(-3.1); // -4
Math.trunc(-3.1); // -3

Convertir cadena a flotar

parseFloat acepta una cadena como un argumento que convierte en un float /

parseFloat("10.01") // = 10.01

Convertir a booleano

Boolean(...) convertirá cualquier tipo de datos en true o false .

Boolean("true") === true
Boolean("false") === true
Boolean(-1) === true
Boolean(1) === true
Boolean(0) === false
Boolean("") === false
Boolean("1") === true
Boolean("0") === true
Boolean({}) === true
Boolean([]) === true

Las cadenas vacías y el número 0 se convertirán a falso, y todos los demás se convertirán a verdadero.

Una forma más corta, pero menos clara:

!!"true" === true
!!"false" === true
!!-1 === true
!!1 === true
!!0 === false
!!"" === false
!!"1" === true
!!"0" === true
!!{} === true
!![] === true

Esta forma más corta aprovecha la conversión de tipo implícita utilizando el operador lógico NO dos veces, como se describe en http://www.riptutorial.com/javascript/example/3047/double-negation----x-

Aquí está la lista completa de las conversiones booleanas de la especificación ECMAScript

• si myArg de tipo undefined o null entonces Boolean(myArg) === false
• si myArg de tipo boolean entonces Boolean(myArg) === myArg
• si myArg de tipo number entonces Boolean(myArg) === false si myArg es +0 , ‑0 , o NaN ; de lo contrario true
• si myArg de tipo string entonces Boolean(myArg) === false si myArg es la cadena vacía (su longitud es cero); de lo contrario true
• si myArg de tipo symbol u object entonces Boolean(myArg) === true

Los valores que se convierten en false como booleanos se denominan falsy (y todos los demás se llaman verdad ). Ver Operaciones de comparación .

Convertir una matriz en una cadena

Array.join(separator) se puede usar para generar una matriz como una cadena, con un separador configurable.

Predeterminado (separador = ","):

["a", "b", "c"].join() === "a,b,c"

Con un separador de hilo:

[1, 2, 3, 4].join(" + ") === "1 + 2 + 3 + 4"

Con un separador en blanco:

["B", "o", "b"].join("") === "Bob"

Array to String usando métodos de array

De esta manera, puede parecerle útil porque está utilizando una función anónima para lograr algo con lo que puede hacer con join (); Pero si necesita hacer algo con las cadenas mientras está convirtiendo la matriz en cadena, esto puede ser útil.

var  arr = ['a', 'á', 'b', 'c']

function upper_lower (a, b, i) {
  //...do something here
  b = i & 1 ? b.toUpperCase() : b.toLowerCase();
  return a + ',' + b
}
arr = arr.reduce(upper_lower); // "a,Á,b,C"

Tabla de conversión de primitivo a primitivo

Los valores en negrita resaltan la conversión que los programadores pueden encontrar sorprendente

Para convertir valores explícitos, puede usar String () Number () Boolean ()