Überprüfen Sie, ob eine Variable eine Zeichenfolge in JavaScript ist

Wie kann ich feststellen, ob eine Variable eine Zeichenfolge oder etwas anderes in JavaScript ist?

Sie können den typeofOperator verwenden:

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"

Beispiel von dieser Webseite . (Beispiel wurde jedoch leicht modifiziert).

Dies funktioniert bei mit erstellten Zeichenfolgen nicht wie erwartet new String(), wird jedoch selten verwendet und gegen ^{[1] [2]} empfohlen . In den anderen Antworten erfahren Sie, wie Sie damit umgehen können, wenn Sie dies wünschen.

1. Im Google JavaScript Style Guide heißt es, niemals primitive Objekt-Wrapper zu verwenden .
2. Douglas Crockford empfahl, primitive Objektverpackungen zu verwerfen .

Das funktioniert bei mir:

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

Da mehr als 580 Personen für eine falsche Antwort gestimmt haben und mehr als 800 für eine funktionierende Antwort im Stil einer Schrotflinte gestimmt haben, hielt ich es für sinnvoll, meine Antwort in einer einfacheren Form zu wiederholen, die jeder verstehen kann.

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

Oder inline (ich habe ein UltiSnip-Setup dafür):

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

Zu Ihrer Information, die Antwort von Pablo Santa Cruz ist falsch, weil es so typeof new String("string")istobject

Die Antwort von DRAX ist genau und funktional und sollte die richtige sein (da Pablo Santa Cruz definitiv falsch ist und ich nicht gegen die Volksabstimmung argumentieren werde).

Diese Antwort ist jedoch auch definitiv richtig und tatsächlich die beste Antwort (außer vielleicht für den Vorschlag, lodash / Unterstrich zu verwenden ). Haftungsausschluss: Ich habe zur Codebasis von lodash 4 beigetragen.

Meine ursprüngliche Antwort (die offensichtlich über viele Köpfe flog) lautet wie folgt:

Ich habe dies von underscore.js transkodiert:

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

Das definiert isString, isNumber usw.

In Node.js kann dies als Modul implementiert werden:

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

[Bearbeiten]: Object.prototype.toString.call(x)Funktioniert auch zur Abgrenzung zwischen Funktionen und asynchronen Funktionen:

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

Ich empfehle die integrierten Funktionen von jQuery oder lodash / Underscore . Sie sind einfacher zu bedienen und leichter zu lesen.

Jede Funktion behandelt den erwähnten Fall DRAX ... das heißt, beide prüfen, ob (A) die Variable ein String-Literal oder (B) eine Instanz des String-Objekts ist. In beiden Fällen identifizieren diese Funktionen den Wert korrekt als Zeichenfolge.

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

Weitere Informationen finden Sie in der lodash-Dokumentation zu _.isString () .

Weitere Informationen finden Sie in der jQuery-Dokumentation zu $ ​​.type () .

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

Das habe ich hier gesehen:

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

Bester Weg:

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

Jedes von diesen wurde durch seine entsprechende Klassenfunktion wie "new Object ()" usw. konstruiert.

Ententypisierung: "Wenn es wie eine Ente aussieht, wie eine Ente läuft und wie eine Ente riecht - es muss ein Array sein" bedeutet, überprüfen Sie seine Eigenschaften.

Hoffe das hilft.

Bearbeiten; 12/05/2016

Denken Sie daran, dass Sie auch immer Kombinationen von Ansätzen verwenden können. Hier ist ein Beispiel für die Verwendung einer Inline-Karte von Aktionen mit typeof :

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

Hier ist ein realistischeres Beispiel für die Verwendung von 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

Diese Funktion würde [benutzerdefinierte] "Typumwandlung" - eher "Typ - / - Wertzuordnung" - verwenden, um herauszufinden, ob eine Variable tatsächlich "existiert". Jetzt können Sie das böse Haar zwischen null& aufteilen0 !

Oft interessiert man sich nicht einmal für seinen Typ . Eine andere Möglichkeit, das Tippen zu umgehen, besteht darin, Duck-Type-Sets zu kombinieren:

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

Beide Number.prototype und String.prototype haben eine .toString() method. Sie haben nur sichergestellt, dass das Zeichenfolgenäquivalent der Zahl identisch ist, und dann haben Sie sichergestellt, dass Sie es als httpFunktion an die Funktion übergeben haben Number. Mit anderen Worten, es war uns egal welchen Typ es sich handelte.

Hoffe das gibt dir mehr zum arbeiten :)

Ich kann ehrlich gesagt nicht verstehen, warum man typeofin diesem Fall nicht einfach verwenden würde :

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

Ja, es wird gegen objektumhüllte Zeichenfolgen (z. B. new String('foo')) fehlschlagen, aber diese werden allgemein als schlechte Praxis angesehen, und die meisten modernen Entwicklungswerkzeuge werden wahrscheinlich von ihrer Verwendung abraten. (Wenn Sie eine sehen, beheben Sie sie einfach!)

Der Object.prototype.toStringTrick ist etwas, das alle Front-End-Entwickler eines Tages in ihrer Karriere für schuldig befunden haben, aber lassen Sie sich nicht von seinem cleveren Glanz täuschen: Er wird kaputt gehen, sobald der Affen-Prototyp von einem Affen gepatcht wird:

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

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

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

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

Ich verwende gerne diese einfache Lösung:

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

Dies ist ein gutes Beispiel dafür, warum Leistung wichtig ist:

Etwas so Einfaches wie einen Test für einen String zu machen, kann teuer sein, wenn es nicht richtig gemacht wird.

Wenn ich beispielsweise eine Funktion schreiben wollte, um zu testen, ob etwas eine Zeichenfolge ist, kann ich dies auf zwei Arten tun:

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

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

Beide sind ziemlich einfach. Was könnte sich also möglicherweise auf die Leistung auswirken? Im Allgemeinen können Funktionsaufrufe teuer sein, insbesondere wenn Sie nicht wissen, was im Inneren passiert. Im ersten Beispiel gibt es einen Funktionsaufruf für die toString-Methode von Object. Im zweiten Beispiel gibt es keine Funktionsaufrufe, da typeof und instanceof Operatoren sind. Operatoren sind deutlich schneller als Funktionsaufrufe.

Wenn die Leistung getestet wird, ist Beispiel 1 79% langsamer als Beispiel 2!

Siehe die Tests: https://jsperf.com/isstringtype

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

Funktioniert sowohl für Zeichenfolgenliterale let s = 'blah'als auch für Objektzeichenfolgenlet s = new String('blah')

Entnommen aus 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

Ich denke, dass die @ customcommander-Lösung in 90% Ihrer Fälle ausreichen sollte:

typeof str === 'string'

Sollte dir recht geben (einfach da es normalerweise keinen Grund gibt zu haben new String('something') in Ihrem Code ).

Wenn Sie daran interessiert sind, die String Objekts (zum Beispiel erwarten Sie eine Variation von einem Drittanbieter), scheint die Verwendung von lodash als @ ClearCloud8 vorgeschlagen eine klare, einfache und elegante Lösung zu sein.

Ich würde jedoch empfehlen, mit Bibliotheken wie lodash aufgrund ihrer Größe vorsichtig zu sein. Anstatt zu tun

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

Was das ganze riesige Lodash-Objekt bringt, würde ich so etwas vorschlagen:

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

Und mit einfacher Bündelung sollte es Ihnen gut gehen (ich beziehe mich hier auf Client-Code).

Wenn Sie in der Umgebung von node.js arbeiten, können Sie einfach die integrierte Funktion isString in utils verwenden.

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

Bearbeiten: Wie @Jehy erwähnt, ist dies seit v4 veraltet.

Die folgende Methode überprüft, ob eine Variable eine Zeichenfolge ist ( einschließlich nicht vorhandener Variablen ).

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

Ich fand auch, dass dies auch gut funktioniert und es ist viel kürzer als die anderen Beispiele.

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

Durch Verketten mit leeren Anführungszeichen wird der Wert in eine Zeichenfolge umgewandelt. Wenn myVares sich bereits um eine Zeichenfolge handelt, ist die if-Anweisung erfolgreich.

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

Ich finde diese einfache Technik nützlich, um nach Zeichenfolgen zu suchen -

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

Die gleiche Technik funktioniert auch für 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

Und für 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

Gleiches gilt für Objekt -

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

NB, reguläre Ausdrücke, Arrays und Funktionen werden ebenfalls als Objekte betrachtet.

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)    

Die Suche nach Arrays ist jedoch etwas anders -

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

Diese Technik funktioniert jedoch nicht für Funktionen -

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

Eine einfache Lösung wäre:

var x = "hello"

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

Ein Typechecker-Helfer:

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

Verwendungszweck:

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

Auch wenn Sie möchten, dass es rekursiv ist (wie Array, das ein Objekt ist), können Sie es verwenden instanceof .

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

Ich werde hier einen anderen Weg als den Rest gehen und versuchen festzustellen, ob eine Variable ein bestimmter Typ oder ein Mitglied eines bestimmten Satzes von Typen ist.
JS basiert auf ducktyping; Wenn etwas wie eine Schnur quakt, können und sollten wir es wie eine Schnur verwenden.

Ist 7eine Zeichenfolge? Warum funktioniert /\d/.test(7)dann?
Ist {toString:()=>('hello there')}eine Zeichenfolge? Warum funktioniert ({toString:()=>('hello there')}) + '\ngeneral kenobi!'dann?
Dies sind keine Fragen zu sollten das oben Genannte funktionieren, der Punkt ist, dass sie es tun.

Also habe ich eine duckyString()Funktion erstellt. Im
Folgenden teste ich viele Fälle, die von anderen Antworten nicht berücksichtigt werden. Für jeden Code:

• Setzt eine stringähnliche Variable
• führt eine identische Zeichenfolgenoperation und eine echte Zeichenfolge aus, um die Ausgaben zu vergleichen (was beweist, dass sie wie Zeichenfolgen behandelt werden können)
• konvertiert die Zeichenfolge in eine echte Zeichenfolge, um Ihnen duckyString()zu zeigen, wie Sie Eingaben für Code normalisieren können, der echte Zeichenfolgen erwartet

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

Dies ist in der gleichen Weise wie !!xim Gegensatz zu x===trueund Testen, ob etwas Array- ähnlich ist, anstatt ein tatsächliches Array zu erfordern.
jQuery-Objekte; sind sie Arrays? Sind sie gut genug? Ja, Sie können sie problemlos durch Array.prototypeFunktionen ausführen .
Es ist diese Flexibilität, die JS seine Leistungsfähigkeit verleiht, und das Testen auf Zeichenfolgen macht Ihren Code weniger interoperabel.

Die Ausgabe der oben genannten ist:

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"

Es geht also darum, warum Sie wissen möchten, ob etwas eine Zeichenfolge ist.
Wenn Sie wie ich von Google hierher gekommen sind und sehen möchten, ob etwas stringartig ist , finden Sie hier eine Antwort.
Es ist nicht einmal teuer, wenn Sie nicht mit wirklich langen oder tief verschachtelten Char-Arrays arbeiten.
Dies liegt daran, dass es sich bei allen if-Anweisungen um keine Funktionsaufrufe handelt .toString().
_{Außer wenn Sie versuchen zu sehen, ob ein char-Array Objekte enthält, die nur aus toString()Zeichen oder Multibyte-Zeichen bestehen. In diesem Fall gibt es keine andere Möglichkeit, dies zu überprüfen, als die Zeichenfolge zu erstellen und die Zeichen zu zählen, aus denen die Bytes bestehen}

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

Enthalten sind Optionen zu

• Fragen Sie, welche Methode es als string-y erachtet
• Methoden zur Zeichenfolgenerkennung ausschließen (z. B. wenn Sie nicht mögen .toString())

Hier sind weitere Tests, weil ich ein Vervollständiger bin:

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

• Alle negativen Fälle scheinen berücksichtigt zu sein
• Dies sollte in Browsern> = IE8 ausgeführt werden
• Char-Arrays mit mehreren Bytes werden in Browsern mit Unterstützung für Zeichenfolgeniteratoren unterstützt

Ausgabe:

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"

Um die Antwort von @ DRAX zu erweitern , würde ich Folgendes tun:

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

Es berücksichtigt auch nulls und undefinedTypen und kümmert sich um Nicht-String-Typen, wie z 0.

Das ist gut genug für mich.

WARNUNG: Dies ist keine perfekte Lösung. Siehe den Ende meines Beitrags.

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

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

Und Sie können dies wie unten verwenden.

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

WARNUNG: Dies funktioniert nicht in dem Fall:

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

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

Mit dieser Funktion können Sie den Typ von allem bestimmen:

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

So überprüfen Sie, ob eine Variable eine Zeichenfolge ist:

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

Ich bin mir nicht sicher, ob Sie wissen wollen, ob es sich um einen Typ handelt, stringunabhängig von seinem Inhalt, oder ob es sich bei dem Inhalt um eine Zahl oder eine Zeichenfolge handelt, unabhängig von seinem Typ.

Um zu wissen, ob es sich bei dem Typ um eine Zeichenfolge handelt, wurde diese bereits beantwortet.
Aber um anhand des Inhalts zu wissen, ob es sich um eine Zeichenfolge oder eine Zahl handelt, würde ich Folgendes verwenden:

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

Und für einige Beispiele:

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