¿Cómo convierto una cadena a un entero en JavaScript?

La forma más sencilla sería utilizar la Numberfunción nativa :

var x = Number("1000")

Si eso no funciona para usted, existen los métodos parseInt , unary plus , parseFloat with floor y Math.round .

parseInt:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

unario más si su cadena ya tiene la forma de un entero:

var x = +"1000";

si su cadena es o podría ser flotante y desea un número entero:

var x = Math.floor("1000.01"); //floor automatically converts string to number

o, si vas a usar Math.floor varias veces:

var floor = Math.floor;
var x = floor("1000.01");

Si eres del tipo que se olvida de poner la raíz cuando llamas a parseInt, puedes usar parseFloat y redondearlo como quieras. Aquí uso el piso.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Curiosamente, Math.round (como Math.floor) realizará una conversión de cadena a número, por lo que si desea redondear el número (o si tiene un número entero en la cadena), esta es una excelente manera, tal vez mi favorito:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

Prueba la función parseInt:

var number = parseInt("10");

Pero hay un problema. Si intenta convertir "010" usando la función parseInt, detecta como número octal y devolverá el número 8. Por lo tanto, debe especificar una raíz (de 2 a 36). En este caso base 10.

parseInt(string, radix)

Ejemplo:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Tenga en cuenta que parseIntignora los datos incorrectos después de analizar algo válido.
Esta guía se analizará como 51:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

Hay dos formas principales de convertir una cadena en un número en javascript. Una forma es analizarlo y la otra es cambiar su tipo a un Número. Todos los trucos en las otras respuestas (por ejemplo, unario más) implican coaccionar implícitamente el tipo de la cadena a un número. También puede hacer lo mismo explícitamente con la función Número.

Analizando

var parsed = parseInt("97", 10);

parseInt y parseFloat son las dos funciones utilizadas para analizar cadenas a números. El análisis se detendrá en silencio si golpea a un personaje que no reconoce, lo que puede ser útil para analizar cadenas como "92px", pero también es algo peligroso, ya que no le dará ningún tipo de error en una entrada incorrecta. Volveré a NaN a menos que la cadena comience con un número. El espacio en blanco al comienzo de la cadena se ignora. Aquí hay un ejemplo de que hace algo diferente a lo que desea y no da indicios de que algo salió mal:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Es una buena práctica especificar siempre la raíz como el segundo argumento. En los navegadores más antiguos, si la cadena comenzara con un 0, se interpretaría como octal si no se especificara la raíz, lo que sorprendió a mucha gente. El comportamiento para hexadecimal se desencadena haciendo que la cadena comience con 0x si no se especifica una raíz, por ejemplo 0xff. El estándar en realidad cambió con ecmascript 5, por lo que los navegadores modernos ya no activan octal cuando hay un 0 inicial si no se ha especificado la raíz. parseInt comprende radixes hasta la base 36, en cuyo caso las letras mayúsculas y minúsculas se tratan como equivalentes.

Cambiar el tipo de una cadena a un número

Todos los otros trucos mencionados anteriormente que no usan parseInt, implican forzar implícitamente la cadena en un número. Prefiero hacer esto explícitamente

var cast = Number("97");

Esto tiene un comportamiento diferente a los métodos de análisis (aunque todavía ignora los espacios en blanco). Es más estricto: si no comprende toda la cadena de lo que devuelve NaN, entonces no puede usarla para cadenas como 97px. Como desea un número primitivo en lugar de un objeto contenedor de números, asegúrese de no poner newdelante de la función Número.

Obviamente, la conversión a un Número le da un valor que podría ser un flotante en lugar de un entero, por lo que si desea un entero, debe modificarlo. Hay algunas formas de hacerlo:

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

Cualquier operador bit a bit (aquí he hecho un bit a bit o, pero también podría hacer doble negación como en una respuesta anterior o un desplazamiento de bits) convertirá el valor a un entero de 32 bits, y la mayoría de ellos se convertirá en un entero con signo. Tenga en cuenta que esto no querrá lo que quiere para enteros grandes . Si el número entero no se puede representar en 32 bits, se ajustará.

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

Para trabajar correctamente con números más grandes, debe usar los métodos de redondeo

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Tenga en cuenta que todos estos métodos entienden la notación exponencial, por lo que 2e2es 200más que NaN. Además, Number entiende "Infinito", mientras que los métodos de análisis no.

Personalizado

Es poco probable que alguno de estos métodos haga exactamente lo que quieres. Por ejemplo, generalmente me gustaría que se arroje un error si falla el análisis, y no necesito soporte para Infinity, exponenciales o espacios en blanco iniciales. Dependiendo de su caso de uso, a veces tiene sentido escribir una función de conversión personalizada.

Siempre verifique que la salida de Number o uno de los métodos de análisis sea el tipo de número que espera. Seguramente querrá usar isNaNpara asegurarse de que el número no sea NaN (por lo general, la única forma de descubrir que el análisis falló).

ParseInt () y + son diferentes

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Aunque es una vieja pregunta, pero tal vez esto pueda ser útil para alguien.

Yo uso esta forma de convertir una cadena a int número

var str = "25";       // string
var number = str*1;   // number

Entonces, cuando se multiplica por 1, el valor no cambia, pero js devuelve automáticamente un número.

Pero como se muestra a continuación, esto debe usarse si está seguro de que stres un número (o puede representarse como un número), de lo contrario devolverá NaN, no un número.

puede crear funciones simples para usar, por ejemplo

function toNumber(str) {
   return str*1;
}

Lo más rápido

var x = "1000"*1;

Prueba

Aquí hay una pequeña comparación de la velocidad (solo Mac Os) ... :)

Para Chrome 'plus' y 'mul' son los más rápidos (> 700,000,00 op / sec), 'Math.floor' es el más lento. Para Firefox, 'plus' es el más lento (!) 'Mul' es el más rápido (> 900,000,000 op / sec). En Safari, 'parseInt' es ayuno, 'número' es el más lento (pero los resulats son bastante similares,> 13,000,000 <31,000,000). Entonces Safari para transmitir cadenas a int es más de 10 veces más lento que otros navegadores. Entonces el ganador es ' mul ' :)

Puede ejecutarlo en su navegador mediante este enlace https://jsperf.com/js-cast-str-to-number/1

Actualizar

También pruebo var x = ~~"1000";: en Chrome y Safari es un poco más lento que var x = "1000"*1(<1%), en Firefox es un poco más rápido (<1%). Actualizo la imagen de arriba y pruebo

Prueba parseInt.

var number = parseInt("10", 10); //number will have value of 10.

Publiqué la respuesta incorrecta aquí, lo siento. fijo.

Esta es una vieja pregunta, pero me encanta este truco:

~~"2.123"; //2
~~"5"; //5

El negativo doble bit a bit deja cualquier cosa después del punto decimal Y lo convierte a un formato numérico. Me han dicho que es un poco más rápido que llamar a funciones y otras cosas, pero no estoy completamente convencido.

EDITAR: Otro método que acabo de ver aquí (una pregunta sobre el operador javascript >>>, que es un desplazamiento a la derecha de relleno a cero) que muestra que desplazar un número por 0 con este operador convierte el número en uint32, lo cual es bueno si También lo quiero sin firmar . Nuevamente, esto se convierte en un entero sin signo , lo que puede conducir a comportamientos extraños si usa un número con signo.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

¡Tenga cuidado si usa parseInt para convertir un flotador en notación científica! Por ejemplo:

parseInt("5.6e-14") 

resultará en

5 

en vez de

0

Para convertir una Cadena en Entero, recomiendo usar parseFloat y NO parseInt. Este es el por qué:

Usando parseFloat:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

Usando parseInt:

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

Entonces, si ha notado que parseInt descarta los valores después de los decimales, mientras que parseFloat le permite trabajar con números de coma flotante y, por lo tanto, es más adecuado si desea retener los valores después de los decimales. Use parseInt si y solo si está seguro de que desea el valor entero.

También como nota al margen: Mootools tiene la función toInt () que se usa en cualquier cadena nativa (o flotante (o entero)).

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

Vea el ejemplo a continuación. Le ayudará a aclarar sus dudas.

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

mediante el uso de la función parseint Solo dará op de entero presente y no la cadena

podemos usar en +(stringOfNumber)lugar de usarparseInt(stringOfNumber)

Ej: +("21")devuelve int de 21 como el parseInt("21").

también podemos usar este operador unario "+" para analizar flotante ...

Intenta str - 0convertir stringa number.

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

Aquí hay dos enlaces para comparar el rendimiento de varias formas de convertir cadenas a int

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

Hay muchas formas en JavaScript para convertir una cadena en un valor numérico ... Todo simple y práctico, elija la forma en que funciona para usted:

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

Además, cualquier operación matemática los convierte en números, por ejemplo ...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

Mi forma preferida es usar el +signo, que es la forma elegante de convertir una cadena a número en JavaScript.

Google me dio esta respuesta como resultado, así que ...

De hecho, necesitaba "guardar" una cadena como un entero, para un enlace entre C y JavaScript, por lo que convierto la cadena en un valor entero:

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}

En mi opinión, ninguna respuesta cubre todos los casos extremos, ya que analizar un flotante debería provocar un error.

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}

parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN

Aquí está la solución más fácil.

let myNumber = "123" | 0;

Solución más fácil

let myNumber = +"123";

Todas las anteriores son correctas. Antes de asegurarse de que se trata de un número en una cadena, haga "typeot x === 'número'"; de lo contrario, devolverá NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

Otra opción es duplicar XOR el valor consigo mismo:

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

Esto generará:

i = 12.34
i ⊕ i ⊕ i = 12

¡Solo agregué un signo más (+) antes de la cadena y esa fue la solución!

+"052254" //52254

Espero eso ayude ;)

Sumando la multiplicación de dígitos con su respectiva potencia de diez:

es decir: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

yo uso esto

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

de esta manera siempre obtengo un int int.

La forma más segura de asegurarse de obtener un número entero válido:

let integer = (parseInt(value, 10) || 0);

Ejemplos:

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0

// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230

// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0

function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}

puedes usar más, por ejemplo =>

var personAge = '24'; var personAge1 = (+ personAge)

entonces puedes ver el tipo de persona La edad es el número