Búsqueda de sitios web

¿Cómo convertir una cadena en un número entero en JavaScript?

¿Cómo convierto una cadena en un número entero en JavaScript?

Respuesta #1

La forma más simple sería usar la función nativa Number:

var x = Number("1000")

Si eso no funciona para ti, entonces están los métodos parseInt, unary plus, parseFloat con 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])

Signo más unario

Si tu cadena ya está en forma de un número entero:

var x = +"1000";

floor()

Si tu cadena es o podría ser un número decimal y quieres 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");

parseFloat()

Si eres del tipo que olvida poner la base al llamar a parseInt, puedes usar parseFloat y redondearlo como quieras. Aquí uso floor.

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

round()

Curiosamente, Math.round (al igual que Math.floor) hará una conversión de cadena a número, así que si quieres el número redondeado (o si tienes un entero en la cadena), esta es una excelente manera, tal vez mi favorita:

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

Respuesta #2

Prueba la función parseInt:

var number = parseInt("10");

Pero hay un problema. Si intentas convertir "010" usando la función parseInt, se detectará como un número octal, y devolverá el número 8. Por lo tanto, necesitas especificar una base (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 parseInt ignora los datos incorrectos después de analizar cualquier cosa válida.
Esta guía se analizará como 51:

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

Respuesta #3

Hay dos maneras principales de convertir una cadena en un número en JavaScript. Una manera es analizarla y la otra manera es cambiar su tipo a un Número. Todos los trucos en las otras respuestas (por ejemplo, el signo más unario) implican coercer implícitamente el tipo de la cadena a un número. También puedes hacer lo mismo explícitamente con la función Number.

Analizando

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

parseInt y parseFloat son las dos funciones utilizadas para convertir cadenas en números. La conversión se detendrá silenciosamente si encuentra un carácter que no reconoce, lo cual puede ser útil para convertir cadenas como "92px", pero también es algo peligroso ya que no dará ningún tipo de error en caso de entrada incorrecta; en su lugar, obtendrás NaN a menos que la cadena comience con un número. Los espacios en blanco al principio de la cadena se ignoran. Aquí hay un ejemplo de que hace algo diferente de lo que quieres y no indica que algo haya salido mal:

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

Es una buena práctica siempre especificar la base como el segundo argumento. En navegadores antiguos, si la cadena empezaba con un 0, se interpretaba como octal si no se especificaba la base, lo cual sorprendía a muchas personas. El comportamiento para hexadecimal se activa al comenzar la cadena con 0x si no se especifica la base, por ejemplo, 0xff. El estándar cambió en realidad con ECMAScript 5, por lo que los navegadores modernos ya no activan octal cuando hay un 0 inicial si no se ha especificado la base. parseInt comprende bases hasta 36, en cuyo caso se considera equivalente tanto letras mayúsculas como minúsculas.

Cambiar el tipo de una cadena a un número

Todos los demás trucos mencionados arriba que no usan parseInt implican forzar implícitamente la conversión de la cadena a un número. Prefiero hacer esto de forma explícita,

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 entiende toda la cadena, devuelve NaN, por lo que no se puede usar para cadenas como 97px. Dado que quieres un número primitivo en lugar de un objeto wrapper Number, asegúrate de no poner new delante de la función Number.

Obviamente, convertir a un Número te da un valor que podría ser un flotante en lugar de un entero, así que si quieres un entero, necesitas modificarlo. Hay varias formas de hacer esto:

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 a nivel de bits (aquí he hecho un OR a nivel de bits, pero también podrías 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. Ten en cuenta que esto no hará lo que quieres para enteros grandes. Si el entero no puede representarse en 32 bits, se desbordará.

~~"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, deberías usar los métodos de redondeo

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

Ten en cuenta que la coerción entiende la notación exponencial y el Infinity, así que 2e2 es 200 en lugar de NaN, mientras que los métodos parse no lo hacen.

Personalizado

Es poco probable que cualquiera de estos métodos haga exactamente lo que deseas. Por ejemplo, normalmente querría que se lanzara un error si el análisis falla, y no necesito soporte para Infinity, exponenciales o espacios en blanco al principio. Dependiendo de tu caso de uso, a veces tiene sentido escribir una función de conversión personalizada.

Siempre verifica que la salida de Number o de uno de los métodos parse sea el tipo de número que esperas. Casi con seguridad querrás usar isNaN para asegurarte de que el número no sea NaN (usualmente la única manera de descubrir que el análisis falló).

Respuesta #4

ParseInt() y + son diferentes.

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Respuesta #5

Más rápido

var x = "1000"*1;

Prueba

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

Para Chrome, 'plus' y 'mul' son los más rápidos (>700,000,000 op/seg), '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/seg). En Safari, 'parseInt' es el más rápido, 'number' es el más lento (pero los resultados son bastante similares, >13,000,000 <31,000,000). Así que Safari para convertir cadenas a enteros es más de 10 veces más lento que otros navegadores. Así que el ganador es 'mul' :)

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

También probé var x=~~"1000";. En Chrome y Safari, es un poco más lento que var x="1000"*1 (<1%), y en Firefox es un poco más rápido (<1%).

Respuesta #6

Uso esta manera de convertir una cadena en número:

var str = "25";       // String
var number = str*1;   // Number

Así que, al multiplicar por 1, el valor no cambia, pero JavaScript automáticamente devuelve un número.

Pero como se muestra a continuación, esto se debe usar si estás seguro de que el str es un número (o puede representarse como un número), de lo contrario devolverá NaN - no es un número.

Puedes crear una función simple para usar, por ejemplo,

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

Respuesta #7

Prueba parseInt.

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

Respuesta #8

Me encanta este truco:

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

El doble negativo a nivel de bits elimina 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 demás, pero no estoy completamente convencido.

Otro método que acabo de ver aquí (una pregunta sobre el operador JavaScript >>>, que es un desplazamiento a la derecha con relleno de ceros) que muestra que desplazar un número por 0 con este operador convierte el número en un uint32, lo cual es útil si también lo quieres sin signo. Nuevamente, esto convierte a un entero sin signo, lo que puede llevar a comportamientos extraños si usas un número con signo.

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

Respuesta #9

Por favor, vea el siguiente ejemplo. Ayudará a responder su pregunta.

Example                  Result

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

Al usar la función parseint, solo devolverá el valor entero presente y no la cadena.

Respuesta #10

En JavaScript, puedes hacer lo siguiente:

ParseInt

parseInt("10.5") // Returns 10

Multiplicar por 1

var s = "10";
s = s*1;  // Returns 10

Usando el operador unario (+)

var s = "10";
s = +s;  // Returns 10

Usando un operador a nivel de bits

(Nota: Comienza a romperse después de 2140000000. Ejemplo: ~~"2150000000"=-2144967296)

var s = "10.5";
s = ~~s; // Returns 10

Usando Math.floor() o Math.ceil()

var s = "10";
s = Math.floor(s) || Math.ceil(s); // Returns 10

Respuesta #11

¡Cuidado si usas parseInt para convertir un número flotante en notación científica! Por ejemplo:

parseInt("5.6e-14")

dará lugar a

5

en lugar de

0

Respuesta #12

Para convertir una cadena en un entero, recomiendo usar parseFloat y no parseInt. He aquí 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

Así que si has notado, parseInt descarta los valores después de los decimales, mientras que parseFloat te permite trabajar con números de punto flotante y, por lo tanto, es más adecuado si quieres conservar los valores después de los decimales. Usa parseInt solo si estás seguro de que quieres el valor entero.

Respuesta #13

Podemos usar +(stringOfNumber) en lugar de usar parseInt(stringOfNumber).

Ejemplo: +("21") devuelve un int de 21, como parseInt("21").

También podemos usar este operador unario "+" para analizar flotantes...

Respuesta #14

Hay muchas maneras en JavaScript de convertir una cadena en un valor numérico... Todas son simples y prácticas. Elige la manera que funcione para ti:

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 de Matemáticas los convierte en número, 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 manera elegante de convertir una cadena en número en JavaScript.

Respuesta #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

Respuesta #16

Cadena a Número en JavaScript:

Unario + (más recomendado)

  • +numStr es fácil de usar y tiene un mejor rendimiento en comparación con otros
  • Admite tanto enteros como decimales
console.log(+'123.45') // => 123.45

Algunas otras opciones:

Analizando cadenas:

  • parseInt(numStr) para números enteros
  • parseFloat(numStr) tanto para enteros como para decimales
console.log(parseInt('123.456')) // => 123
console.log(parseFloat('123'))   // => 123

Funciones de JavaScript

  • Funciones matemáticas como round(numStr), floor(numStr), ceil(numStr) para enteros

  • Number(numStr) tanto para enteros como para decimales

console.log(Math.floor('123'))     // => 123
console.log(Math.round('123.456')) // => 123
console.log(Math.ceil('123.454'))  // => 124
console.log(Number('123.123'))     // => 123.123

Operadores unarios

  • Todos los operadores unarios básicos, +numStr, numStr-0, 1*numStr, numStr*1 y numStr/1

  • Todos soportan tanto enteros como decimales

  • Ten cuidado con numStr+0. Devuelve una cadena.

console.log(+'123')  // => 123
console.log('002'-0) // => 2
console.log(1*'5')   // => 5
console.log('7.7'*1) // => 7.7
console.log(3.3/1)   // =>3.3
console.log('123.123'+0, typeof ('123.123' + 0)) // => 123.1230 string

Operadores a nivel de bits

  • Dos tildes ~~numStr o desplazamiento a la izquierda 0, numStr<<0
  • Admite solo enteros, pero no decimales
console.log(~~'123')      // => 123
console.log('0123'<<0)    // => 123
console.log(~~'123.123')  // => 123
console.log('123.123'<<0) // => 123


// Parsing
console.log(parseInt('123.456')) // => 123
console.log(parseFloat('123'))   // => 123

// Function
console.log(Math.floor('123'))     // => 123
console.log(Math.round('123.456')) // => 123
console.log(Math.ceil('123.454'))  // => 124
console.log(Number('123.123'))     // => 123.123

// Unary
console.log(+'123')  // => 123
console.log('002'-0) // => 2
console.log(1*'5')   // => 5
console.log('7.7'*1) // => 7.7
console.log(3.3/1)   // => 3.3
console.log('123.123'+0, typeof ('123.123'+0)) // => 123.1230 string

// Bitwise
console.log(~~'123')      // => 123
console.log('0123'<<0)    // => 123
console.log(~~'123.123')  // => 123
console.log('123.123'<<0) // => 123

Respuesta #17

Intenta str - 0 para convertir string a número.

> 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 una cadena a entero

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

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

Respuesta #18

En mi opinión, ninguna respuesta cubre todos los casos extremos, ya que al analizar un número flotante debería resultar en 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

Respuesta #19

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

let myNumber = "123" | 0;

Solución más fácil

let myNumber = +"123";

Artículos relacionados