javascript - array - typeof undefined

Compruebe si la variable es número o cadena en JavaScript

Question

¿Alguien sabe cómo puedo verificar si una variable es un número o una cadena en JavaScript?

Answer 1

¿Puedes simplemente dividirlo por 1?

Asumo que el problema sería una entrada de cadena como: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number /n")
}

else
{
alert("This is NOT a number /n")
}

Solo una forma en que lo hice recientemente.

Answer 2

Compruebe si el valor es un literal de cadena o un objeto de cadena:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Prueba de unidad:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

La comprobación de un número es similar:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

Answer 3

Creó un jsperf en la comprobación de si una variable es un número. ¡Bastante interesante! typeof en realidad tiene un uso de rendimiento. Usando typeof para cualquier otra cosa que no sean números, generalmente va a 1/3 de la velocidad como variable.constructor ya que la mayoría de los tipos de datos en javascript son objetos; los números no lo son!

http://jsperf.com/jemiloii-fastest-method-to-check-if-type-is-a-number

typeof variable === ''number'' | más rápido | Si desea un número, como 5, y no ''5''
typeof parseFloat(variable) === ''number'' | más rápido | si quieres un número, como 5 y ''5''

isNaN() es más lento, pero no mucho más lento. Tenía grandes esperanzas en parseInt y parseFloat , sin embargo, eran terriblemente más lentos.

Answer 4

Creo que convertir la var en una cadena disminuye el rendimiento, al menos esta test realizada en los últimos navegadores así lo demuestra.

Así que si te importa el rendimiento, usaría esto:

typeof str === "string" || str instanceof String

para verificar si la variable es una cadena (incluso si usa var str = new String("foo") , str instanceof String devolvería verdadero).

En cuanto a verificar si es un número, buscaría el nativo: isNaN ; función.

Answer 5

Desde ES2015, la forma correcta de verificar si una variable tiene un número válido es:

Number.isFinite(value)

Ejemplos:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite(''0'')        // false
Number.isFinite(null)       // false

Answer 6

Errr? Solo usa expresiones regulares! :)

function isInteger(val) {
  return val.match(/^[0-9]$/)
}

function isFloat(val) {
  return val.match(/^[0-9]*//.[0-9]+$/)
}

Answer 7

Este es un enfoque basado en la idea de forzar la entrada a un número o cadena agregando cero o la cadena nula, y luego hacer una comparación de igualdad escrita.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Por alguna razón incomprensible, x===x+0 parece funcionar mejor que x===+x .

¿Hay casos en los que esto falla?

En la misma vena:

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

Esto parece ser ligeramente más rápido que x===true || x===false x===true || x===false o tipo de typeof x==="boolean" (y mucho más rápido que x===Boolean(x) ).

Luego está también

function is_regexp(x)  { return x === RegExp(x); }

Todo esto depende de la existencia de una operación de "identidad" particular para cada tipo que puede aplicarse a cualquier valor y producir de manera confiable un valor del tipo en cuestión. No puedo pensar en tal operación para las fechas.

Para NaN, hay

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

Básicamente, esta es la versión del guión bajo, y tal como se presenta es cuatro veces más rápida que isNaN() , pero los comentarios en la fuente del guión bajo mencionan que "NaN es el único número que no se iguala a sí mismo" y agrega un cheque para _.isNumber. ¿Por qué? ¿Qué otros objetos no se igualarían? Además, el guión bajo usa x !== +x --pero ¿qué diferencia podría hacer el + aquí?

Entonces para el paranoico:

function is_undefined(x) { return x===[][0]; }

Answer 8

Jsut an FYI, si estás usando jQuery tienes

$.isNumeric() 

para manejar esto Más detalles en http://api.jquery.com/jQuery.isNumeric/

Answer 9

La mejor manera de hacer esto:

function isNumber(num) {
  return (typeof num == ''string'' || typeof num == ''number'') && !isNaN(num - 0) && num !== '''';
};

Esto satisface los siguientes casos de prueba:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber(''2.534e25''));
assertEquals("ISNUMBER-True: 8", true, isNumber(''52334''));
assertEquals("ISNUMBER-True: 9", true, isNumber(''-234''));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''''));
assertEquals("ISNUMBER-False: 4", false, isNumber(''one''));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

Answer 10

La mejor manera de hacerlo es utilizando el casting de tipo isNaN +:

Método todo incluido actualizado:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

Lo mismo usando regex:

function isNumber(n) { return /^-?[/d.]+(?:e-?/d+)?$/.test(n); } 

------------------------

isNumber (''123''); // true  
isNumber (''123abc''); // true  
isNumber (5); // true  
isNumber (''q345''); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber(''   ''); // false

Answer 11

La mejor manera que encontré que también piensa en números positivos y negativos es de: O''Reilly Javascript y DHTML Cookbook :

function isNumber(elem) {
var str = elem.value;
var oneDecimal = false;
var oneChar = 0;
// make sure value hasn''t cast to a number data type
str = str.toString( );
for (var i = 0; i < str.length; i++) {
    oneChar = str.charAt(i).charCodeAt(0);
    // OK for minus sign as first character
    if (oneChar =  = 45) {
        if (i =  = 0) {
            continue;
        } else {
            alert("Only the first character may be a minus sign.");
            return false;
        }
    }
    // OK for one decimal point
    if (oneChar =  = 46) {
        if (!oneDecimal) {
            oneDecimal = true;
            continue;
        } else {
            alert("Only one decimal is allowed in a number.");
            return false;
        }
    }
    // characters outside of 0 through 9 not OK
    if (oneChar < 48 || oneChar > 57) {
        alert("Enter only numbers into the field.");
        return false;
    }
}
return true;

}

Answer 12

La mejor manera que he encontrado es verificar un método en la cadena, es decir:

if (x.substring) {
// do string thing
} else{
// do other thing
}

o si desea hacer algo con la verificación de número para una propiedad de número,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

Esto es algo así como "escribir pato", depende de usted cuál es el sentido que tiene más sentido. No tengo suficiente karma para comentar, pero typeof falla para cadenas y números en caja, es decir:

alert(typeof new String(''Hello World''));
alert(typeof new Number(5));

alertará "objeto".

Answer 13

La respuesta de @BitOfUniverse es buena, y se me ocurre una nueva forma:

function isNum(n) {
    return !isNaN(n/0);
}

isNum('''')  // false
isNum(2)   // true
isNum(''2k'') // false
isNum(''2'')  //true

Sé que 0 no puede ser dividendo, pero aquí la función funciona perfectamente.

Answer 14

Muy tarde a la fiesta; sin embargo, lo siguiente siempre me ha funcionado bien cuando quiero comprobar si alguna entrada es una cadena o un número en un disparo.

return !!Object.prototype.toString.call(input).match(//[object (String|Number)/]/);

Answer 15

Para detectar números, el siguiente pasaje de JavaScript: The Good Parts de Douglas Crockford es relevante:

La función isFinite es la mejor manera de determinar si un valor puede usarse como un número porque rechaza NaN e Infinity. Desafortunadamente, isFinite intentará convertir su operando en un número, así que no es una buena prueba si un valor no es realmente un número. Es posible que desee definir su propia función isNumber:

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

Answer 16

Prueba esto,

<script>
var regInteger = /^/d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( ''Integer'' );
} else {
   console.log( ''Non Integer'' );
}
</script>

Answer 17

Si estás tratando con notación literal y no con constructores, puedes usar typeof :.

typeof "Hello World"; // string
typeof 123;           // number

Si está creando números y cadenas a través de un constructor, como var foo = new String("foo") , debe tener en cuenta que typeof puede devolver el object para foo .

Quizás un método más infalible para verificar el tipo sería utilizar el método que se encuentra en underscore.js (la fuente anotada se puede encontrar here ),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == ''[object String]'';
}

Esto devuelve un true booleano para lo siguiente:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

Answer 18

Simplemente usar

myVar.constructor == String

o

myVar.constructor == Number

Si desea manejar cadenas definidas como objetos o literales y guardar, no quiere usar una función auxiliar.

Answer 19

Usted está buscando isNaN ():

<script type="text/javascript">
  alert(isNaN(123));
  alert(isNaN(-1.23));
  alert(isNaN(5-2));
  alert(isNaN(0));
  alert(isNaN("Hello"));
  alert(isNaN("2005/12/12"));
</script>

Ver la función JavaScript isNaN () en MDN.

Answer 20

jQuery usa esto:

function isNumber(obj) {
  return !isNaN( parseFloat( obj ) ) && isFinite( obj );
}

Answer 21

o simplemente usa el invertido de isNaN

si (! isNaN (datos)) hace algo con el número, de lo contrario es una cadena

y sí, usar jQuery - $ .isNumeric () es más divertido por lo que cuesta.

Answer 22

typeof funciona muy bien para mí en la mayoría de los casos. Puedes intentar usar una sentencia if

if(typeof x === ''string'' || typeof x === ''number'') {
    console.log("Your statement");
}

donde x es cualquier nombre de variable de su elección

Answer 23

uh, ¿qué tal sólo:

function IsString(obj) {
    return obj !== undefined && obj != null && obj.toLowerCase !== undefined;
}

Después de una revisión adicional muchos meses después, esto solo garantiza que obj es un objeto que tiene definido el método o el nombre de la propiedad toLowerCase . Me avergüenzo de mi respuesta. Por favor, vea el tipo de uno más votado.

Answer 24

ya que una cadena como ''1234'' con typeof mostrará ''string'', y lo inverso no puede suceder nunca (typeof 123 siempre será un número), lo mejor es usar un regex simple /^/-?/d+$/.test(var) . O un más avanzado para hacer coincidir los flotantes, enteros y números negativos, / /^[/-/+]?[/d]+/.?(/d+)?$/ -/ /^[/-/+]?[/d]+/.?(/d+)?$/ .test lo anterior. una excepción si la var no es una cadena, el valor puede ser cualquier cosa.

var val, regex = /^[/-/+]?[/d]+/.?(/d+)?$/;

regex.test(val)       // false 
val = ''1234'';
regex.test(val)       // true
val = ''-213'';
regex.test(val)       // true
val = ''-213.2312'';
regex.test(val)       // true
val = ''+213.2312'';
regex.test(val)       // true
val = 123;
regex.test(val)       // true
val = new Number(123);
regex.test(val)       // true
val = new String(''123'');
regex.test(val)       // true
val = ''1234e'';
regex.test(val)       // false 
val = {};
regex.test(val)       // false 
val = false;
regex.test(val)       // false 
regex.test(undefined) // false 
regex.test(null)      // false 
regex.test(window)    // false 
regex.test(document)  // false 

Si está buscando el tipo real, entonces typeof solo lo hará.

Answer 25

¡Esta solución resuelve muchos de los problemas planteados aquí!

Este es, con mucho, el método más confiable que he usado con diferencia. No inventé esto, y no puedo recordar dónde lo encontré originalmente. Pero funciona donde fallan otras técnicas:

// Begin public utility /getVarType/
// Returns ''Function'', ''Object'', ''Array'',
// ''String'', ''Number'', ''Boolean'', or ''Undefined''
getVarType = function ( data ){
  if (undefined === data ){ return ''Undefined''; }
  if (data === null ){ return ''Null''; }
  return {}.toString.call(data).slice(8, -1);
};  
// End public utility /getVarType/

Ejemplo de corrección

var str = new String();
console.warn( getVarType(str) ); // Reports "String"    
console.warn( typeof str );      // Reports "object"

var num = new Number();
console.warn( getVarType(num) ); // Reports "Number"
console.warn( typeof num );      // Reports "object"

var list = [];
console.warn( getVarType( list ) ); // Reports "Array"
console.warn( typeof list );        // Reports "object"

Answer 26

//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is(''String'', ''test''); // true
is(''Array'', true); // false

O adaptarlo para devolver un tipo desconocido:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // ''Number''

12 de mayo de 2012 Actualización: Ejemplo completo en Javascript: A Better typeof .

Answer 27

function IsNumeric(num) {
    return ((num >=0 || num < 0)&& (parseInt(num)==num) );
}