Annak ellenőrzése, hogy egy változó egy karakterlánc-e JavaScriptben

Nálam ez működik:

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

Használhatja a typeof operátort:

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"

Példa erről a weboldalról. (A példát azonban kissé módosítottuk).

Ez a new String() segítségével létrehozott karakterláncok esetében nem működik a várt módon, de ezt ritkán használják, és ajánlott ellene[1][2]. A többi válaszban megtalálod, hogyan kezelheted ezeket, ha szeretnéd.

1. A Google JavaScript Style Guide azt mondja, hogy soha ne használjunk primitív objektumcsomagolást.
2. Douglas Crockford azt ajánlja, hogy a primitív objektumcsomagolások használata elavult.

A legjobb módja:

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

Ezek mindegyike a megfelelő osztályfüggvényével lett létrehozva, mint például "new Object()" stb.

Továbbá a kacsa-tipizálás: "Ha úgy néz ki, mint egy kacsa, úgy jár, mint egy kacsa, és úgy szaglik, mint egy kacsa - akkor bizonyára egy Array" Vagyis ellenőrizd a tulajdonságait.

Remélem, ez segít.

Edit; 2016.05.12.

Ne feledd, mindig használhatod a megközelítések kombinációit is. Itt's egy példa a inline map műveletek typeof használatával:

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

Itt'van egy 'valósabb' példa az inline-térképek használatára:

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

Ez a függvény [ custom ] "type-casting" -- inkább "type-/value-mapping" -- használna, hogy kiderítse, hogy egy változó valóban "létezik". Most már szétválaszthatod azt a csúnya szőrszálat a null & 0 között!

Sokszor nem is érdekel a típusa. Egy másik módja a tipizálás megkerülésének a Duck-Type halmazok kombinálása:

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

Mind a Number.prototype és a String.prototype rendelkezik egy .toString() metódussal. Te csak megbizonyosodtál arról, hogy a szám string-egyenértékűje ugyanaz, majd megbizonyosodtál arról, hogy számként adtad át az http függvénybe. Más szóval, még csak nem is voltunk tekintettel arra, hogy milyen típusú.

Remélem, hogy ez több munkalehetőséget ad neked :)