HOWTO · JavaScript
Comment vérifier si une variable est une chaîne de caractères en JavaScript
Ce tutoriel explique comment vérifier si une variable est une chaîne de caractères ou non en JavaScript
Sur cette page
Utilisez typeof value === "string" pour vérifier qu’une valeur est une chaîne primitive. C’est généralement le bon choix pour la validation. Les guillemets simples, les guillemets doubles et les accents graves créent tous des chaînes primitives ; le style de guillemets ne change pas leur type.
Vérifier les chaînes primitives avec typeof
Pour une chaîne primitive, l’opérateur typeof renvoie la chaîne "string". Comparez son résultat à cette valeur exacte. La comparaison renvoie false pour les nombres, les booléens, null et les objets. Cette vérification fonctionne avec les valeurs locales, les arguments de fonction et les valeurs reçues d’un autre code.
Exécutez cet exemple. Le bloc et ses libellés affichés restent en anglais afin de préserver le code à l’identique :
const primitive = "hello";
const boxed = new String("hello");
const number = 42;
console.log(typeof primitive);
console.log(typeof boxed);
console.log(typeof number === "string");
string
object
false
La chaîne primitive produit "string", la valeur créée avec new String("hello") produit "object", et 42 échoue à la comparaison avec une chaîne primitive. Pour valider une valeur, utilisez la comparaison typeof value === "string".
Décider s’il faut accepter les objets String
JavaScript possède aussi des objets String, parfois appelés chaînes encapsulées. new String("hello") en crée un, tandis que String("hello"), sans new, renvoie une chaîne primitive. Privilégiez les chaînes primitives : les valeurs encapsulées se comportent comme des objets et peuvent surprendre lors des comparaisons ou dans certaines API.
La vérification avec typeof accepte les chaînes primitives et rejette les objets String, car typeof new String("hello") renvoie "object". C’est généralement le comportement souhaité pour valider une entrée. Si une API accepte délibérément les deux formes, définissez cette règle explicitement au lieu d’assouplir toutes vos vérifications de chaînes.
value instanceof String vérifie si le String.prototype du contexte d’exécution courant figure dans la chaîne de prototypes de la valeur. Le résultat est false pour les chaînes primitives. Il peut aussi être false pour un véritable objet String créé dans un autre contexte, par exemple dans une autre fenêtre ou un autre cadre du navigateur. Cette vérification ne prouve pas qu’un objet possède les données internes d’une chaîne encapsulée.
Comprendre les limites des autres vérifications
Object.prototype.toString.call(value) === "[object String]" peut reconnaître les chaînes primitives et les objets String ordinaires, y compris de nombreux objets provenant d’un autre contexte d’exécution. Ce n’est pas un test d’authenticité universel : les objets peuvent personnaliser le résultat avec Symbol.toStringTag. N’utilisez cette vérification que si cette limite convient aux valeurs traitées par votre code.
String.prototype.isPrototypeOf(value) vérifie si le String.prototype du contexte courant figure dans la chaîne de prototypes d’un objet. Cette méthode s’applique aux objets, pas aux valeurs primitives, et présente une limite liée aux contextes différents, similaire à celle de instanceof. Ni cette méthode ni instanceof String ne prouvent que la valeur est un véritable objet String ou contient des données internes de chaîne : par exemple, Object.create(String.prototype) peut satisfaire ces deux vérifications de chaîne de prototypes. Ces vérifications répondent à des questions différentes et ne sont pas interchangeables. Pour une validation de type ordinaire, utilisez typeof value === "string" et décidez séparément si les objets encapsulant une chaîne font partie des entrées acceptées.
FAQ
Comment vérifier si une variable est une chaîne en JavaScript ?
Utilisez typeof value === "string" pour accepter les chaînes primitives. C’est le choix standard pour la plupart des entrées d’application. Si vous acceptez aussi les valeurs encapsulées, définissez cette règle séparément ; les vérifications de chaîne de prototypes ne prouvent pas à elles seules qu’un objet est un véritable objet String.
Quelle est la différence entre les chaînes primitives et les objets String ?
Une chaîne primitive est une valeur de type chaîne. new String("hello") crée un objet qui en encapsule une ; typeof renvoie donc "object". Privilégiez les chaînes primitives, sauf si une API a spécifiquement besoin d’un objet String.
instanceof String fonctionne-t-il avec les chaînes primitives ?
Non. instanceof vérifie si un objet hérite du constructeur String du contexte d’exécution courant. Les chaînes primitives ne sont pas des objets.
Quelle vérification choisir ?
Utilisez typeof pour valider des chaînes primitives. Utilisez instanceof String ou String.prototype.isPrototypeOf() uniquement si vous devez vérifier une chaîne de prototypes String du même contexte ; aucune des deux méthodes ne prouve qu’il s’agit d’un véritable objet String. Utilisez Object.prototype.toString.call() si vous devez reconnaître les chaînes primitives et encapsulées, en tenant compte de la personnalisation possible par Symbol.toStringTag. Un véritable objet String provenant d’un autre contexte peut échouer aux vérifications de prototypes du contexte courant.