Vérifier si une variable est une chaîne de caractères en JavaScript

C'est ce qui fonctionne pour moi :

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

Vous pouvez utiliser l'opérateur typeof :

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"

Exemple tiré de [cette page web][1]. (L'exemple a été légèrement modifié).

Cela ne fonctionnera pas comme prévu dans le cas de chaînes créées avec new String(), mais cela est rarement utilisé et il est recommandé de ne pas[1][2]. Consultez les autres réponses pour savoir comment les gérer, si vous le souhaitez.

1. Le Google JavaScript Style Guide [indique qu'il ne faut jamais utiliser de wrappers d'objets primitifs] (https://google.github.io/styleguide/jsguide.html#disallowed-features-wrapper-objects).
2. Douglas Crockford [recommande que les enveloppes d'objets primitifs soient dépréciées] (http://www.crockford.com/javascript/recommend.html).

[1] : https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof

Le meilleur moyen :

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

Chacun de ces objets a été construit par la fonction de classe appropriée, comme "new Object()&quot ; etc.

Aussi, Duck-Typing : "Si ça ressemble à un canard, marche comme un canard, et sent comme un canard - ça doit être un tableau&quot ; Autrement dit, vérifiez ses propriétés.

J'espère que cela vous aidera.

Edit ; 12/05/2016

N'oubliez pas que vous pouvez toujours utiliser des combinaisons d'approches également. Voici un exemple d'utilisation d'une map en ligne d'actions avec typeof :

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

Voici un exemple plus réaliste de l'utilisation des cartes en ligne :

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

Cette fonction utiliserait [ custom ] "type-casting&quot ; -- plutôt, "type-/-value-mapping&quot ; -- pour déterminer si une variable "existe&quot ;. Maintenant, vous pouvez diviser ces cheveux méchants entre null &amp ; 0 !

Souvent, on ne se soucie même pas de son type. Une autre façon de contourner le typage est de combiner les ensembles Duck-Type :

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

Les deux Number.prototype et String.prototype ont une méthode .toString(). Vous avez simplement fait en sorte que l'équivalent chaîne du nombre soit le même, puis vous avez fait en sorte de le passer dans la fonction http comme un Number. En d'autres termes, nous ne nous sommes même pas souciés de son type.

J'espère que cela vous donnera plus de matière à travailler :)