array - Compruebe si una variable es una cadena en JavaScript

typeof jquery

Question

¿Cómo puedo determinar si una variable es una cadena o algo más en JavaScript?

Answer 1

Dado que más de 580 personas han votado por una respuesta incorrecta, y más de 800 han votado por una respuesta que funciona como la de una escopeta, pensé que valdría la pena rehacer mi respuesta de una forma más sencilla que todos puedan entender.

function isString(x) {
  return Object.prototype.toString.call(x) === "[object String]"
}

O, en línea (tengo una configuración de UltiSnip para esto):

Object.prototype.toString.call(myVar) === "[object String]"

Para su información, la respuesta de Pablo Santa Cruz es incorrecta, porque typeof new String("string") es un object

La respuesta de DRAX es precisa y funcional, y debería ser la correcta (ya que Pablo Santa Cruz es definitivamente incorrecto, y no discutiré contra el voto popular).

Sin embargo, esta respuesta también es definitivamente correcta, y en realidad es la mejor respuesta (excepto, quizás, por la sugerencia de usar lodash / underscore ). descargo de responsabilidad: contribuí al código base de lodash 4.

Mi respuesta original (que obviamente voló sobre muchas cabezas) sigue:

Yo transcodifiqué esto desde underscore.js:

[''Arguments'', ''Function'', ''String'', ''Number'', ''Date'', ''RegExp''].forEach( 
    function(name) { 
        window[''is'' + name] = function(obj) {
              return toString.call(obj) == ''[object '' + name + '']'';
    }; 
});

Eso definirá isString, isNumber, etc.

En Node.js, esto se puede implementar como un módulo:

module.exports = [
  ''Arguments'', 
  ''Function'', 
  ''String'', 
  ''Number'', 
  ''Date'', 
  ''RegExp''
].reduce( (obj, name) => {
  obj[ ''is'' + name ] = x => toString.call(x) == ''[object '' + name + '']'';
  return obj;
}, {});

Answer 2

El siguiente método comprobará si alguna variable es una cadena ( incluidas las variables que no existen ).

const is_string = value => {
    try {
        return typeof value() === ''string'';
    } catch ( error ) {
        return false;
    }
};

let example = ''Hello, world!'';

console.log( is_string( () => example ) );                 // true
console.log( is_string( () => variable_doesnt_exist ) );   // false

Answer 3

Este es un gran ejemplo de por qué el rendimiento importa:

Hacer algo tan simple como una prueba para una cuerda puede ser costoso si no se hace correctamente.

Por ejemplo, si quisiera escribir una función para probar si algo es una cadena, podría hacerlo de una de estas dos maneras:

1) const isString = str => (Object.prototype.toString.call(str) === ''[object String]'');

2) const isString = str => ((typeof str === ''string'') || (str instanceof String));

Ambos son bastante sencillos, entonces, ¿qué podría afectar el rendimiento? En general, las llamadas a funciones pueden ser costosas, especialmente si no sabes lo que sucede dentro. En el primer ejemplo, hay una llamada de función al método toString de Object. En el segundo ejemplo, no hay llamadas a funciones, ya que typeof y instanceof son operadores. Los operadores son significativamente más rápidos que las llamadas de función.

Cuando se prueba el rendimiento, el ejemplo 1 es un 79% más lento que el ejemplo 2.

Vea las pruebas: https://jsperf.com/isstringtype

Answer 4

Esto es lo que funciona para mí:

if (typeof myVar === ''string'' || myVar instanceof String)
// it''s a string
else
// it''s something else

Answer 5

Esto es lo suficientemente bueno para mí.

ADVERTENCIA: Esta no es una solución perfecta. Ver la parte inferior de mi post.

Object.prototype.isString = function() { return false; };
String.prototype.isString = function() { return true; };

var isString = function(a) {
  return (a !== null) && (a !== undefined) && a.isString();
};

Y puedes usar esto como abajo.

//return false
isString(null);
isString(void 0);
isString(-123);
isString(0);
isString(true);
isString(false);
isString([]);
isString({});
isString(function() {});
isString(0/0);

//return true
isString("");
isString(new String("ABC"));

ADVERTENCIA: Esto funciona incorrectamente en el caso:

//this is not a string
var obj = {
    //but returns true lol
    isString: function(){ return true; }
}

isString(obj) //should be false, but true

Answer 6

Me gusta usar esta solución simple:

var myString = "test";
if(myString.constructor === String)
{
     //It''s a string
}

Answer 7

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 estos ha sido construido por su función de clase apropiada, como "nuevo objeto ()", etc.

Además, Duck-Typing: "Si parece un pato, camina como un pato y huele como un pato, debe ser un Array" Significado, verifique sus propiedades.

Espero que esto ayude.

Editar; 12/05/2016

Recuerde, siempre puede usar combinaciones de enfoques también. Aquí hay un ejemplo del 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'' de usar mapas en línea:

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 usaría la "conversión de tipos" [personalizada] - más bien, "mapeo de valores - / - de tipo" - para averiguar si una variable realmente "existe". ¡Ahora puedes dividir ese desagradable cabello entre null y 0 !

Muchas veces ni siquiera te importa su tipo . Otra forma de evitar la escritura es combinando conjuntos de tipo pato:

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 .toString() method . Simplemente se aseguró de que la cadena equivalente del número fuera la misma, y ​​luego se aseguró de pasarla a la función http como un Number . En otras palabras, ni siquiera nos importaba su tipo.

Espero que te dé más para trabajar :)

Answer 8

No estoy seguro de si te refieres a saber si es una string tipo independientemente de su contenido, o si su contenido es un número o cadena, independientemente de su tipo.

Entonces para saber si su tipo es una cadena, eso ya ha sido respondido.
Pero para saber en base a su contenido si es una cadena o un número, usaría esto:

function isNumber(item) {
    return (parseInt(item) + '''') === item;
}

Y para algunos ejemplos:

isNumber(123);   //true
isNumber(''123''); //true
isNumber(''123a'');//false
isNumber('''');    //false

Answer 9

Recomiendo usar las funciones integradas de jQuery o lodash / Underscore . Son más fáciles de usar y más fáciles de leer.

Cualquiera de las funciones manejará el caso mencionado por DRAX ... es decir, ambos verifican si (A) la variable es una cadena literal o (B) es una instancia del objeto String. En cualquier caso, estas funciones identifican correctamente el valor como una cadena.

lodash / Underscore.js

if(_.isString(myVar))
   //it''s a string
else
   //it''s something else

jQuery

if($.type(myVar) === "string")
   //it''s a string
else
   //it''s something else

Consulte la documentación de lodash para _.isString () para obtener más detalles.

Consulte la documentación de jQuery para $ .type () para obtener más detalles.

Answer 10

Si trabaja en el entorno node.js, simplemente puede usar la función incorporada isString en utils.

const util = require(''util'');
if (util.isString(myVar)) {}

Edición: como se mencionó @Jehy, esto está en desuso desde v4.

Answer 11

Solo para ampliar la answer de @DRAX, haría esto:

function isWhitespaceEmptyString(str)
{
    //RETURN:
    //      = ''true'' if ''str'' is empty string, null, undefined, or consists of white-spaces only
    return str ? !(//S/.test(str)) : (str === "" || str === null || str === undefined);
}

También tendrá en cuenta los tipos null y undefined , y se encargará de los tipos que no sean de cadena, como 0 .

Answer 12

También encontré que esto funciona bien también, y es mucho más corto que los otros ejemplos.

if (myVar === myVar + '''') {
   //its string
} else {
   //its something else
}

Al concatenar en comillas vacías, convierte el valor en una cadena. Si myVar ya es una cadena, entonces la sentencia if es exitosa.

Answer 13

Tomado de lodash:

function isString(val) {
   return typeof val === ''string'' || ((!!val && typeof val === ''object'') && Object.prototype.toString.call(val) === ''[object String]'');
}

console.log(isString(''hello world!'')); // true
console.log(isString(new String(''hello world''))); // true

Answer 14

Una solución simple sería:

var x = "hello"

if(x === x.toString(){
// it''s a string 
}else{
// it isn''t
}

Answer 15

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 . (El ejemplo fue ligeramente modificado).

Esto no funcionará como se esperaba en el caso de cadenas creadas con la new String() , pero rara vez se usa y se recomienda contra ^{[1] [2]} . Vea las otras respuestas para saber cómo manejarlas, si así lo desea.

1. La Guía de estilo de Google JavaScript dice que nunca se deben usar envoltorios de objetos primitivos .
2. Douglas Crockford recomendó que los envoltorios de objetos primitivos estén en desuso .

Answer 16

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

Lo vi aquí:

http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/

Answer 17

var a = new String('''')
var b = ''''
var c = []

function isString(x) {
  return x !== null && x !== undefined && x.constructor === String
}

console.log(isString(a))
console.log(isString(b))
console.log(isString(c))