Controlla se una variabile è una stringa in JavaScript

Come posso determinare se una variabile è una stringa o qualcos’altro in JavaScript?

Puoi usare l’operatore typeof :

 var booleanValue = true; var numericalValue = 354; var stringValue = "This is a String"; alert(typeof booleanValue) // displays "boolean" alert(typeof numericalValue) // displays "number" alert(typeof stringValue) // displays "string" 

Esempio da questa pagina web . (L’esempio è stato leggermente modificato però).

Questo è ciò che funziona per me:

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

Dal momento che più di 580 persone hanno votato per una risposta sbagliata, e 800+ hanno votato per una risposta funzionante ma in stile fucile, ho pensato che valesse la pena di rifare la mia risposta in una forma più semplice che tutti possono capire.

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

Oppure, in linea (ho una configurazione UltiSnip per questo):

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

Cordiali saluti, la risposta di Pablo Santa Cruz è sbagliata, perché typeof new String("string") è un object

La risposta di DRAX è precisa e funzionale, e dovrebbe essere la risposta corretta (dal momento che Pablo Santa Cruz è decisamente inesatto, e non discuterò con il voto popolare).

Tuttavia, questa risposta è anche sicuramente corretta, e in realtà la migliore risposta (tranne, forse, per il suggerimento di usare lodash / underscore ). disclaimer: ho contribuito al codice base di lodash 4.

La mia risposta originale (che ovviamente è volata sopra molte teste) segue:

Ho transcodificato questo da underscore.js:

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

Questo definirà isString, isNumber, ecc.


In Node.js, questo può essere implementato come un modulo:

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

Raccomando di usare le funzioni integrate da jQuery o lodash / Underscore . Sono più semplici da usare e più facili da leggere.

Entrambe le funzioni gestiranno il caso DRAX menzionato … cioè, entrambi controllano se (A) la variabile è una stringa letterale o (B) è un’istanza dell’object String. In entrambi i casi, queste funzioni identificano correttamente il valore come una stringa.

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 

Vedere la documentazione di lodash per _.isString () per ulteriori dettagli.

Vedi jQuery Documentation for $ .type () per maggiori dettagli.

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

L’ho visto qui:

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

Miglior modo:

 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 con la sua funzione di class appropriata, come “nuovo object ()” ecc.

Inoltre, Duck-Typing: “Se sembra un’anatra, cammina come un’anatra e odora come un’anatra – deve essere una Matrice” Significato, controlla le sue proprietà.

Spero che questo ti aiuti.

Modificare; 2016/12/05

Ricorda, puoi sempre usare anche combinazioni di approcci. Ecco un esempio di utilizzo di una mappa inline di azioni con typeof :

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

Ecco un esempio più “reale” di utilizzo delle 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 “esiste” effettivamente. Ora puoi dividere quei capelli cattivi tra null e 0 !

Molte volte non ti importa nemmeno del suo tipo . Un altro modo per aggirare la digitazione è la combinazione di set di tipo Duck:

 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 che String.prototype hanno un .toString() method . Hai appena fatto in modo che l’equivalente della stringa del numero fosse lo stesso, e poi hai fatto in modo di passarlo alla funzione http come Number . In altre parole, non ci importava nemmeno di che tipo fosse.

Spero che ti dia più lavoro con 🙂

Mi piace usare questa semplice soluzione:

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

Tratto da 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 

Una soluzione semplice sarebbe:

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

Se lavori sull’ambiente node.js, puoi semplicemente utilizzare la funzione built-in isString nei programmi di utilità.

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

Modifica: come menzionato @Jehy, questo è deprecato dalla v4.

Ho anche scoperto che questo funziona bene, ed è molto più breve rispetto agli altri esempi.

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

Concatenando su virgolette vuote, trasforma il valore in una stringa. Se myVar è già una stringa, l’istruzione if ha esito positivo.

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

Ecco una semplice funzione principalmente per stampare la risposta ajax, che potrebbe essere una stringa o un object json .

printData ():

 function printData (data) { if (typeof data === 'string' || data instanceof String) { // plain string, console.log("string: %s", data); } else if (typeof data === 'object') { // object, console.log("object: %s", JSON.stringify(data)); } else { // other var t = typeof data; console.log("%s: %o", t, data); } } 

Chiama la funzione:

 // call function, printData("hello"); // string printData({name:"Eric", age:12}); // object printData(3); // number 

Questo è un grande esempio del perché le prestazioni contano:

Fare qualcosa di semplice come un test per una stringa può essere costoso se non eseguito correttamente.

Ad esempio, se volessi scrivere una funzione per verificare se qualcosa è una stringa, potrei farlo in due modi:

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

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

Entrambe queste sono piuttosto avanti, quindi cosa potrebbe avere un impatto sulle prestazioni? In generale, le chiamate di funzione possono essere costose, soprattutto se non si sa cosa succede all’interno. Nel primo esempio, c’è una chiamata di funzione al metodo toString di Object. Nel secondo esempio, non ci sono chiamate di funzione, poiché typeof e instanceof sono operatori. Gli operatori sono significativamente più veloci delle chiamate di funzione.

Quando la prestazione viene testata, l’esempio 1 è il 79% più lento dell’esempio 2!

Guarda i test: https://jsperf.com/isstringtype

Solo per espandere la risposta di @ DRAX, farei questo:

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

Conta anche per i tipi null e undefined , e si prenderà cura dei tipi non string, come 0 .

Il seguente metodo controllerà se una variabile è una stringa ( incluse le variabili che non esistono ).

 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 

File di utilità completo per il controllo di tutti i tipi di variabili.

Ecco la soluzione completa che, non solo fornisce una funzione di base per scoprire se il valore è object String o altro. Inoltre alcune altre funzioni utili.

questo file raw è usato nel mio semplice progetto di reazione redux su github Simple React Redux

 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 

Il codice sopra creerà un object Sys = {} questo metodo ha tutte le funzioni come getType, isDefined Per usarle basta selezionare chiama questo metodo come questo.

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

Non sono sicuro se intendi sapere se si tratta di una string tipo indipendentemente dal suo contenuto o se il contenuto è un numero o una stringa, indipendentemente dal suo tipo.

Quindi, per sapere se il suo tipo è una stringa, è già stata data una risposta.
Ma per sapere in base al suo contenuto se è una stringa o un numero, vorrei usare questo:

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

E per alcuni esempi:

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