Cualquier número, es número. La cadena parece un número, es un número. Todo lo demás, va NaN.

'a' => NaN
'1' => 1
1 => 1

Hay 4 formas de hacerlo hasta donde yo sé.

Number(x);
parseInt(x, 10);
parseFloat(x);
+x;

Según esta prueba rápida que hice, en realidad depende de los navegadores.

http://jsperf.com/best-of-string-to-number-conversion/2

Implicit marcó el más rápido en 3 navegadores, pero hace que el código sea difícil de leer ... ¡Así que elige lo que quieras!

Hay al menos 5 formas de hacer esto:

Si desea convertir solo a enteros, otra forma rápida (y corta) es el doble bit a bit (es decir, usando dos caracteres tilde):

p.ej

~~x;

Referencia: http://james.padolsey.com/cool-stuff/double-bitwise-not/

Las 5 formas comunes que conozco hasta ahora para convertir una cadena en un número tienen sus diferencias (hay más operadores bit a bit que funcionan, pero todos dan el mismo resultado que ~~). Este JSFiddle muestra los diferentes resultados que puede esperar en la consola de depuración: http://jsfiddle.net/TrueBlueAussie/j7x0q0e3/22/

var values = ["123",
          undefined,
          "not a number",
          "123.45",
          "1234 error",
          "2147483648",
          "4999999999"
          ];

for (var i = 0; i < values.length; i++){
    var x = values[i];

    console.log(x);
    console.log(" Number(x) = " + Number(x));
    console.log(" parseInt(x, 10) = " + parseInt(x, 10));
    console.log(" parseFloat(x) = " + parseFloat(x));
    console.log(" +x = " + +x);
    console.log(" ~~x = " + ~~x);
}

Consola de depuración:

123
  Number(x) = 123
  parseInt(x, 10) = 123
  parseFloat(x) = 123
  +x = 123
  ~~x = 123
undefined
  Number(x) = NaN
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = NaN
  ~~x = 0
null
  Number(x) = 0
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = 0
  ~~x = 0
"not a number"
  Number(x) = NaN
  parseInt(x, 10) = NaN
  parseFloat(x) = NaN
  +x = NaN
  ~~x = 0
123.45
  Number(x) = 123.45
  parseInt(x, 10) = 123
  parseFloat(x) = 123.45
  +x = 123.45
  ~~x = 123
1234 error
  Number(x) = NaN
  parseInt(x, 10) = 1234
  parseFloat(x) = 1234
  +x = NaN
  ~~x = 0
2147483648
  Number(x) = 2147483648
  parseInt(x, 10) = 2147483648
  parseFloat(x) = 2147483648
  +x = 2147483648
  ~~x = -2147483648
4999999999
  Number(x) = 4999999999
  parseInt(x, 10) = 4999999999
  parseFloat(x) = 4999999999
  +x = 4999999999
  ~~x = 705032703

La ~~xversión da como resultado un número en "más" casos, donde otros a menudo dan como resultado undefined, pero falla por una entrada no válida (por ejemplo, regresará 0si la cadena contiene caracteres que no son números después de un número válido).

Desbordamiento

Tenga en cuenta: puede ocurrir un desbordamiento de enteros y / o truncamiento de bits ~~, pero no con las otras conversiones. Si bien es inusual ingresar valores tan grandes, debe ser consciente de esto. Ejemplo actualizado para incluir valores mucho más grandes.

Algunas pruebas de rendimiento indican que el estándar parseInty las parseFloatfunciones son en realidad las opciones más rápidas, presumiblemente altamente optimizadas por los navegadores, pero todo depende de sus requisitos, ya que todas las opciones son lo suficientemente rápidas : http://jsperf.com/best-of-string-to -conversión-número / 37

Todo esto depende de cómo se configuren las pruebas de rendimiento, ya que algunos muestran que parseInt / parseFloat es mucho más lento.

Mi teoría es:

• Mentiras
• Líneas malditas
• Estadísticas
• Resultados JSPerf :)

Prefije la cadena con el +operador.

console.log(+'a') // NaN
console.log(+'1') // 1
console.log(+1) // 1

Una forma rápida de convertir cadenas a un entero es usar un bit a bit o, de esta manera:

x | 0

Si bien depende de cómo se implemente, en teoría debería ser relativamente rápido (al menos tan rápido como +x) ya que primero emitirá xun número y luego realizará un muy eficiente o.

Aquí hay una manera simple de hacerlo: var num = Number (str); en este ejemplo, str es la variable que contiene la cadena. Puede probar y ver cómo funciona abierto: herramientas para desarrolladores de Google Chrome , luego vaya a la consola y pegue el siguiente código. lea los comentarios para comprender mejor cómo se realiza la conversión.

// Here Im creating my variable as a string
var str = "258";


// here im printing the string variable: str
console.log ( str );


// here Im using typeof , this tells me that the variable str is the type: string
console.log ("The variable str is type: " + typeof str);


// here is where the conversion happens
// Number will take the string in the parentesis and transform it to a variable num as type: number
var num = Number(str);
console.log ("The variable num is type: " + typeof num);

Me parece que num * 1es simple, claro y funciona para enteros y flotantes ...

Probablemente esto no sea tan rápido, pero tiene el beneficio adicional de asegurarse de que su número tenga al menos un cierto valor (por ejemplo, 0), o como máximo un cierto valor:

Math.max(input, 0);

Si necesita asegurar un valor mínimo, generalmente lo haría

var number = Number(input);
if (number < 0) number = 0;

Math.max(..., 0) te salva de escribir dos declaraciones.

¡Puede intentar usar UnitOf , una biblioteca de conversión de medidas y tipos de datos que acabamos de lanzar oficialmente! UnitOf es súper rápido, pequeño y eficiente en la conversión de cualquier tipo de datos sin arrojar un error o nulo / indefinido. Los valores predeterminados que defina o los valores predeterminados de UnitOf se devuelven cuando una conversión no tiene éxito.

//One liner examples
UnitOf.DataType("12.5").toFloat(); //12.5 of type Float is returned. 0 would be returned if conversion failed.
UnitOf.DataType("Not A Num").toInt(10); //10 of type Int is returned as the conversion failed.

//Or as a variable
var unit = UnitOf.DataType("12.5");
unit.toInt(5); //12.5 of type Float is returned. 5 would be returned if the conversion failed.
unit.toFloat(8); // 12 of type Int is returned. 8 would be returned if the conversion failed.

La forma más rápida es usar -0:

const num = "12.34" - 0;