Convertir una cadena a un entero?
https://stackoverflow.com/questions/1133770
-
16-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cómo puedo convertir una cadena a un entero en JavaScript?
Solución
La forma más sencilla sería utilizar la función Number orígenes:
var x = Number("1000")
Si eso no funciona para usted, entonces no son los parseInt , unario mas , parseFloat con piso y Math.round métodos.
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])
plus unario Si la cadena ya está en la forma de un número entero:
var x = +"1000";
Si la cadena es o podría ser un flotador y se desea un entero:
var x = Math.floor("1000.01"); //floor automatically converts string to number
o, si se va a utilizar Math.floor varias veces:
var floor = Math.floor;
var x = floor("1000.01");
Si usted es el tipo que se olvida de poner la raíz en cuando se llama a parseInt, puede utilizar parseFloat y alrededor de ella como usted quiera. Aquí, he utilizado piso.
var floor = Math.floor;
var x = floor(parseFloat("1000.01"));
Curiosamente, Math.round (como Math.floor) va a hacer una cadena de conversión de números, por lo que si desea que el número redondeado (o si tiene un número entero en la cadena), esta es una gran manera, tal vez mi favorita :
var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)
Otros consejos
Trate 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 volverá el número 8. Por lo tanto, es necesario especificar una raíz (del 2 al 36). En este caso la 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 malos datos después de analizar nada válido.
Este GUID analizará como 51:
var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true
Hay dos formas principales para convertir una cadena en un número en javascript. Una forma es analizar ésta y la otra forma es cambiar su tipo a un número. Todos los trucos en las otras respuestas (por ejemplo, más unario) implican implícitamente coaccionar el tipo de la cadena en un número. También se puede hacer la misma cosa explícitamente con la función de Número.
Analizar
var parsed = parseInt("97", 10);
parseInt y parseFloat son las dos funciones que se utilizan para analizar cadenas de números. Análisis se detendrá en silencio si golpea a un personaje que no reconoce, 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 el mal de entrada, en su lugar pondremos NaN a menos que la cadena comienza con un número. Espacios en blanco al principio de la cadena se ignora. He aquí un ejemplo de ello hacer algo diferente a lo que quiere, y sin dar ninguna indicación de que algo iba 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 se inició con un 0, que sería interpretado como octal si la raíz no se ha especificado que se llevó a mucha gente por sorpresa. El comportamiento para hexadecimal se desencadena por tener la cadena comienza con 0x si no se especifica radix, por ejemplo, 0xff. El estándar de hecho cambió con ECMAScript 5, por lo que los navegadores modernos ya no desencadenan octal cuando hay un 0 si no se ha especificado radix. parseInt entiende radixes hasta la base 36, en cuyo caso tanto letras mayúsculas y minúsculas son tratadas como equivalentes.
Cambiar el tipo de una cadena en un número
Todos los otros trucos mencionados anteriormente que no utilizan parseInt, implican implícitamente coaccionar a la cadena en un número. Yo prefiero hacer esto de forma explícita,
var cast = Number("97");
Esto tiene un comportamiento diferente a los métodos de análisis sintáctico (aunque todavía ignora los espacios en blanco). Es más estricto: si no entiende el conjunto de la cadena que devuelve NaN, por lo que no se puede utilizar para cadenas como 97px. Puesto que usted quiere un número primitiva en lugar de un objeto envoltorio Número, asegúrese de que no pone new delante de la función de número.
Obviamente, la conversión a un número da un valor que podría ser un flotador en lugar de un número entero, así que si quieres un entero, es necesario modificarlo. Hay algunas maneras 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 de bits (en este caso he hecho un OR, pero también se puede hacer una doble negación como en una respuesta anterior o una BitShift) convertirá el valor a un número entero de 32 bits, y la mayoría de ellos se convertirá en una firmado entero. Tenga en cuenta que este no quiero que desea para grandes números enteros . Si el número entero no puede ser representado en 32bits, que envolverá.
~~"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 los números más grandes, debe utilizar 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 comprenden la notación exponencial, por lo que se 2e2 200 en lugar de NaN. Además, Número entiende "infinito", mientras que los métodos de análisis sintáctico no lo hacen.
Personalizado
Es poco probable que cualquiera de estos métodos hacen exactamente lo que quiere. Por ejemplo, por lo general me gustaría que un error arrojado si falla el análisis, y no necesitan apoyo para el infinito, exponenciales o espacios iniciales. Dependiendo de su caso de uso, a veces tiene sentido escribir una función de conversión personalizado.
Compruebe siempre que la salida de número o uno de los métodos de análisis sintáctico es el tipo de número que se espera. Es casi seguro que desee utilizar isNaN para asegurarse de que el número no es NaN (por lo general la única forma de averiguar que el análisis sintáctico no).
parseInt () y + son diferentes
parseInt("10.3456") // returns 10
+"10.3456" // returns 10.3456
A pesar de una vieja pregunta, pero tal vez esto puede ser útil a alguien.
Yo uso esta manera de convertir cadena a int número
var str = "25"; // string
var number = str*1; // number
Por lo tanto, cuando se multiplican por 1, el valor no cambia, pero JS vuelve automáticamente un número.
Sin embargo, como se demuestra más adelante, esto se debe utilizar si está seguro de que el str es un número (o puede ser representado como un número), en caso contrario devolverá NaN - no es un número
puede crear la función simple de usar, por ejemplo.
function toNumber(str) {
return str*1;
}
Trate parseInt.
var number = parseInt("10", 10); //number will have value of 10.
más rápido
var x = "1000"*1;
prueba
Aquí es pequeña comparación de la velocidad (sólo Mac OS) ...:)
Para cromo 'más' y 'mul' están más rápida (> 700,000,00 op / seg), 'Math.floor' es más lenta. Para Firefox 'más' es más lenta (!) 'Mul' es más rápida (> 900 millones op / seg). En Safari 'parseInt' es fastes, 'número' es más lenta (pero resulats son bastante similares,> 13000000 <31000000). Así Safari para cadena de fundición a int es más de 10 veces más lento que otros navegadores. Por lo que el ganador es ' mul ':)
Puede ejecutarlo en su navegador por medio de este enlace https://jsperf.com/js-cast-str-to-number/ 1
Actualizar
También var x = ~~"1000"; prueba - 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%). Puedo actualizar la imagen de arriba y de prueba
He publicado la respuesta equivocada aquí, lo siento. fijo.
Esta es una vieja pregunta, pero me encanta este truco:
~~"2.123"; //2
~~"5"; //5
El negativo de doble bit a bit deja nada después de la coma decimal y la convierte en un formato de número. Me han dicho que es ligeramente más rápido que llamar funciones y todo eso, pero no estoy del todo convencido.
EDIT: Otro método que acabo de ver aquí (una pregunta sobre el Javascript >>> operador, que es un relleno de cero desplazamiento a la derecha), que muestra que el desplazamiento de un número por 0 con este operador convierte el número a un uint32 que está bien si usted también quiere que sin signo . De nuevo, esto se convierte en un entero sin signo , que puede conducir a comportamientos extraños si se utiliza un número con signo.
"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5
Tenga cuidado si utiliza parseInt para convertir un flotante en notación científica! Por ejemplo:
parseInt("5.6e-14")
también se
5
en lugar de
0
También como una nota:. Mootools tiene la Toint () la función que se utiliza en cualquier cadena nativa (o flotador (o entero))
"2".toInt() // 2
"2px".toInt() // 2
2.toInt() // 2
Uso parseFloat:
parseFloat('2.34cms') //Output: 2.34
parseFloat('12.5') //Output: 12.5
parseFloat('012.3') //Output: 12.3
Uso parseInt:
parseInt('2.34cms') //Output: 2
parseInt('12.5') //Output: 12
parseInt('012.3') //Output: 12
Así que si usted ha notado parseInt descarta los valores después de los decimales, mientras que parseFloat le permite trabajar con números de punto y por lo tanto más adecuada flotante si desea conservar los valores después de decimales. Usar parseInt si y sólo si está seguro de que desea que el valor entero.
Por favor, ver el siguiente example.It ayudará a despejar la duda
Example Result
parseInt("4") 4
parseInt("5aaa") 5
parseInt("4.33333") 4
parseInt("aaa"); NaN (means "Not a Number")
utilizando la función parseInt Es sólo dará op de número entero presente y no la cadena
podemos utilizar +(stringOfNumber) en lugar de utilizar parseInt(stringOfNumber)
Ex:. +("21") devuelve int de 21 como el parseInt("21")
podemos utilizar este operador unario "+" para analizar flotador también ...
str - 0 tratar de convertir a string 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 la cadena a int
Hay muchas maneras en JavaScript para convertir una cadena en un valor numérico ... Todo simples y prácticos, elegir la forma en que se trabaja 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
También cualquier Matemáticas operación 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 prefieren forma es utilizar signo +, que es la manera elegante para convertir una cadena a número en JavaScript.
En mi opinión, no hay respuesta abarca todos los casos de orillo como analizar un flotador debe dar lugar a 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
Google me dio esta respuesta como resultado de ello, así que ...
En realidad tenía que "salvar" a una cadena como un entero, para una unión entre C y JavaScript, así que convertir 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;
}
todas las anteriores son correctas. Por favor, asegúrese antes de que este es un número en una cadena haciendo "typeot x === 'número'" de otra forma se volverá NaN
var num = "fsdfsdf242342";
typeof num => 'string';
var num1 = "12423";
typeof num1 => 'number';
+num1 = > 12423`
Otra opción es hacer doble XOR con el valor propio:
var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));
Esta es la salida:
i = 12.34
i ⊕ i ⊕ i = 12
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>
Yo uso este
String.prototype.toInt = function (returnval) {
var i = parseInt(this);
return isNaN(i) ? returnval !== undefined ? returnval : - 1 : i;
}
esta manera siempre me dan un int espalda.
sólo añade un signo más (+) antes de cuerda y que estaba solución!
+"052254" //52254
Espero que ayuda;)
Resumiendo 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;
}
Esta es la solución más fácil
let myNumber = "123" | 0;
La forma más segura de asegurarse de que obtiene un 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);
}
