Controlla se una variabile è una stringa in JavaScript

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

È possibile utilizzare l' typeofoperatore:

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 . (L'esempio è stato leggermente modificato).

Questo non funzionerà come previsto nel caso di stringhe create con new String(), ma raramente viene usato e raccomandato contro ^{[1] [2]} . Vedi le altre risposte su come gestirle, se lo desideri.

1. La Guida di stile JavaScript di Google dice di non usare mai wrapper di oggetti primitivi .
2. Douglas Crockford ha raccomandato di deprecare i wrapper di oggetti primitivi .

Questo è ciò che funziona per me:

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

Dato che 580+ persone hanno votato per una risposta errata e 800+ hanno votato per una risposta funzionante ma in stile fucile, ho pensato che valesse la pena rifare la mia risposta in una forma più semplice che tutti possano 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é lo typeof new String("string")èobject

La risposta di DRAX è accurata e funzionale e dovrebbe essere la risposta corretta (dal momento che Pablo Santa Cruz è decisamente errato e non discuterò contro il voto popolare).

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

La mia risposta originale (che ovviamente ha sorvolato 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 + ']';
    }; 
});

Ciò 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;
}, {});

[modifica]: Object.prototype.toString.call(x)funziona anche per delineare tra funzioni e funzioni asincrone:

const fn1 = () => new Promise((resolve, reject) => setTimeout(() => resolve({}), 1000))
const fn2 = async () => ({})

console.log('fn1', Object.prototype.toString.call(fn1))
console.log('fn2', Object.prototype.toString.call(fn2))

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

Entrambe le funzioni gestiranno il caso DRAX menzionato ... cioè, entrambi controlleranno se (A) la variabile è una stringa letterale o (B) è un'istanza dell'oggetto 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 maggiori dettagli.

Vedere la documentazione di jQuery per $ .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 dalla sua funzione di classe appropriata, come "new Object ()" ecc.

Inoltre, Duck-Typing: "Se sembra un'anatra, cammina come un'anatra e profuma di anatra - deve essere una matrice" Significato, controlla le sue proprietà.

Spero che sia di aiuto.

Modificare; 2016/12/05

Ricorda, puoi sempre usare anche combinazioni di approcci. Ecco un esempio dell'uso di una mappa incorporata di azioni con typeof :

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

Ecco un esempio più "reale" dell'uso 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". Ora puoi dividere quei capelli cattivi tra null& 0!

Molte volte non ti interessa nemmeno del suo tipo . Un altro modo per aggirare la digitazione è la combinazione di set 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) ...;
}

Entrambi Number.prototype e String.prototype hanno a .toString() method. Hai appena fatto in modo che l'equivalente in stringa del numero fosse lo stesso e poi ti sei assicurato di averlo passato alla httpfunzione come a Number. In altre parole, non abbiamo nemmeno cura ciò che il suo tipo era.

Spero che ti dia di più per lavorare :)

Onestamente non riesco a capire perché non si debba semplicemente usare typeofin questo caso:

if (typeof str === 'string') {
  return 42;
}

Sì, fallirà contro le stringhe avvolte da oggetti (ad es. new String('foo')), Ma queste sono ampiamente considerate come una cattiva pratica e la maggior parte degli strumenti di sviluppo moderni può scoraggiare il loro uso. (Se ne vedi uno, risolvilo e basta!)

Il Object.prototype.toStringtrucco è qualcosa che tutti gli sviluppatori front-end sono stati giudicati colpevoli di fare un giorno nella loro carriera, ma non lasciarti ingannare dalla sua raffinatezza intelligente: si romperà non appena qualcosa scimmia rattoppierà il prototipo dell'Oggetto:

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

console.log(isString('foo'));

Object.prototype.toString = () => 42;

console.log(isString('foo'));

Mi piace usare questa semplice soluzione:

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

Questo è un ottimo 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));

Entrambi sono piuttosto semplici, quindi cosa potrebbe avere un impatto sulle prestazioni? In generale, le chiamate di funzione possono essere costose, soprattutto se non sai cosa sta succedendo 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 le prestazioni vengono testate, l'esempio 1 è più lento del 79% rispetto all'esempio 2!

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

if (s && typeof s.valueOf() === "string") {
  // s is a string
}

Funziona sia con valori letterali di stringa sia con stringhe let s = 'blah'di oggettilet s = new String('blah')

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

Penso che la soluzione @customcommander dovrebbe essere sufficiente nel 90% dei tuoi casi:

typeof str === 'string'

Dovrebbe servirti nel modo giusto (semplicemente perché normalmente non c'è motivo di avere new String('something')nel tuo codice).

Se sei interessato a gestire il String oggetto (ad esempio ti aspetti qualche var da una terza parte), usare lodash come suggerito da @ ClearCloud8 sembra una soluzione chiara, semplice ed elegante.

Vorrei tuttavia suggerire di essere cauti con le biblioteche come lodash a causa delle loro dimensioni. Invece di farlo

import _ from 'lodash'
...
_.isString(myVar)

Il che porta l'intero enorme oggetto lodash, suggerirei qualcosa del tipo:

import { isString as _isString } from 'lodash'
...
_isString(myVar)

E con un semplice raggruppamento dovresti andare bene (mi riferisco qui al codice client).

Se lavori nell'ambiente node.js, puoi semplicemente utilizzare la funzione integrata isString in utils.

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

Modifica: come accennato da @Jehy, questo è obsoleto dalla v4.

Il seguente metodo verificherà se una variabile è una stringa ( comprese 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

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

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

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

Trovo questa semplice tecnica utile per il controllo del tipo di String -

String(x) === x // true, if x is a string
                // false in every other case

const test = x =>
  console.assert
    ( String(x) === x
    , `not a string: ${x}`
    )

test("some string")
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  // assertion failed
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

La stessa tecnica funziona anche per Number -

Number(x) === x // true, if x is a number
                // false in every other case

const test = x =>
  console.assert
    ( Number(x) === x
    , `not a number: ${x}`
    )

test("some string") // assertion failed
test(123)           
test(0)             
test(/some regex/)  // assertion failed
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

E per RegExp -

RegExp(x) === x // true, if x is a regexp
                // false in every other case

const test = x =>
  console.assert
    ( RegExp(x) === x
    , `not a regexp: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

Lo stesso per l' oggetto -

Object(x) === x // true, if x is an object
                // false in every other case

NB, regexps, array e funzioni sono considerati anche oggetti.

const test = x =>
  console.assert
    ( Object(x) === x
    , `not an object: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  
test([ 5, 6 ])      
test({ a: 1 })      
test(x => x + 1)    

Ma controllare l' array è un po 'diverso -

Array.isArray(x) === x // true, if x is an array
                       // false in every other case

const test = x =>
  console.assert
    ( Array.isArray(x)
    , `not an array: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  // assertion failed
test([ 5, 6 ])      
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

Questa tecnica non non funziona per le funzioni tuttavia -

Function(x) === x // always false

Una soluzione semplice sarebbe:

var x = "hello"

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

Un aiutante Typechecker:

function isFromType(variable, type){
  if (typeof type == 'string') res = (typeof variable == type.toLowerCase())
  else res = (variable.constructor == type)
  return res
}

utilizzo:

isFromType('cs', 'string') //true
isFromType('cs', String) //true
isFromType(['cs'], Array) //true
isFromType(['cs'], 'object') //false

Inoltre, se si desidera che sia ricorsivo (come una matrice che è un oggetto), è possibile utilizzare instanceof.

( ['cs'] instanceof Object //true)

Ho intenzione di seguire una strada diversa rispetto al resto qui, che prova a dire se una variabile è un tipo specifico o un membro di un insieme specifico di tipi.
JS è costruito su ducktyping; se qualcosa cade come una stringa, possiamo e dovremmo usarla come una stringa.

È 7una stringa? Allora perché /\d/.test(7)funziona?
È {toString:()=>('hello there')}una stringa? Allora perché ({toString:()=>('hello there')}) + '\ngeneral kenobi!'funziona?
Queste non sono domande su dovrebbe il lavoro di cui sopra, il punto è che fanno.

Quindi ho fatto una duckyString()funzione
Di seguito ho testato molti casi non soddisfatti da altre risposte. Per ciascuno il codice:

• imposta una variabile simile a una stringa
• esegue un'operazione di stringa identica su di essa e una stringa reale per confrontare gli output (dimostrando che possono essere trattati come stringhe)
• converte il tipo di stringa in una stringa reale per mostrare duckyString()all'utente di normalizzare gli input per il codice che prevede stringhe reali

text = 'hello there';
out(text.replace(/e/g, 'E') + ' ' + 'hello there'.replace(/e/g, 'E'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = new String('oh my');
out(text.toUpperCase() + ' ' + 'oh my'.toUpperCase());
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = 368;
out((text + ' is a big number') + ' ' + ('368' + ' is a big number'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = ['\uD83D', '\uDE07'];
out(text[1].charCodeAt(0) + ' ' + '😇'[1].charCodeAt(0));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

function Text() { this.math = 7; }; Text.prototype = {toString:function() { return this.math + 3 + ''; }}
text = new Text();
out(String.prototype.match.call(text, '0') + ' ' + text.toString().match('0'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

Questo è nella stessa vena di !!xopposto x===truee test se qualcosa è simile a un array invece di richiedere un array reale.
oggetti jQuery; sono array? No. Sono abbastanza bravi? Sì, puoi eseguirli attraverso le Array.prototypefunzioni bene.
È questa flessibilità che dà a JS la sua potenza e il test per stringhe rende specificamente il tuo codice meno interoperabile.

L'output di quanto sopra è:

hEllo thErE hEllo thErE
Is string? true "hello there"

OH MY OH MY
Is string? true "oh my"

368 is a big number 368 is a big number
Is string? true "368"

56839 56839
Is string? true "😇"

0 0
Is string? true "10"

Quindi, tutto dipende dal motivo per cui vuoi sapere se qualcosa è una stringa.
Se, come me, sei arrivato qui da Google e volevi vedere se qualcosa era simile a una stringa , ecco una risposta.
Non è nemmeno costoso a meno che non lavori con array di caratteri molto lunghi o profondamente annidati.
Questo perché è tutto se le istruzioni, nessuna funzione chiama come .toString().
_{Tranne se stai provando a vedere se un array di caratteri con oggetti che hanno solo toString()caratteri multi-byte o, nel qual caso non c'è altro modo di controllare se non per creare la stringa e contare i caratteri che compongono i byte, rispettivamente}

function duckyString(string, normalise, unacceptable) {
    var type = null;
    if (!unacceptable)
        unacceptable = {};
    if (string && !unacceptable.chars && unacceptable.to == null)
        unacceptable.to = string.toString == Array.prototype.toString;

    if (string == null)
        ;

    //tests if `string` just is a string
    else if (
        !unacceptable.is &&
        (typeof string == 'string' || string instanceof String)
    )
        type = 'is';

    //tests if `string + ''` or `/./.test(string)` is valid
    else if (
        !unacceptable.to &&
        string.toString && typeof string.toString == 'function' && string.toString != Object.prototype.toString
    )
        type = 'to';

    //tests if `[...string]` is valid
    else if (
        !unacceptable.chars &&
        (string.length > 0 || string.length == 0)
    ) {
        type = 'chars';
        //for each char
        for (var index = 0; type && index < string.length; ++index) {
            var char = string[index];

            //efficiently get its length
            var length = ((duckyString(char, false, {to:true})) ?
                char :
                duckyString(char, true) || {}
            ).length;

            if (length == 1)
                continue;

            //unicode surrogate-pair support
            char = duckyString(char, true);
            length = String.prototype[Symbol && Symbol.iterator];
            if (!(length = length && length.call(char)) || length.next().done || !length.next().done)
                type = null;
        }
    }

    //return true or false if they dont want to auto-convert to real string
    if (!(type && normalise))
        //return truthy or falsy with <type>/null if they want why it's true
        return (normalise == null) ? type != null : type;

    //perform conversion
    switch (type) {
    case 'is':
        return string;
    case 'to':
        return string.toString();
    case 'chars':
        return Array.from(string).join('');
    }
}

Sono incluse opzioni per

• chiedi quale metodo lo ha considerato string-y
• escludere metodi di rilevamento delle stringhe (ad es. se non ti piace .toString())

Ecco altri test perché sono un completista:

out('Edge-case testing')
function test(text, options) {
    var result = duckyString(text, false, options);
    text = duckyString(text, true, options);
    out(result + ' ' + ((result) ? '"' + text + '"' : text));
}
test('');
test(null);
test(undefined);
test(0);
test({length:0});
test({'0':'!', length:'1'});
test({});
test(window);
test(false);
test(['hi']);
test(['\uD83D\uDE07']);
test([['1'], 2, new String(3)]);
test([['1'], 2, new String(3)], {chars:true});

• Tutti i casi negativi sembrano essere giustificati
• Questo dovrebbe essere eseguito su browser> = IE8
• Array di caratteri con più byte supportati nei browser con supporto iteratore di stringhe

Produzione:

Edge-case testing
is ""
null null
null null
to "0"
chars ""
chars "!"
null null
chars ""
to "false"
null null
chars "😇"
chars "123"
to "1,2,3"

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

Terrà conto anche di tipi nulle undefinedtipi e si occuperà di tipi non stringa, come ad esempio 0.

Questo è abbastanza buono per me.

ATTENZIONE: questa non è una soluzione perfetta. Vedi il fondo del mio post.

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

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

E puoi usarlo come di seguito.

//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"));

ATTENZIONE: questo funziona in modo errato nel caso:

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

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

Puoi usare questa funzione per determinare il tipo di qualsiasi cosa:

var type = function(obj) {
    return Object.prototype.toString.apply(obj).replace(/\[object (.+)\]/i, '$1').toLowerCase();
};

Per verificare se una variabile è una stringa:

type('my string') === 'string' //true
type(new String('my string')) === 'string' //true
type(`my string`) === 'string' //true
type(12345) === 'string' //false
type({}) === 'string' // false

https://codepen.io/patodiblasi/pen/NQXPwY?editors=0012

Non sono sicuro se intendi sapere se è un tipo stringindipendentemente dal suo contenuto o se il suo 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