Come posso verificare se un var è una stringa in JavaScript?

Come posso verificare se un var è una stringa in JavaScript?

L'ho provato e non funziona ...

var a_string = "Hello, I'm a string.";

if (a_string typeof 'string') {
    // this is a string
}

Eri vicino:

if (typeof a_string === 'string') {
    // this is a string
}

In una nota correlata: il controllo sopra riportato non funzionerà se viene creata una stringa new String('hello')come sarà Objectinvece il tipo . Ci sono soluzioni complicate per aggirare questo problema, ma è meglio evitare di creare stringhe in quel modo, mai.

L' typeofoperatore non è un infisso (quindi l'LHS del tuo esempio non ha senso).

Devi usarlo in questo modo ...

if (typeof a_string == 'string') {
    // This is a string.
}

Ricorda, typeofè un operatore, non una funzione. Nonostante ciò, vedrai typeof(var)essere usato molto in natura. Questo ha tanto senso quanto var a = 4 + (1).

Inoltre, puoi anche usare ==(operatore di confronto di uguaglianza) poiché entrambi gli operandi sono Strings ( restituisce typeof sempre a String), JavaScript è definito per eseguire gli stessi passaggi che avevo usato ===(operatore di confronto rigoroso).

Come menziona Box9 , questo non rileverà un Stringoggetto istanziato .

Puoi rilevarlo con ....

var isString = str instanceof String;

jsFiddle .

...o...

var isString = str.constructor == String;

jsFiddle .

Ma questo non funzionerà in un windowambiente multiplo (pensa iframe).

Puoi aggirare questo con ...

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

jsFiddle .

Ma ancora, (come menziona Box9 ), stai meglio usando solo il Stringformato letterale , ad es var str = 'I am a string';.

Ulteriori letture .

La combinazione delle risposte precedenti fornisce queste soluzioni:

if (typeof str == 'string' || str instanceof String)

o

Object.prototype.toString.call(str) == '[object String]'

L'espressione seguente restituisce true :

'qwe'.constructor === String

L'espressione seguente restituisce true :

typeof 'qwe' === 'string'

L'espressione seguente restituisce false (sic!):

typeof new String('qwe') === 'string'

L'espressione seguente restituisce true :

typeof new String('qwe').valueOf() === 'string'

Modo migliore e giusto ( imho ):

if (someVariable.constructor === String) {
   ...
}

Oggi credo che sia preferito usare una forma funzione di typeof () quindi ...

if(filename === undefined || typeof(filename) !== "string" || filename === "") {
   console.log("no filename aborted.");
   return;
}

controlla null o indefinito in tutti i casi a_string

if (a_string && typeof a_string === 'string') {
    // this is a string and it is not null or undefined.
}

Il mio approccio personale, che sembra funzionare in tutti i casi, sta testando la presenza di membri che saranno tutti presenti solo per le stringhe.

function isString(x) {
    return (typeof x == 'string' || typeof x == 'object' && x.toUpperCase && x.substr && x.charAt && x.trim && x.replace ? true : false);
}

Vedi: http://jsfiddle.net/x75uy0o6/

Mi piacerebbe sapere se questo metodo ha dei difetti, ma mi ha servito bene per anni.