¿Cómo puedo determinar si una variable es una cadena o algo más en JavaScript?
Puede utilizar el operador typeof
:
var booleanValue = true;
var numericalValue = 354;
var stringValue = "This is a String";
var stringObject = new String( "This is a String Object" );
alert(typeof booleanValue) // displays "boolean"
alert(typeof numericalValue) // displays "number"
alert(typeof stringValue) // displays "string"
alert(typeof stringObject) // displays "object"
Ejemplo de esta página web. (Aunque el ejemplo fue ligeramente modificado).
Esto no funcionará como se espera en el caso de cadenas creadas con new String()
, pero esto se usa raramente y se recomienda contra|[1]|[2]. Vea las otras respuestas para saber cómo manejarlas, si así lo desea.
La mejor manera:
var s = 'String';
var a = [1,2,3];
var o = {key: 'val'};
(s.constructor === String) && console.log('its a string');
(a.constructor === Array) && console.log('its an array');
(o.constructor === Object) && console.log('its an object');
(o.constructor === Number || s.constructor === Boolean) && console.log('this won\'t run');
Cada uno de ellos ha sido construido por su función de clase apropiada, como "new Object()" etc.
También, Duck-Typing: "Si se ve como un pato, camina como un pato, y huele como un pato - debe ser un Array" Es decir, comprueba sus propiedades.
Espero que esto ayude.
Recuerda que siempre puedes usar combinaciones de enfoques también. Aquí's un ejemplo de uso de un mapa en línea de acciones con typeof:
var type = { 'number': Math.sqrt.bind(Math), ... }[ typeof datum ];
Aquí'hay un ejemplo más 'real' del uso de mapas inline:
function is(datum) {
var isnt = !{ null: true, undefined: true, '': true, false: false, 0: false }[ datum ];
return !isnt;
}
console.log( is(0), is(false), is(undefined), ... ); // >> true true false
Esta función utilizaría [ custom ] "type-casting" -- más bien, "type-/-value-mapping" -- para averiguar si una variable realmente "existe". ¡Ahora puedes dividir ese desagradable pelo entre null
& 0
!
Muchas veces ni siquiera te importa su tipo. Otra forma de eludir la tipificación es combinar conjuntos Duck-Type:
this.id = "998"; // use a number or a string-equivalent
function get(id) {
if (!id || !id.toString) return;
if (id.toString() === this.id.toString()) http( id || +this.id );
// if (+id === +this.id) ...;
}
Tanto Number.prototype
como String.prototype
tienen un método .toString()
. Sólo te has asegurado de que el equivalente en cadena del número era el mismo, y luego te has asegurado de pasarlo a la función http
como un Number
. En otras palabras, ni siquiera nos preocupamos de cuál era su tipo.
Espero que eso te dé más trabajo :)