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


Respuestas:


2154

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)

1
jsperf.com/performance-of-parseint/29 , hy @jedierikb edité el enlace jsperf. Sumando '4'>>0y '4'>>>0.
emaniacs

66
Actualización a 2015: a partir de ECMAScript 5, las cadenas con un cero inicial "0" también obtienen la raíz predeterminada 10, en lugar de 8. La especificación explícita de la raíz 10 solo es necesaria para los navegadores más antiguos. kangax.github.io/compat-table/es5/…
Grilse

20
Tenga en cuenta que Number ('') tiene éxito (devuelve 0), aunque la mayoría de las personas no considerarían que la cadena vacía representa un número válido. Y parseInt ('3q') tiene éxito (devuelve 3) aunque la mayoría de la gente no consideraría que '3q' es un número válido.
Dave Pacheco

3
Aviso. Ambos parseInty parseFloatfelizmente acepta cartas. Solo Numberregresa NaNconsistentemente.
Karl Pokus

2
En mi opinión, analizar un número entero debería resultar con una excepción / NaNpara cada valor que no sea exactamente un número entero. Por lo tanto, ninguno de estos funciona como Number('2.2')coacción 2y Number('')coacción a 0.
Michał Knapik

225

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

44
Radix ya no es necesario en 2016.

77
Puede que no sea para los navegadores más nuevos, pero aún se requiere radix para la compatibilidad con versiones anteriores.
Profesor de programación el

¿Qué pasa con '' o '02 "o" 02 + 1 ", o" 03,12 "o" 03.12 "?
stackdave

3
Tenga en cuenta que esto ignora los datos incorrectos después del número. Por ejemplo, parseInt('0asdf', 10)produce 0.
Sam

121

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ó).


66
Depende de si quieres que tu código también acepte 97,8,00y similar o no. Un truco simple es hacer .replace(/[^0-9]/g, "")lo que eliminará todos los dígitos que no sean de su cadena y luego realizará la conversión. Por supuesto, esto no hará caso de todo tipo de cuerdas locas que probablemente debería de error en lugar de sólo de análisis ...
kybernetikos

66
@kybernetikos probablemente debería serlo .replace(/[^0-9.]/g, ""), de lo contrario "1.05" se convertirá en "105".
J.Steve

Muy bien, aunque de todos modos no usaría algo así para un código importante: hay tantas formas en que puede dejar pasar algo que realmente no quieres dejar pasar.
kybernetikos

2
Encontré que usar Number es mucho más legible en el código, así que gracias por señalarlo como una solución.
carlin.scott

1
@kybernetikos En var fixed = Number("97.654").toFixed(0); // rounded rather than truncated, estamos obteniendo un string(debido al .toFixedmétodo) en lugar de un number(entero). Si queremos el número entero redondeado, probablemente sea mejor usarloMath.round("97.654");
Edu Zamora

50

ParseInt () y + son diferentes

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

36

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;
}

ingrese la descripción de la imagen aquí


36

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

ingrese la descripción de la imagen aquí

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


No hay diferencia significativa entre los resultados de las pruebas A, B, E y F - todos son esencialmente los mismos,
Alf Eaton

33

Prueba parseInt.

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

44
Probablemente también desee incluir la raíz con eso: var number = parseInt ("10", 10);
Joel Coehoorn el

27

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

19

¡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

14
Usar parseIntno funcionaría bien para un flotador. parseFloatFunciona correctamente en este caso.
benekastah

16

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.


66
La pregunta era "¿Cómo convierto una cadena en un entero en JavaScript?"
Pierre Arlaud

15

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

77
El tercer ejemplo causa un SyntaxError, debe usar un punto doble, por ejemplo: 2..toInt();el primer punto terminará la representación de un Numberliteral y el segundo punto es el descriptor de acceso de propiedad.
CMS

2
Esta pregunta no se trata de mootools sino de JavaScript.
Liam

14

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


12

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 ...


1
¡Pero no puedes usarlo en fórmulas! Es decir (1 + ("21")) * 10 === 1210!
Alexander Vasilyev

2
@AlexanderVasilyev Creo que puedes, ¿no usarías un paréntesis extra alrededor del +?
NiCk Newman

@NiCkNewman Obtengo + ("21") del ejemplo en la respuesta que comentamos.
Alexander Vasilyev

Realmente no me gusta esta solución. No es explícito como parseIntes. Una implementación común es la const myNumber = +myNumberAsAStringque parece un estándar +=u =+operador a primera vista. Además, si se usa incorrectamente, podría provocar errores de concatenación. Esta solución se basa en el hecho de que 0 se supone como el lado izquierdo cuando no se proporciona ningún número.
Storm Muller el


10

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.


8

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;
}

44
Esa es una forma interesante de almacenar y recuperar valores de 4 bytes. No responde la interpretación convencional de la pregunta: cómo convertir una representación de cadena de un número en un valor entero. En cualquier caso, su int2strfunción se detiene si un byte es 0, lo que podría ser un elemento legítimo dentro del valor, por lo que if... breakdebe eliminarse para que se devuelva un valor completo de 4 bytes.
Suncat2000

8

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

1
Devolver no un número es un poco agresivo para una carroza, ¿no te parece?
Thomas Ayoub

2
Es parseInteger, no parseNumber. Supongo que todas las soluciones son una solución ya que JS no admite enteros y flotantes como tipos separados. Podríamos regresar en nulllugar de NaN, si no un número es engañoso.
Michał Knapik

4

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

let myNumber = "123" | 0;

Solución más fácil

let myNumber = +"123";

2

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`

En el nodo v8.5.0, var num1 = "12423"; typeof num1;devuelve string.
Edu Zamora

2

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

2

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

+"052254" //52254

Espero eso ayude ;)


2

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;

}


1

function doSth(){
  var a = document.getElementById('input').value;
  document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
  return +str;
}
<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>


1

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.


1

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

1
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);
}

0

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

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.