quitar - nan javascript parseint

¿Por qué isNaN("") es igual a falso?

Question

Tengo una pregunta rápida (¡espero!). En JS, ¿por qué isNaN(" ") evalúa a falso, pero isNaN(" x") evalúa a verdadero?

Estoy realizando operaciones numéricas en un campo de entrada de texto, y estoy comprobando si el campo es nulo, "" o NaN. Cuando alguien escribe un puñado de espacios en el campo, mi validación falla en los tres, y estoy confundido en cuanto a por qué pasa la comprobación de ISNAN.

¡Gracias!

Answer 1

La respuesta no completamente correcta

La respuesta altamente votada y aceptada de Antonio Haley aquí supone erróneamente que este proceso pasa por la función parseInt de JavaScript:

Puede usar parseInt en la cadena ... El resultado debería fallar isNAN.

Podemos refutar fácilmente esta afirmación con la cadena "123abc" :

parseInt("123abc")    // 123     (a number...
isNaN("123abc")       // true     ...which is not a number)

Con esto, podemos ver que la función parseInt de JavaScript devuelve "123abc" como el número 123 , sin embargo, su función isNaN nos dice que "123abc" no es un número.

La respuesta correcta

ECMAScript-262 define cómo funciona la comprobación de isNaN en la sección 18.2.3 .

18.2.3 isNaN (Número)

La función isNaN es el objeto intrínseco %isNaN% . Cuando se isNaN función isNaN con un número de argumento, se siguen los siguientes pasos:

1. Deje num ser? ToNumber(number) .
2. Si num es NaN , devuelve true .
3. De lo contrario, devuelve false .

La función ToNumber que hace referencia también se define en la sección 7.1.3 de ECMAScript-262 . Aquí, se nos dice cómo JavaScript maneja las cadenas que se pasan a esta función.

El primer ejemplo dado en la pregunta es una cadena que contiene nada más que caracteres de espacio en blanco. Esta sección establece que:

Un StringNumericLiteral que está vacío o contiene solo espacios en blanco se convierte a +0 .

La " " cadena de ejemplo se convierte a +0 , que es un número.

La misma sección también dice:

Si la gramática no puede interpretar el String como una expansión de StringNumericLiteral , entonces el resultado de ToNumber es NaN .

Sin citar todas las verificaciones contenidas en esa sección, el ejemplo " x" dado en la pregunta cae en la condición anterior ya que no puede interpretarse como StringNumericLiteral . " x" se convierte por lo tanto en NaN .

Answer 2

Como otros explicaron, la función isNaN la cadena vacía en un número antes de validarlo, cambiando así una cadena vacía a 0 (que es un número válido). Sin embargo, encontré que la función parseInt devolverá NaN cuando intente analizar una cadena vacía o una cadena con solo espacios. Como tal, la siguiente combinación parece estar funcionando bien:

if ( isNaN(string) || isNaN(parseInt(string)) ) console.log(''Not a number!'');

Esta comprobación funcionará para números positivos, números negativos y números con un punto decimal, así que creo que cubre todos los casos numéricos comunes.

Answer 3

Creo que es debido a la escritura de Javascript: '' '' se convierte a cero, mientras que ''x'' no es:

alert('' '' * 1); // 0
alert(''x'' * 1); // NaN

Answer 4

De MDN razón por el problema que enfrenta

Cuando el argumento para la función isNaN no es de tipo Número, el valor se coacciona primero a un Número. El valor resultante se prueba para determinar si es NaN.

Es posible que desee comprobar la siguiente respuesta integral que cubre la comparación de NaN para la igualdad también.

Cómo probar si una variable de JavaScript es NaN

Answer 5

Escribí esta pequeña y rápida función para ayudar a resolver este problema.

function isNumber(val) {
     return (val != undefined && val != null && val.toString().length > 0 && val.toString().match(/[^0-9/./-]/g) == null);
};

Simplemente comprueba si hay caracteres que no son numéricos (0-9), que no son ''-'' o ''.'', Y que no están indefinidos, nulos o vacíos y devuelve verdadero si no hay coincidencias. :)

Answer 6

Esta función pareció funcionar en mis pruebas

function isNumber(s) {
    if (s === "" || s === null) {
        return false;
    } else {
        var number = parseInt(s);
        if (number == ''NaN'') {
            return false;
        } else {
            return true;
        }
    }
}

Answer 7

Intenta usar:

alert(isNaN(parseInt("   ")));

O

alert(isNaN(parseFloat("    ")));

Answer 8

JavaScript interpreta una cadena vacía como un 0, que luego falla la prueba isNAN. Puede usar parseInt en la cadena primero, que no convertirá la cadena vacía en 0. El resultado debería fallar entonces.

Answer 9

La función isNaN("") realiza una coerción de tipo String to Number

ECMAScript 3-5 define los siguientes valores de retorno para el operador typeof:

• indefinido
• objeto (null, objetos, matrices)
• booleano
• número
• cuerda
• función

Mejor ajustar nuestra prueba en un cuerpo de función:

function isNumber (s) {
    return typeof s == ''number''? true
           : typeof s == ''string''? (s.trim() === ''''? false : !isNaN(s))
           : (typeof s).match(/object|function/)? false
           : !isNaN(s)
}

Esta función no tiene la intención de probar el tipo de variable, en su lugar, prueba el valor coaccionado . Por ejemplo, booleanos y cadenas se fuerzan a números, por lo que quizás desee llamar a esta función como isNumberCoerced()

Si no es necesario probar otros tipos de cadena y número , el siguiente fragmento podría usarse como parte de alguna condición:

if (!isNaN(s) && s.toString().trim()!='''') // ''s'' can be boolean, number or string
    alert("s is a number")

Answer 10

La función isNaN espera un número como su argumento, por lo que los argumentos de cualquier otro tipo (en su caso una cadena) se convertirán en número antes de que se realice la lógica de la función real. (¡Tenga en cuenta que NaN también es un valor de tipo Number!)

Por cierto. esto es común para todas las funciones incorporadas: si esperan un argumento de cierto tipo, el argumento real se convertirá utilizando las funciones de conversión estándar. Hay conversiones estándar entre todos los tipos básicos (bool, cadena, número, objeto, fecha, nulo, indefinido).

La conversión estándar para String to Number se puede invocar explícitamente con Number() . Entonces podemos ver eso:

• Number(" ") evalúa a 0
• Number(" x") evalúa a NaN

¡Dado esto, el resultado de la función isNaN es completamente lógico!

La verdadera pregunta es por qué la conversión de String-to-Number estándar funciona como lo hace. La conversión de cadena a número realmente pretende convertir cadenas numéricas como "123" o "17.5e4" a los números equivalentes. La conversión salta primero el espacio en blanco inicial (para que "123" sea válido) y luego intenta analizar los silencios como un número. Si no se puede analizar como un número ("x" no), el resultado es NaN. Pero existe la regla especial explícita de que una cadena que está vacía o solo espacios en blanco se convierte a 0. Entonces, esto explica la conversión.

Referencia: http://www.ecma-international.org/ecma-262/5.1/#sec-9.3.1

Answer 11

La función JavaScript incorporada es, como debería esperarse por defecto, un "Operador de tipo dinámico". Por lo tanto, todos los valores que (durante el proceso DTC) pueden arrojar un simple verdadero | falso como "", " ", " 000" , no puede ser NaN.

Lo que significa que el argumento proporcionado se someterá primero a una conversión como en:

function isNaNDemo(arg){
   var x = new Number(arg).valueOf();
   return x != x;
}

Explicación:

En la línea superior del cuerpo de la función, estamos (primero) tratando de convertir con éxito el argumento en un objeto numérico. Y (segundo), usando el operador de punto estamos, para nuestra propia conveniencia, quitando inmediatamente, el valor primitivo del objeto creado.

En la segunda línea, estamos tomando el valor obtenido en el paso anterior, y la ventaja del hecho de que NaN no es igual a nada en el universo, ni siquiera a sí mismo, por ejemplo: NaN == NaN >> false para finalmente comparar (por desigualdad) consigo mismo.

De esta forma, el retorno de la función solo será verdadero cuando, y solo si, el argumento-retorno suministrado, es un intento fallido de conversión a un objeto numérico, es decir, un número que no es un número; por ejemplo, NaN.

isNaNstatic ()

Sin embargo, para un operador de tipo estático, si es necesario y cuando sea necesario, podemos escribir una función mucho más simple como:

function isNaNstatic(x){   
   return x != x;
}

Y evite el DTC por completo, de modo que si el argumento no es explícitamente un número NaN, devolverá falso. Por lo tanto, prueba contra lo siguiente:

isNaNStatic(" x"); // will return false isNaNStatic(" x"); // will return false porque todavía es una cadena.

Sin embargo: isNaNStatic(1/"x"); // will of course return true. isNaNStatic(1/"x"); // will of course return true. como por ejemplo isNaNStatic(NaN); >> true isNaNStatic(NaN); >> true .

Pero contrario a isNaN , el isNaNStatic("NaN"); >> false isNaNStatic("NaN"); >> false porque (el argumento) es una cadena ordinaria.

ps: la versión estática de isNaN puede ser muy útil en los escenarios de codificación modernos. Y puede ser una de las razones principales por las que me tomé mi tiempo para publicar esto.

Saludos.

Answer 12

Le sugiero que use la siguiente función si realmente desea una verificación adecuada si se trata de un número entero:

function isInteger(s)
{
   return Math.ceil(s) == Math.floor(s);
}

Answer 13

No estoy seguro de por qué , pero para evitar el problema, siempre puedes recortar el espacio en blanco antes de verificar. Probablemente quieras hacer eso de todos modos.

Answer 14

Para entenderlo mejor, abra el PDF de especificaciones de Ecma-Script en la página 43 "Número Aplicado al Tipo de Cadena"

si una cadena tiene una sintaxis numérica, que puede contener cualquier cantidad de caracteres de espacio en blanco, se puede convertir a tipo de Número. Cadena vacía evalúa a 0. También la cadena ''Infinito'' debería dar

isNaN(''Infinity''); // false

Answer 15

Puede encontrar esto sorprendente o tal vez no, pero aquí hay algunos códigos de prueba para mostrarle la locura del motor de JavaScript.

document.write(isNaN("")) // false
document.write(isNaN(" "))  // false
document.write(isNaN(0))  // false
document.write(isNaN(null)) // false
document.write(isNaN(false))  // false
document.write("" == false)  // true
document.write("" == 0)  // true
document.write(" " == 0)  // true
document.write(" " == false)  // true
document.write(0 == false) // true
document.write(" " == "") // false

entonces esto significa que

" " == 0 == false

y

"" == 0 == false

pero

"" != " "

Que te diviertas :)

Answer 16

Qué pasa

function isNumberRegex(value) {        
    var pattern = /^[-+]?/d*/.?/d*$/i;
    var match = value.match(pattern);
    return value.length > 0 && match != null;
}

Answer 17

Que isNaN(" ") es falso es parte del comportamiento confuso de la función global isNaN debido a su coerción de no números a un tipo numérico.

De MDN :

Desde las primeras versiones de la isNaN función isNaN , su comportamiento para argumentos no numéricos ha sido confuso. Cuando el argumento para la función isNaN no es de tipo Número, el valor se coacciona primero a un Número. El valor resultante se prueba para determinar si es NaN . Por lo tanto, para los no números que cuando se forza al tipo numérico dan como resultado un valor numérico no NaN válido (notablemente la cadena vacía y las primitivas booleanas, que al coaccionar dan valores numéricos a cero o uno), el valor devuelto "falso" puede ser inesperado; la cadena vacía, por ejemplo, seguramente no es "un número".

Tenga en cuenta también que con ECMAScript 6, ahora también está el método Number.isNaN , que de acuerdo con MDN:

En comparación con la función global isNaN() , Number.isNaN() no sufre el problema de convertir forzosamente el parámetro en un número. Esto significa que ahora es seguro pasar valores que normalmente se convertirían a NaN , pero en realidad no tienen el mismo valor que NaN . Esto también significa que solo los valores del número de tipo, que también son NaN , devuelven true .

Desafortunadamente

Incluso el método ECMAScript 6 Number.isNaN tiene sus propios problemas, como se detalla en la publicación del blog: Solucionando el feo problema de NaN de JavaScript y ES6 .

Answer 18

Si desea implementar una función isNumber precisa, aquí hay una forma de hacerlo desde Javascript: The Good Parts por Douglas Crockford [página 105]

var isNumber = function isNumber(value) {
   return typeof value === ''number'' && 
   isFinite(value);
}

Answer 19

isNaN siempre devolverá falso para una cadena de nada más que espacios. Sugeriría hacer recorte de cuerdas antes de la evaluación.

Answer 20

yo uso esto

    function isNotANumeric(val) {
     if(val.trim && val.trim() == "") {
         return true;
      } else {
        return isNaN(parseFloat(val * 1));
      }
    }
    
    alert(isNotANumeric("100"));  // false
    alert(isNotANumeric("1a"));   // true
    alert(isNotANumeric(""));     // true
    alert(isNotANumeric("   "));  // true

Answer 21

isNAN(<argument>) es una función que indica si el argumento dado es un número ilegal. isNaN typecasts los argumentos en tipo de número. Si desea verificar si el argumento es numérico o no? Utilice la función $.isNumeric() en jQuery.

Es decir, isNaN (foo) es equivalente a isNaN (Number (foo)) Acepta cualquier cadena que tenga todos los números como números por razones obvias. Por ej.

isNaN(123) //false
isNaN(-1.23) //false
isNaN(5-2) //false
isNaN(0) //false
isNaN(''123'') //false
isNaN(''Hello'') //true
isNaN(''2005/12/12'') //true
isNaN('''') //false
isNaN(true) //false
isNaN(undefined) //true
isNaN(''NaN'') //true
isNaN(NaN) //true
isNaN(0 / 0) //true