valor - parseint javascript

¿Cómo convertir NaN desde parseInt en 0 para una cadena vacía?

Question

¿Es posible de alguna manera devolver 0 en lugar de NaN al analizar valores en JavaScript?

En el caso de la cadena vacía, parseInt devuelve NaN .

¿Es posible hacer algo así en JavaScript para verificar si hay NaN ?

var value = parseInt(tbb) == NaN ? 0 : parseInt(tbb)

¿O tal vez hay otra función o complemento jQuery que puede hacer algo similar?

Answer 1

¿El trabajo es mucho más limpio que parseInt en mi opinión, use el operador +

var s = '''';
console.log(+s);

var s = ''1024''
+s
1024

s = 0
+s
0

s = -1
+s
-1

s = 2.456
+s
2.456

s = ''''
+s
0

s = ''wtf''
+s
NaN

Answer 2

¿Por qué no anular la función? En ese caso, siempre puede estar seguro de que devuelve 0 en caso de NaN :

(function(original) {
    parseInt = function() {
        return original.apply(window, arguments) || 0;
    };
})(parseInt);

Ahora, en cualquier parte de tu código:

parseInt('''') === 0

Answer 3

Aquí hay un método tryParseInt que estoy usando, este toma el valor predeterminado como segundo parámetro para que pueda ser lo que necesites.

function tryParseInt(str, defaultValue) {
    return parseInt(str) == str ? parseInt(str) : defaultValue;
}

tryParseInt("", 0);//0 
tryParseInt("string", 0);//0 
tryParseInt("558", 0);//558

Answer 4

Creé un prototipo 2 para manejar esto por mí, uno para un número y otro para una cadena.

// This is a safety check to make sure the prototype is not already defined.
Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
        return this;
    }
};

// returns the int value or -1 by default if it fails
Number.method(''tryParseInt'', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

// returns the int value or -1 by default if it fails
String.method(''tryParseInt'', function (defaultValue) {
    return parseInt(this) == this ? parseInt(this) : (defaultValue === undefined ? -1 : defaultValue);
});

Si no desea utilizar el control de seguridad, utilice

String.prototype.tryParseInt = function(){
    /*Method body here*/
};
Number.prototype.tryParseInt = function(){
     /*Method body here*/
};

Ejemplo de uso:

var test = 1;
console.log(test.tryParseInt()); // returns 1

var test2 = ''1'';
console.log(test2.tryParseInt()); // returns 1

var test3 = ''1a'';
console.log(test3.tryParseInt()); // returns -1 as that is the default

var test4 = ''1a'';
console.log(test4.tryParseInt(0));// returns 0, the specified default value

Answer 5

Haga una comprobación por separado para una cadena vacía (ya que es un caso específico) y establézcala en cero en este caso.

Puede aplicar "0" al inicio, pero luego debe agregar un prefijo para indicar que es un decimal y no un número octal

Answer 6

Me sorprendió no ver a nadie mencionar usando Number() . Concedido, analizará los decimales si se proporciona, por lo que actuará de manera diferente a parseInt() , sin embargo, ya asume la base 10 y convertirá "" o incluso "" en 0.

Answer 7

Para las personas que no están restringidas a parseInt , puede usar el operador OR a nivel de bit (que implícitamente llama a ToInt32 a sus operandos).

var value = s | 0;

// NaN | 0     ==>> 0
// ''''  | 0     ==>> 0
// ''5'' | 0     ==>> 5
// ''33Ab'' | 0  ==>> 0
// ''0x23'' | 0  ==>> 35
// 113 | 0     ==>> 113
// -12 | 0     ==>> -12
// 3.9 | 0     ==>> 3

Nota: ToInt32 es diferente de parseInt . (es decir, parseInt(''33Ab'') === 33 )

Answer 8

También de esta manera, ¿por qué no escribir una función y llamarla cuando sea necesario? Supongo que es la entrada en los campos del formulario para realizar cálculos.

var Nanprocessor = function (entry) {
    if(entry=="NaN") {
        return 0;
    } else {
        return entry;
    }
}

 outputfield.value = Nanprocessor(x); 

// where x is a value that is collected from a from field
// i.e say x =parseInt(formfield1.value); 

¿Qué está mal haciendo esto?

Answer 9

También puedes usar la función isNaN() :

var s = ''''
var num = isNaN(parseInt(s)) ? 0 : parseInt(s)

Answer 10

Tuve un problema similar (firefox v34) con cadenas simples como:

var myInt = parseInt("b4");

Así que se me ocurrió un truco rápido de:

var intVal = ("" + val).replace(/[^0-9]/gi, "");

Y luego se hizo todo estúpido complicado lidiar con floats + ints para cosas no simples:

var myval = "12.34";

function slowParseNumber(val, asInt){
    var ret = Number( ("" + val).replace(/[^0-9/.]/gi, "") );
    return asInt ? Math.floor(ret) : ret;
}
var floatVal = slowParseNumber(myval);

var intVal = slowParseNumber(myval, true);
console.log(floatVal, intVal);

Devolverá 0 para cosas como:

var intVal = slowParseNumber("b"); // yeilds 0

Answer 11

Una función auxiliar que todavía permite utilizar el radix.

function parseIntWithFallback(s, fallback, radix) {
    var parsed = parseInt(s, radix);
    return isNaN(parsed) ? fallback : parsed;
}

Answer 12

El problema

Otras respuestas no tienen en cuenta que 0 es falsy y, por lo tanto, lo siguiente será 20 en lugar de 0:

var myNumber = parseInt(''0'') || 20; // 20

La solución

Propongo una función de ayuda, que resuelve la mayoría de los problemas:

function getNumber(number, defaultNumber) {
    return isNaN(parseInt(number, 10)) ? defaultNumber : parseInt(number, 10);
}

La función de ayuda dará los siguientes resultados:

getNumber(''0'', 20); // 0
getNumber(''2'', 20); // 2
getNumber(''2.2'', 20); // 2
getNumber(''any string'', 20); // 20
getNumber(undefined, 20); // 20
getNumber(null, 20); // 20
getNumber(NaN, 20); // 20
getNumber(false, 20); // 20
getNumber(true, 20); // 20

Answer 13

// implicit cast
var value = parseInt(tbb*1); // see original question

Explicación, para aquellos que no lo encuentran trivial:

Al multiplicar por uno, un método llamado "conversión implícita", intenta convertir el operando de tipo desconocido en el tipo primitivo ''número''. En particular, una cadena vacía se convertiría en el número 0, por lo que es un tipo elegible para parseInt () ...

PirateApp también dio un muy buen ejemplo, quien sugirió que se antepuje el signo +, lo que obligó a JavaScript a usar el número implícito de conversión.

Answer 14

//////////////////////////////////////////////////////
function ToInt(x){x=parseInt(x);return isNaN(x)?0:x;}
//////////////////////////////////////////////////////
var x = ToInt('''');   //->  x=0
    x = ToInt(''abc'') //->  x=0
    x = ToInt(''0.1'') //->  x=0
    x = ToInt(''5.9'') //->  x=5
    x = ToInt(5.9)   //->  x=5
    x = ToInt(5)     //->  x=5

Answer 15

var s = '''';

var num = parseInt(s) || 0;

Answer 16

var value = isNaN(parseInt(tbb)) ? 0 : parseInt(tbb);