Verifica dacă o variabilă este un șir în JavaScript

Aceasta este ceea ce funcționează pentru mine:

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

Puteți folosi typeof` operator:

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"

Exemplu din această pagină web. (De exemplu, a fost ușor modificat, deși).

Asta nu't lucreze cum era de așteptat în cazul de siruri de caractere creat cu new String()`, dar acest lucru este rar folosit și recomandat împotriva[1][2]. Vezi alte răspunsuri pentru cum să se ocupe de acestea, dacă doriți.

1. Google JavaScript Ghid de Stil spune să nu folosiți niciodată primitive obiect ambalaje.
2. Douglas Crockford recomandat primitive obiect ambalaje fi depreciat.

Din 580+ oamenii au votat pentru un răspuns incorect, și 800+ au votat pentru un lucru, dar shotgun-stil de răspuns, am crezut că ar putea fi în valoare de refacerea răspunsul meu într-o formă mai simplă pe care toată lumea poate înțelege.

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

Sau, inline (am un UltiSnip de configurare pentru acest lucru):

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

FYI, Pablo de Santa Cruz's în care răspunsul este greșit, pentru că `typeof new String("string") este "obiect"

DRAX's de răspuns sunt corecte și funcționale, și ar trebui să fie răspunsul corect (de Pablo de Santa Cruz este cu siguranță incorectă, și n-o't argumenta împotriva votului popular.)

Cu toate acestea, acest răspuns este, de asemenea, cu siguranță corect, și, de fapt, cel mai bun raspuns (cu excepția, poate, pentru sugestia de a folosi lodash/subliniere). disclaimer: am contribuit la lodash 4 codebase.

Meu răspuns inițial (care, evident, a zburat peste o mulțime de capete) după cum urmează:

Am transcodat asta de la underscore.js:

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

Care va defini isString, isnum, etc.

În Node.js, acest lucru poate fi implementat ca un modul:

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

Am recomandăm să utilizați built-in functii de jQuery sau lodash/Subliniere. Ei're mai simplu de utilizat și ușor de citit.

Fie funcția se va ocupa de cazul DRAX menționat... asta este, ei ambele verificați dacă (A) variabila este un șir literal sau (B)'s un exemplu de obiect String. În orice caz, aceste funcții identifica în mod corect valoarea ca fiind un șir de caractere.

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

A se vedea lodash Documentația pentru _.isString() pentru mai multe detalii.

A se vedea jQuery Documentația de dolari.tip() pentru mai multe detalii.

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

Am vazut ca aici:

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

Cel mai bun mod:

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

Fiecare dintre acestea a fost construit de către clasa corespunzătoare funcției, cum ar fi "new Obiect()" etc.

De Asemenea, Rață-Tastarea: "Dacă arată ca o rață, merge ca o rață, și miroase ca o rață - trebuie să fie o Matrice" Sensul, verificați proprietățile sale.

Sper că acest lucru vă ajută.

Edita; 12/05/2016

Amintiți-vă, aveți posibilitatea să utilizați întotdeauna combinații de abordări prea. Aici's un exemplu de utilizare a o inline hartă de acțiuni cu typeof:

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

Aici's-o mai 'din lumea reală' exemplu de utilizare inline-maps:

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

Această funcție ar folosi [ custom ] "type-casting" - mai degrabă, "tip/valoare-mapping" -- să-mi dau seama dacă o variabilă de fapt "exista". Acum puteți împărți urât de păr între nul & 0!

De multe ori nu't mai pasă de tipul acesteia. O altă modalitate de a eluda tastarea este combinarea Rață-Tip seturi:

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

Atât Numărul.prototip**și**Șir de caractere.prototipo.toString() metoda`. Tocmai ai făcut-vă că string-echivalentul a numărul a fost la fel, și apoi te-ai asigurat că ai trecut în "http", funcționează ca un "Număr". Cu alte cuvinte, ne-am't chiar îngrijire ce tip sa a fost.

Sper că vă oferă mai mult pentru a lucra cu :)

Pot't sincer, nu văd de ce nu ar folosi pur și simplu `typeof în acest caz:

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

Da va eșua împotriva obiect înfășurat-siruri de caractere (de exemplu, new String('foo')), dar acestea sunt în general considerată ca o practică proastă și cele mai moderne instrumente de dezvoltare sunt de natură să descurajeze utilizarea lor. (Dacă ai văzut unul, trebuie doar să-l repara!)

Obiectul.prototip.toString truc este ceva ce toți dezvoltatorii front-end au fost găsiți vinovați de a face într-o zi în carierele lor, dar don't lăsa păcălit de către polonez de inteligent: se va rupe imediat ca ceva maimuță-patch Obiect prototip:

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

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

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

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

Îmi place să folosesc această soluție simplă:

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

Acesta este un mare exemplu de ce performanța contează:

A face ceva la fel de simplu ca un test pentru un șir poate fi costisitoare, dacă nu se face corect.

De exemplu, dacă am vrut să scrie o funcție pentru a testa dacă ceva este un șir de caractere, am putea-o face într-unul din două moduri:

1. const isString = str => (Obiect.prototip.toString.apel(str) === '[obiect String]');

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

Ambele sunt destul de drept înainte, deci, ce ar putea avea impact asupra performanței? În general vorbind, apeluri de funcții poate fi costisitoare, mai ales dacă nu't știu ce's întâmplă în interior. În primul exemplu, nu este un apel de funcție la Obiect's a metoda toString. În cel de-al doilea exemplu, nu există apeluri de funcții, ca typeof și instanceof sunt operatorii. Operatorii sunt în mod semnificativ mai repede decât apeluri de funcții.

Atunci când performanța este testat, de exemplu 1 este de 79% mai lent decât exemplul 2!

Vezi teste: https://jsperf.com/isstringtype

Luate de la 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

Dacă lucrați pe node.js mediu, pur și simplu, puteți utiliza built-in funcția de isString în utils.

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

Edit: ca @Jehy menționat, aceasta este învechită începând cu v4.

Cred că @customcommander soluție ar trebui să fie suficientă în 90% din cazuri:

typeof str === 'string'

Ar trebui să vă servească drept (pur și simplu, deoarece, în mod normal, nu's nici un motiv să ai `new String('ceva') din cod).

Daca're interesat în manipularea String obiect la fel de bine (de exemplu te aștepți la un var de la un 3rd petrecere) apoi folosind lodash ca @ClearCloud8 sugerat pare clară, simplă și elegantă soluție.

Totuși aș sugera să fie precauți cu biblioteci, cum ar fi lodash din cauza dimensiunii lor. În loc de a face

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

Care aduce întreaga mare lodash obiect, am'd sugera ceva de genul:

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

Și cu o simplă grupare ar trebui să fie bine (mă refer aici la codul clientului).

O soluție simplă ar fi:

var x = "hello"

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

Următoarea metodă va verifica dacă orice variabilă este un șir de caractere (inclusiv variabilele care nu există).

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

De asemenea, am constatat că acest lucru funcționează bine, de asemenea, și mult mai scurt decât alte exemple.

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

Prin concatenarea pe gol citate se transformă în valoare într-un șir. Dacă myVar este deja un șir apoi, dacă declarația este de succes.

Am găsit această tehnică simplă util pentru tip-verificați 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

Aceeași tehnică funcționează pentru Numărul prea -

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

Și pentru 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

Aceeași pentru Obiect -

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

NB, regexps, tablouri, și funcții sunt considerate obiecte.

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)    

Dar, verificarea Matrice este un pic diferit -

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

Aceasta tehnica nu nu de lucru pentru Funcții cu toate acestea -

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

Acest lucru este destul de bun pentru mine.

AVERTISMENT: Acest lucru nu este o soluție perfectă. A se vedea partea de jos a postului.

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

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

Și puteți folosi acest lucru ca de mai jos.

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

AVERTISMENT: Aceasta funcționează incorect în cazul:

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

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

Doar să se extindă pe @DRAX's răspunde, am'd a face acest lucru:

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

Se va ține cont, de asemenea, pentru nul e și "nedefinit" tipuri, și ea va avea grijă de non-string tipuri, cum ar fi0`.

Un typechecker-ul helper: funcția isFromType(variabila, tip){ if (typeof tip == 'string') res = (typeof variabilă == tip.toLowerCase()) altceva res = (variabilă.constructor == tip) reveni res } utilizare: isFromType('cs', 'string') //adevărat isFromType('cs', String) //adevărat isFromType(['cs'], Matrice) //adevărat isFromType(['cs'], 'obiect') //false De asemenea, dacă doriți să fie recursive(ca Matrice care este un Obiect), puteți utiliza instanceof.

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