web-dev-qa-db-de.com

Prüfen Sie, ob eine Variable in JavaScript eine Zeichenfolge ist

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

1341
Olical

Sie können den Operator typeof 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 aus dieser Webseite . (Beispiel wurde jedoch leicht modifiziert).

Dies funktioniert bei Strings, die mit new String() erstellt wurden, nicht wie erwartet. Dies wird jedoch nur selten verwendet und empfohlen[1] [2]. In den anderen Antworten erfahren Sie, wie Sie damit umgehen, wenn Sie dies wünschen.


  1. Der Google JavaScript Style Guide sagt, dass niemals primitive Objekt-Wrapper verwendet werden sollen .
  2. Douglas Crockford empfohlen, dass primitive Objektumhüllungen nicht mehr empfohlen werden .
1289

Das funktioniert für mich:

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

Da mehr als 580 Menschen für eine falsche Antwort gestimmt haben und mehr als 800 für eine funktionierende, aber Schrotflinten-Antwort, stimmte ich der Meinung zu, dass es sich lohnt, 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 dafür ein UltiSnip-Setup):

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

Zu Ihrer Information, Pablo Santa Cruz 's Antwort ist falsch, weil typeof new String("string")object ist.

Die Antwort von DRAX ist genau und funktionell und sollte die richtige Antwort 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). disclaimer: Ich habe zur codebase lodash 4 beigetragen.

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

Ich habe dies aus underscore.js transcodiert:

['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;
}, {});
113
Orwellophile

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

Jede der beiden Funktionen behandelt den von DRAX erwähnten Fall. Das heißt, beide prüfen , ob (A) die Variable ein String-Literal ist oder (B) eine Instanz des String-Objekts . 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 unter lodash Documentation for _.isString () .

Weitere Informationen finden Sie unter jQuery-Dokumentation für $ .type () .

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

Ich habe das hier gesehen:

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

31
ling

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 konstruiert, wie "new Object ()" usw.

Duck-Typing: "Wenn es aussieht wie eine Ente, läuft wie eine Ente und riecht wie eine Ente - es muss ein Array sein.".

Hoffe das hilft.

Bearbeiten; 12/05/2016

Denken Sie daran, Sie können auch immer Kombinationen von Ansätzen verwenden. Hier ist ein Beispiel für die Verwendung einer Inline-Map 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 [benutzerdefiniert] "Typumwandlung" - stattdessen "Typ -/- Wertzuordnung" - verwenden, um herauszufinden, ob eine Variable tatsächlich "existiert". Jetzt können Sie dieses böse Haar zwischen null & 0 aufteilen!

Häufig interessiert Sie nicht einmal der Typ . Eine andere Möglichkeit, das Tippen zu umgehen, ist das Kombinieren von Duck-Type-Sets:

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.prototypendString.prototype haben eine .toString() method. Sie haben nur sichergestellt, dass das String-Äquivalent der Zahl identisch ist, und dann haben Sie sichergestellt, dass Sie es als http an die Number -Funktion übergeben haben. Mit anderen Worten, wir haben nicht einmal care den Typ angegeben.

Hoffe, das gibt dir mehr zu arbeiten :)

23
Cody

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

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

Wenn ich zum Beispiel eine Funktion schreiben wollte, um zu testen, ob etwas ein String ist, könnte 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? Generell 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

9
Rob Brander

Ich benutze gerne diese einfache Lösung:

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

Genommen von 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
7
Benj Sicam

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

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

Edit: wie @Jehy erwähnt, ist dies seit v4 veraltet.

5
David

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 von leeren Anführungszeichen wird der Wert in eine Zeichenfolge umgewandelt. Wenn myVar bereits eine Zeichenfolge ist, ist die if -Anweisung erfolgreich.

5
Chris Dolphin
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))
3
Jake

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

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

Ja, gegen objektumschlossene Zeichenketten (z. B. new String('foo')) schlägt dies fehl, aber diese werden allgemein als schlechte Praxis angesehen, und die meisten modernen Entwicklungswerkzeuge dürften ihre Verwendung abschrecken. (Wenn Sie eine sehen, reparieren Sie es einfach!)

Der Object.prototype.toString-Trick ist etwas, das alle Front-End-Entwickler für schuldig befunden wurden, eines Tages in ihrer Karriere tätig zu sein, aber lassen Sie sich nicht durch ihre Klugheit von clever täuschen: Es wird kaputt gehen, sobald der Prototyp des Prototyps durch einen Affen-Patch behoben wird:

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

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

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

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

3
customcommander

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

typeof str === 'string'

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

Wenn Sie auch das Objekt String behandeln möchten (zum Beispiel erwarten Sie eine Variable von einem Drittanbieter), erscheint die Verwendung von lodash, wie von @ ClearCloud8 vorgeschlagen, als eine klare, einfache und elegante Lösung.

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

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

Welches bringt das ganze riesige Objekt lodash, würde ich vorschlagen, etwas wie:

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

3
Erez Cohen

Eine einfache Lösung wäre:

var x = "hello"

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

Ich finde diese einfache Technik nützlich, um nach String - 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 Zahl -

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

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

Hinweis: Auch reguläre Ausdrücke, Arrays und Funktionen werden 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)    

Aber nach Array zu suchen ist ein bisschen 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 nicht für Funktionen jedoch -

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

Um nur @ DRAX's answer 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 die Typen nulls und undefined und kümmert sich um Nicht-String-Typen wie 0.

0
ahmd0

Mit dieser Funktion können Sie die Art von allem bestimmen:

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

Die folgende Methode überprüft, ob eine Variable eine Zeichenfolge ist ( einschließlich nicht existierender 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
0
Grant Miller

Das ist gut genug für mich.

WARNUNG: Dies ist keine perfekte Lösung . Siehe unten in meinem Beitrag.

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 folgt 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 falsch 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
0
Tomozma