Controllare se una variabile è una stringa in JavaScript

Questo è quello che funziona per me:

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

Potete usare l'operatore 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"

Esempio da [questa pagina web][1]. (L'esempio è stato però leggermente modificato).

Questo non funzionerà come ci si aspetta nel caso di stringhe create con new String(), ma questo è usato raramente e si raccomanda di non usarlo. Vedi le altre risposte per come gestirle, se lo desideri.

1. La Google JavaScript Style Guide dice di non usare mai wrapper di oggetti primitivi.

2. Douglas Crockford raccomanda che i wrapper di oggetti primitivi siano deprecati.

Il modo migliore:

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

Ognuno di questi è stato costruito dalla sua appropriata funzione di classe, come "new Object()" ecc.

Inoltre, Duck-Typing: "Se ha l'aspetto di un'anatra, cammina come un'anatra e odora come un'anatra - deve essere un Array" Cioè, controlla le sue proprietà.

Spero che questo aiuti.

Modifica; 12/05/2016

Ricorda che puoi sempre usare anche combinazioni di approcci. Ecco un esempio di utilizzo di una mappa in linea di azioni con typeof:

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

Ecco un esempio più 'mondo reale' di utilizzo di mappe in linea:

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

Questa funzione userebbe [ custom ] "type-casting" -- piuttosto, "type-/-value-mapping" -- per capire se una variabile effettivamente "esiste". Ora potete dividere quel brutto pelo tra null & 0!

Molte volte non ti interessa nemmeno il suo tipo. Un altro modo per aggirare la digitazione è combinare gli insiemi 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) ...;
}

Sia Number.prototype e String.prototype hanno un metodo .toString(). Ti sei solo assicurato che l'equivalente stringa del numero sia lo stesso, e poi ti sei assicurato di passarlo nella funzione http come Number. In altre parole, non ci importava nemmeno di quale fosse il suo tipo.

Spero che questo ti dia qualcosa in più con cui lavorare :)