Controleren of een variabele een string is in JavaScript

Dit is wat voor mij werkt:

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

Je kunt de typeof operator gebruiken:

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"

Voorbeeld uit deze webpagina. (Voorbeeld is echter iets aangepast).

Dit zal niet werken zoals verwacht in het geval van strings die zijn gemaakt met new String(), maar dit wordt zelden gebruikt en wordt aanbevolen tegen[1][2]. Zie de andere antwoorden voor hoe hiermee om te gaan, als je dat wilt.

1. De Google JavaScript Style Guide zegt om nooit primitieve object wrappers te gebruiken.
2. Douglas Crockford raadde aan om primitieve object wrappers te depreciëren.

De beste manier:

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

Elk van deze is geconstrueerd door de juiste klasse-functie, zoals "new Object()" enz.

Ook, Duck-Typing: "Als het eruit ziet als een eend, loopt als een eend, en ruikt als een eend - moet het een Array&quot zijn; Betekenis, controleer de eigenschappen.

Ik hoop dat dit helpt.

Edit; 12/05/2016

Vergeet niet dat je ook altijd combinaties van benaderingen kunt gebruiken. Hier's een voorbeeld van het gebruik van een inline map van acties met typeof:

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

Hier's een meer 'echte wereld' voorbeeld van het gebruik van 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

Deze functie zou [ aangepaste ] "type-casting" gebruiken -- eerder, "type-/-value-mapping" -- om uit te zoeken of een variabele werkelijk "bestaat". Nu kun je dat vervelende haar tussen null & 0!

Vaak kan je het type niet eens schelen. Een andere manier om typen te omzeilen is het combineren van 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) ...;
}

Zowel Nummer.prototype als String.prototype hebben een .toString() methode. Je hebt er gewoon voor gezorgd dat het string-equivalent van het getal hetzelfde was, en toen heb je ervoor gezorgd dat je het als een Getal doorgaf aan de http functie. Met andere woorden, het kon ons niet eens veel schelen wat het type was.

Hopelijk geeft dit je meer om mee te werken :)