validacion - (Integrado) en JavaScript para verificar si una cadena es un número válido
validar numero de telefono javascript (24)
¿Espero que haya algo en el mismo espacio conceptual que la antigua función VN6 IsNumeric() ?
Para verificar si una variable (incluyendo una cadena) es un número, verifique si no es un número:
Esto funciona independientemente de si la variable contiene es una cadena o un número.
isNaN(num) // returns true if the variable does NOT contain a valid number
Ejemplos
isNaN(123) // false
isNaN(''123'') // false
isNaN(''1e10000'') // false (This translates to Infinity, which is a number)
isNaN(''foo'') // true
isNaN(''10px'') // true
Por supuesto, puede negar esto si lo necesita. Por ejemplo, para implementar el ejemplo IsNumeric que dio:
function isNumeric(num){
return !isNaN(num)
}
Para convertir una cadena que contiene un número en un número:
solo funciona si la cadena solo contiene caracteres numéricos, de lo contrario devuelve NaN .
+num // returns the numeric value of the string, or NaN
// if the string isn''t purely numeric characters
Ejemplos
+''12'' // 12
+''12.'' // 12
+''12..'' // Nan
+''.12'' // 0.12
+''..12'' // Nan
+''foo'' // NaN
+''12px'' // NaN
Para convertir una cadena libremente a un número
útil para convertir ''12px'' a 12, por ejemplo:
parseInt(num) // extracts a numeric value from the
// start of the string, or NaN.
Ejemplos
parseInt(''12'') // 12
parseInt(''aaa'') // NaN
parseInt(''12px'') // 12
parseInt(''foo2'') // NaN These last two may be different
parseInt(''12a5'') // 12 from what you expected to see.
Flotadores
Tenga en cuenta que, a diferencia de +num , parseInt (como su nombre lo indica) convertirá un flotador en un entero al cortar todo después del punto decimal (si desea usar parseInt() debido a este comportamiento, probablemente sea mejor off utilizando otro método en su lugar ):
+''12.345'' // 12.345
parseInt(12.345) // 12
parseInt(''12.345'') // 12
Cuerdas vacias
Las cuerdas vacías pueden ser un poco contraintuitivas. +num convierte las cadenas vacías a cero, y isNaN() asume lo mismo:
+'''' // 0
isNaN('''') // false
Pero parseInt() no está de acuerdo:
parseInt('''') // NaN
¿Por qué la implementación de jQuery no es lo suficientemente buena?
function isNumeric(a) {
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0;
};
Michael sugirió algo como esto (aunque he robado la versión modificada de "user1691651 - John" aquí):
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
La siguiente es una solución con el más probable mal desempeño, pero resultados sólidos. Es un artilugio hecho a partir de la implementación de jQuery 1.12.4 y la respuesta de Michael, con una verificación adicional de los espacios iniciales / finales (porque la versión de Michael devuelve verdadero para los números con espacios iniciales / finales):
function isNumeric(a) {
var str = a + "";
var b = a && a.toString();
return !$.isArray(a) && b - parseFloat(b) + 1 >= 0 &&
!/^/s+|/s+$/g.test(str) &&
!isNaN(str) && !isNaN(parseFloat(str));
};
Sin embargo, la última versión tiene dos nuevas variables. Uno podría sortear uno de esos, haciendo:
function isNumeric(a) {
if ($.isArray(a)) return false;
var b = a && a.toString();
a = a + "";
return b - parseFloat(b) + 1 >= 0 &&
!/^/s+|/s+$/g.test(a) &&
!isNaN(a) && !isNaN(parseFloat(a));
};
No he probado ninguno de estos mucho, por otro medio que no sea probar manualmente los pocos casos de uso que tendré en mi situación actual, que es todo muy estándar. Esta es una situación "de pie sobre los hombros de los gigantes".
Aquí hay una sola línea para verificar si sNum es un valor numérico válido; ha sido probado para una amplia variedad de entradas:
!isNaN(+s.replace(//s|/$/g, '''')); // returns True if numeric value
Bueno, estoy usando este que hice ...
Ha estado trabajando hasta ahora:
function checkNumber(value) {
if ( value % 1 == 0 )
return true;
else
return false;
}
Si encuentra algún problema con él, dígame, por favor.
Citar:
isNaN (num) // devuelve true si la variable NO contiene un número válido
no es del todo cierto si necesita verificar los espacios iniciales / finales, por ejemplo, cuando se requiere una cierta cantidad de dígitos, y necesita obtener, digamos, ''1111'' y no ''111'' o ''111'' para tal vez un PIN entrada.
Mejor usar:
var num = /^/d+$/.test(num)
En mi aplicación solo permitimos az AZ y 0-9 caracteres. Encontré que la respuesta anterior utilizando " string % 1 === 0" funcionó a menos que la cadena comenzara con 0xnn (como 0x10) y luego la devolvería como numérica cuando no quisiéramos. La siguiente trampa simple en mi comprobación numérica parece hacer el truco en nuestros casos específicos.
function isStringNumeric(str_input){
//concat a temporary 1 during the modulus to keep a beginning hex switch combination from messing us up
//very simple and as long as special characters (non a-z A-Z 0-9) are trapped it is fine
return ''1''.concat(str_input) % 1 === 0;}
Advertencia : Esto podría estar explotando un error de larga data en Javascript y Actionscript [Number ("1" + the_string)% 1 === 0)], no puedo hablar de eso, pero es exactamente lo que necesitábamos.
Hace poco escribí un artículo sobre formas de asegurar que una variable sea un número válido: https://github.com/jehugaleahsa/artifacts/blob/master/2018/typescript_num_hack.md El artículo explica cómo asegurar un punto flotante o un entero, si ese es importante ( +x vs ~~x ).
El artículo asume que la variable es una string o un number para comenzar y que el trim está disponible / polyfilled. No sería difícil extenderlo para manejar otros tipos, también. Aquí está la carne de ella:
// Check for a valid float
if (x == null
|| ("" + x).trim() === ""
|| isNaN(+x)) {
return false; // not a float
}
// Check for a valid integer
if (x == null
|| ("" + x).trim() === ""
|| ~~x !== +x) {
return false; // not an integer
}
He probado y la solución de Michael es la mejor. Vota por su respuesta anterior (busca en esta página "Si realmente quieres asegurarte de una cadena" para encontrarla). En esencia, su respuesta es esta:
function isNumeric(num){
num = "" + num; //coerce num to be a string
return !isNaN(num) && !isNaN(parseFloat(num));
}
Funciona para cada caso de prueba, que documenté aquí: https://jsfiddle.net/wggehvp9/5/
Muchas de las otras soluciones fallan en estos casos de borde: '''', nulo, "", verdadero y []. En teoría, podría usarlos, con el manejo adecuado de errores, por ejemplo:
return !isNaN(num);
o
return (+num === +num);
con manejo especial para / / s /, nulo, "", verdadero, falso, [] (y otros?)
La respuesta aceptada para esta pregunta tiene algunas fallas (como lo resaltaron algunos otros usuarios). Esta es una de las maneras más fáciles y comprobadas de enfocarla en javascript:
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
A continuación se presentan algunos buenos casos de prueba:
console.log(isNumeric(12345678912345678912)); // true
console.log(isNumeric(''2 '')); // true
console.log(isNumeric(''-32.2 '')); // true
console.log(isNumeric(-32.2)); // true
console.log(isNumeric(undefined)); // false
// the accepted answer fails at these tests:
console.log(isNumeric('''')); // false
console.log(isNumeric(null)); // false
console.log(isNumeric([])); // false
Lo hago así:
function isString(value)
{
return value.length !== undefined;
}
function isNumber(value)
{
return value.NaN !== undefined;
}
Por supuesto, isString () se disparará aquí si pasas algún otro objeto que tiene "longitud" definida.
Me gusta la simplicidad de esto.
Number.isNaN(Number(value))
Lo anterior es un Javascript normal, pero lo estoy usando junto con una typeguard de typeguard de tipos para la comprobación inteligente de tipos. Esto es muy útil para que el compilador mecanografiado le dé una inteligencia correcta, y no errores de tipo.
Typeguards mecanografiado
isNotNumber(value: string | number): value is string {
return Number.isNaN(Number(this.smartImageWidth));
}
isNumber(value: string | number): value is number {
return Number.isNaN(Number(this.smartImageWidth)) === false;
}
Digamos que tienes un width propiedad que es number | string number | string Es posible que desee hacer lógica en función de si es o no una cadena.
var width: number|string;
width = "100vw";
if (isNotNumber(width))
{
// the compiler knows that width here must be a string
if (width.endsWith(''vw''))
{
// we have a ''width'' such as 100vw
}
}
else
{
// the compiler is smart and knows width here must be number
var doubleWidth = width * 2;
}
El typeguard es lo suficientemente inteligente como para restringir el tipo de width dentro de la sentencia if para que sea SOLAMENTE una string . Esto permite que el compilador permita width.endsWith(...) que no permitiría si el tipo fuera string | number string | number
Puedes llamar al typeguard como quieras. No es isNotNumber , es isNotNumber , es isNumber , no es una isString , pero creo que es isString es algo ambiguo y más difícil de leer.
Mi intento de ser un poco confuso, quizás la mejor solución.
function isInt(a){
return a === ""+~~a
}
console.log(isInt(''abcd'')); // false
console.log(isInt(''123a'')); // false
console.log(isInt(''1'')); // true
console.log(isInt(''0'')); // true
console.log(isInt(''-0'')); // false
console.log(isInt(''01'')); // false
console.log(isInt(''10'')); // true
console.log(isInt(''-1234567890'')); // true
console.log(isInt(1234)); // true
console.log(isInt(''123.4'')); // false
console.log(isInt('''')); // false
// other types then string returns false
console.log(isInt(5)); // false
console.log(isInt(undefined)); // false
console.log(isInt(null)); // false
console.log(isInt(''0x1'')); // false
console.log(isInt(Infinity)); // false
Mi solución:
// returns true for positive ints;
// no scientific notation, hexadecimals or floating point dots
var isPositiveInt = function(str) {
var result = true, chr;
for (var i = 0, n = str.length; i < n; i++) {
chr = str.charAt(i);
if ((chr < "0" || chr > "9") && chr != ",") { //not digit or thousands separator
result = false;
break;
};
if (i == 0 && (chr == "0" || chr == ",")) { //should not start with 0 or ,
result = false;
break;
};
};
return result;
};
Puede agregar condiciones adicionales dentro del bucle, para adaptarse a sus necesidades particulares.
PFB la solución de trabajo:
function(check){
check = check + "";
var isNumber = check.trim().length>0? !isNaN(check):false;
return isNumber;
}
Pregunta antigua, pero faltan varios puntos en las respuestas dadas.
Notación cientifica.
!isNaN(''1e+30'') es true , sin embargo, en la mayoría de los casos, cuando las personas piden números, no quieren hacer coincidir cosas como 1e+30 .
Los grandes números flotantes pueden comportarse raro
Observar (usando Node.js):
> var s = Array(16 + 1).join(''9'')
undefined
> s.length
16
> s
''9999999999999999''
> !isNaN(s)
true
> Number(s)
10000000000000000
> String(Number(s)) === s
false
>
Por otra parte:
> var s = Array(16 + 1).join(''1'')
undefined
> String(Number(s)) === s
true
> var s = Array(15 + 1).join(''9'')
undefined
> String(Number(s)) === s
true
>
Entonces, si uno espera String(Number(s)) === s , entonces limite sus cadenas a un máximo de 15 dígitos (después de omitir los ceros a la izquierda).
infinito
> typeof Infinity
''number''
> !isNaN(''Infinity'')
true
> isFinite(''Infinity'')
false
>
Dado todo eso, verificando que la cadena dada sea un número que satisfaga todo lo siguiente:
- notación no científica
- Conversión predecible a
Numbery vuelta aString - finito
no es una tarea tan fácil Aquí hay una versión simple:
function isNonScientificNumberString(o) {
if (!o || typeof o !== ''string'') {
// Should not be given anything but strings.
return false;
}
return o.length <= 15 && o.indexOf(''e+'') < 0 && o.indexOf(''E+'') < 0 && !isNaN(o) && isFinite(o);
}
Sin embargo, incluso este está lejos de ser completo. Los ceros iniciales no se manejan aquí, pero sí atornillan la prueba de longitud.
Prueba la función isNan :
La función isNaN () determina si un valor es un número no válido (Not-a-Number).
Esta función devuelve verdadero si el valor equivale a NaN. De lo contrario, devuelve falso.
Esta función es diferente del método Number.isNaN() específico del Número.
La función global isNaN (), convierte el valor probado en un Número, luego lo prueba.
Number.isNan () no convierte los valores a un número, y no devolverá verdadero para ningún valor que no sea del tipo Number ...
Puede usar el resultado de Number al pasar un argumento a su constructor.
Si el argumento (una cadena) no se puede convertir en un número, devuelve NaN, por lo que puede determinar si la cadena proporcionada fue un número válido o no.
Notas: Tenga en cuenta que al pasar una cadena vacía o ''/t/t'' y ''/n/t'' , el Número devolverá 0; Pasar true devolverá 1 y false devuelve 0.
Number(''34.00'') // 34
Number(''-34'') // -34
Number(''123e5'') // 12300000
Number(''123e-5'') // 0.00123
Number(''999999999999'') // 999999999999
Number(''9999999999999999'') // 10000000000000000 (integer accuracy up to 15 digit)
Number(''0xFF'') // 255
Number(''Infinity'') // Infinity
Number(''34px'') // NaN
Number(''xyz'') // NaN
Number(''true'') // NaN
Number(''false'') // NaN
// cavets
Number('' '') // 0
Number(''/t/t'') // 0
Number(''/n/t'') // 0
Puede usar tipos, como con la biblioteca de flujos , para obtener una verificación de tiempo de compilación estática. Por supuesto, no es terriblemente útil para la entrada del usuario.
// @flow
function acceptsNumber(value: number) {
// ...
}
acceptsNumber(42); // Works!
acceptsNumber(3.14); // Works!
acceptsNumber(NaN); // Works!
acceptsNumber(Infinity); // Works!
acceptsNumber("foo"); // Error!
Si alguien alguna vez llega tan lejos, dediqué un tiempo a piratear esto intentando parchear moment.js ( https://github.com/moment/moment ). Aquí hay algo que le quité:
function isNumeric(val) {
var _val = +val;
return (val !== val + 1) //infinity check
&& (_val === +val) //Cute coercion check
&& (typeof val !== ''object'') //Array/object check
}
Maneja los siguientes casos:
¡Cierto! :
isNumeric("1"))
isNumeric(1e10))
isNumeric(1E10))
isNumeric(+"6e4"))
isNumeric("1.2222"))
isNumeric("-1.2222"))
isNumeric("-1.222200000000000000"))
isNumeric("1.222200000000000000"))
isNumeric(1))
isNumeric(0))
isNumeric(-0))
isNumeric(1010010293029))
isNumeric(1.100393830000))
isNumeric(Math.LN2))
isNumeric(Math.PI))
isNumeric(5e10))
¡Falso! :
isNumeric(NaN))
isNumeric(Infinity))
isNumeric(-Infinity))
isNumeric())
isNumeric(undefined))
isNumeric(''[1,2,3]''))
isNumeric({a:1,b:2}))
isNumeric(null))
isNumeric([1]))
isNumeric(new Date()))
Irónicamente, con el que más estoy luchando:
isNumeric(new Number(1)) => false
Cualquier sugerencia de bienvenida. :]
Si realmente quiere asegurarse de que una cadena contenga solo un número, cualquier número (entero o punto flotante) y exactamente un número, no puede usar parseInt() / parseFloat() , Number() o !isNaN() con sí mismos. Tenga en cuenta que !isNaN() realidad devuelve true cuando Number() devolvería un número, y false cuando devolvería NaN , así que lo excluiré del resto de la discusión.
El problema con parseFloat() es que devolverá un número si la cadena contiene algún número, incluso si la cadena no contiene solo y exactamente un número:
parseFloat("2016-12-31") // returns 2016
parseFloat("1-1") // return 1
parseFloat("1.2.3") // returns 1.2
El problema con Number() es que devolverá un número en los casos en que el valor pasado no sea un número.
Number("") // returns 0
Number(" ") // returns 0
Number(" /u00A0 /t/n/r") // returns 0
El problema con la rotación de su propia expresión regular es que, a menos que cree la expresión regular exacta para hacer coincidir un número de punto flotante a medida que Javascript lo reconoce, perderá los casos o reconocerá los casos en los que no debería hacerlo. E incluso si puedes rodar tu propio regex, ¿por qué? Hay formas más simples de hacerlo.
Sin embargo, resulta que Number() (y isNaN() ) hace lo correcto para cada caso en que parseFloat() devuelve un número cuando no debería, y viceversa. Entonces, para averiguar si una cadena es realmente exacta y solo un número, llame a ambas funciones y vea si ambas devuelven verdadero:
function isNumber(str) {
if (typeof str != "string") return false // we only process strings!
// could also coerce to string: str = ""+str
return !isNaN(str) && !isNaN(parseFloat(str))
}
Si solo está tratando de verificar si una cadena es un número entero (sin posiciones decimales), regex es una buena manera de hacerlo. Otros métodos como isNaN son demasiado complicados para algo tan simple.
function isNumeric(value) {
return /^-{0,1}/d+$/.test(value);
}
console.log(isNumeric(''abcd'')); // false
console.log(isNumeric(''123a'')); // false
console.log(isNumeric(''1'')); // true
console.log(isNumeric(''1234567890'')); // true
console.log(isNumeric(''-23'')); // true
console.log(isNumeric(1234)); // true
console.log(isNumeric(''123.4'')); // false
console.log(isNumeric('''')); // false
console.log(isNumeric(undefined)); // false
console.log(isNumeric(null)); // false
Para solo permitir números enteros positivos usa esto:
function isNumeric(value) {
return /^/d+$/.test(value);
}
console.log(isNumeric(''123'')); // true
console.log(isNumeric(''-23'')); // false
Tal vez hay una o dos personas que se encuentran con esta pregunta que necesitan un control mucho más estricto de lo normal (como lo hice yo). En ese caso, esto podría ser útil:
if(str === String(Number(str))) {
// it''s a "perfectly formatted" number
}
¡Tener cuidado! Esto rechazará cadenas como .1 , 40.000 , 080 , 00.1 . Es muy delicado: la cadena debe coincidir con la " forma perfecta más mínima " del número para que pase esta prueba.
Utiliza el constructor de String y Number para convertir la cadena en un número y viceversa y, por lo tanto, comprueba si la "forma mínima perfecta" del motor de JavaScript (la que se convirtió con el constructor de Number inicial) coincide con la cadena original.
Y usted podría ir por el camino del regexp:
var num = "987238";
if(num.match(/^-{0,1}/d+$/)){
//valid integer (positive or negative)
}else if(num.match(/^/d+/./d+$/)){
//valid float
}else{
//not valid number
}
parseInt (), pero tenga en cuenta que esta función es un poco diferente en el sentido de que, por ejemplo, devuelve 100 para parseInt ("100px").