Verificar se uma variável é um texto em JavaScript

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

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

Ou, em linha (tenho uma configuração UltiSnip para isto):

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

No Entanto, esta resposta é definitivamente correta, e, na verdade, a melhor resposta (exceto, talvez, para a sugestão de utilizar lodash/sublinhado). aviso: eu contribuí para a base de dados do lodash 4.

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

Que irá definir isString, isNumber, etc.

No Nó.js, isto pode ser implementado como um módulo:

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

Recomendo a utilização das funções incorporadas de jQuery ou lodash / Underscore . São mais simples de usar e mais fáceis de ler.

Qualquer das funções tratará do caso DRAX mencionado... isto é, eles ambos verificam se (a) a variável é uma cadeia de caracteres literal ou (B) é uma instância do objecto de cadeia de caracteres. Em ambos os casos, estas funções identificam corretamente o valor como sendo uma string.

Lodash / Sublinhar.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

Ver documentação de lodash para _.isString () para mais detalhes.

Ver documentação do jQuery por$.tipo () para mais detalhes.

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

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

A melhor maneira:

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 um destes foi construído pela sua função de classe apropriada, como "novo objecto()" etc.

Também, Dactilografia De Patos: "Se se parece com um pato, anda como um pato, e cheira como um pato - deve ser uma matriz" Ou seja, verifica as suas propriedades.

Editar; 12/05/2016

Lembre-se, você pode sempre usar combinações de abordagens também. Aqui está um exemplo de usar um inline map de acções com tipo de:

var type = { 'number': Math.sqrt.bind(Math), ... }[ typeof datum ];

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 função utilizaria [custom ] "type-casting" -- rather," type-/-value-mapping "-- to figure out if a variable actually"exists". Agora podes partir esse cabelo nojento entre null & 0!

Muitas vezes você nem se importa com o seu tipo. Outra forma de contornar a datilografia é combinar conjuntos 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) ...;
}

Ambos Number.prototype e String.prototype toma um. Você acabou de se certificar de que o equivalente de cadeia do número era o mesmo, e então você se certificou de que você passou para a função http como um Number. Em outras palavras, nós nem nos importamos com o seu tipo.

Espero que isso lhe dê mais para trabalhar com:)

Retirado 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

Gosto de usar esta solução simples:

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

Também descobri que isto funciona bem, e é muito mais curto do que os outros exemplos.

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

Ao concatenar sobre aspas vazias transforma o valor numa cadeia de caracteres. Se myVar já é uma cadeia de caracteres, então a instrução if é bem sucedida.

Se trabalhares no nó.ambiente js, você pode simplesmente usar a função built-in isString in utils.

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

Editar: como @Jehy mencionou, isto está desactualizado desde v4.

Uma solução simples seria:

var x = "hello"

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

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))

Este é um grande exemplo de porque o desempenho importa:

Fazer algo tão simples como um teste para uma cadeia de caracteres pode ser caro se não for feito correctamente.

Por exemplo, se eu quisesse escrever uma função para testar se algo é uma cadeia, Eu poderia fazê-lo de uma de duas maneiras:

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

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

Quando o desempenho é testado, o exemplo 1 é 79% mais lento do que o exemplo 2!

Ver os testes: https://jsperf.com/isstringtype

Só para expandir a resposta de @ DRAX , eu faria isto:

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);
}

Também terá em conta os tipos nulls e undefined, e tratará dos tipos Não-string, tais como 0.

O seguinte método irá verificar se alguma variável é uma string (incluindo variáveis que não existem).

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

Não sei se queres dizer saber se é um tipo string independentemente do seu conteúdo, ou se é um número ou uma cadeia, independentemente do seu tipo.

Então para saber se seu tipo é uma string, isso já foi respondido.
Mas para saber com base no seu conteúdo se é uma cadeia ou um número, eu usaria isto:

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

E para alguns exemplos:

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

Ficheiro utilitário completo para verificar todo o tipo de variáveis.

Aqui está a solução completa que, não só lhe dá a função util básica para descobrir se o valor é objeto de cadeia de caracteres ou qualquer outra coisa. Além de outro bem para ter funções.

Este ficheiro raw é usado no meu projecto Redux reat simples no github Reajuste Simples

var Sys = {
    /** This Returns Object Type */
    getType: function(val){
        return Object.prototype.toString.call(val);
    },
    /** This Checks and Return if Object is Defined */
    isDefined: function(val){
        return val !== void 0 || typeof val !== 'undefined';
    }
    /** Run a Map on an Array **/
    map: function(arr,fn){
        var res = [], i=0;
        for( ; i<arr.length; ++i){
            res.push(fn(arr[i], i));
        }
        arr = null;
        return res;
    },
    /** Checks and Return if the prop is Objects own Property */
    hasOwnProp: function(obj, val){
        return Object.prototype.hasOwnProperty.call(obj, val);
    },
    /** Extend properties from extending Object to initial Object */
    extend: function(newObj, oldObj){
        for(var prop in oldObj){
            if(hasOwnProp(oldObj, prop)){
                newObj[prop] = oldObj[prop];
            }
        }
        return newObj;
    } }

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

O código acima irá criar um sistema de objectos = {} este método tem todas as funções como getType, está definido Para usá-los basta verificar chamar este método como este.

if(Sys.isDefined(myVar)){ console.log('myVar is defined'); }else { console.log('no myVar is not defined.');}
//Similar to this 
var myStr = 'You are awesome.. !!';
if(Sys.isString(myStr)){console.log(myStr);}