Vérifier si une variable est une chaîne dans TypeScript

1. Types TypeScript
2. Utilisez l’opérateur typeof pour vérifier si une variable est une chaîne dans TypeScript
3. Utilisez l’opérateur instanceof pour vérifier si une variable est une chaîne dans TypeScript
4. Utilisez Object.prototype pour vérifier si une variable est une chaîne dans TypeScript

Cet article discutera de la vérification si une variable est une chaîne dans TypeScript.

Types TypeScript

TypeScript est un sur-ensemble du langage JavaScript où la vérification de type a lieu au moment de la compilation. Chaque fois qu’une variable, une fonction ou un argument est déclaré, TypeScript nous permet d’attribuer les types explicitement, ce qui aide à identifier les erreurs à l’avance.

// variable declaration and assignment
let stringTypeVariable: string = 'Hello world';
let booleanTypeVariable: boolean = true;
let numberTypeVariable: number = 10;

// function declaration
function calculateSum(numOne: number, numTwo: number): number {
    return numOne + numTwo;
}

le type string en TypeScript

Le type de chaîne TypeScript contient une collection de caractères. Il s’agit d’un type de données primitif dans lequel une séquence de caractères est entourée de guillemets simples ou doubles.

Les données textuelles peuvent être stockées dans le type de chaîne. Il existe deux manières de stocker des chaînes dans TypeScript :

1. Stocker en tant que type primitif
2. Stocker en tant qu’instance d’objet

Stocker la chaîne en tant que type primitif

Habituellement, le type de chaîne primitif contient les littéraux de chaîne. Les chaînes primitives sont recommandées sur les instances d’objet.

let stringTypeName: string = 'John Doe';
let stringTypeId: string = "User001";

Stocker la chaîne en tant qu’instance d’objet

TypeScript prend en charge les instances d’objet String où il encapsule le type de chaîne primitif avec des méthodes d’assistance supplémentaires. L’instance de l’objet String aura le String.prototype dans sa chaîne de prototypes.

let stringVal: String = new String('This is a String object');
let anotherStrVal: String = String('Another String object');

Il existe plusieurs façons de vérifier si une variable donnée contient ou non une chaîne. Habituellement, l’opérateur typeof est utilisé pour vérifier les types de chaîne primitifs, et l’opérateur instanceof peut être utilisé avec des instances d’objet String.

En dehors de cela, la propriété Object.prototype peut être utilisée pour vérifier si le type donné est une chaîne ou non.

Utilisez l’opérateur typeof pour vérifier si une variable est une chaîne dans TypeScript

Le typeof est un opérateur unaire TypeScript qui renvoie le type de données de l’opérande spécifié.

Syntaxe:

typeof <operand>

L’opérateur renvoie une chaîne indiquant le type de l’opérande.

Créons une chaîne primitive, userName.

let userName: string = 'Ricky hardy';

Ensuite, nous utiliserons l’opérateur typeof pour vérifier le type de données de la variable userName. Imprimons-le sur la console comme indiqué ci-dessous :

console.log(typeof userName);

Production:

string

Par conséquent, l’opérateur typeof peut être utilisé pour vérifier les chaînes de type primitif dans un fragment de code conditionnel, comme illustré ci-dessous :

if (typeof userName === 'string') {
    // logic to be executed when the type is a string
} else {
    // logic to be executed for non-string types
}

Utilisez l’opérateur instanceof pour vérifier si une variable est une chaîne dans TypeScript

L’opérateur instanceof opère sur la chaîne prototype d’un objet donné et vérifie si la propriété prototype y est apparue. Il vérifie si l’objet spécifié est un enfant ou une instance d’un constructeur donné.

Syntaxe:

<object> instanceof <constructor/type>

Cet opérateur renvoie une valeur booléenne. De plus, l’opérateur n’accepte que les instances d’objet, pas les primitives.

Instancions un nouvel objet String, vehicleBrand.

let vehicleBrand: String = new String("AUDI");

Ensuite, nous utiliserons l’opérateur instanceof pour vérifier si le vehicleBrand est un type de chaîne.

console.log(vehicleBrand instanceof String);

Production:

true

Comme prévu, l’opérateur renvoie true car le vehicleBrand est un objet String.

Utilisez Object.prototype pour vérifier si une variable est une chaîne dans TypeScript

Le Object.prototype peut également être utilisé comme un moyen plus générique d’identifier les types de chaînes dans TypeScript. Cette propriété contient la méthode toString(), où nous pouvons utiliser la méthode call et vérifier le type du prototype d’une variable spécifiée.

Syntaxe:

Object.prototype.toString.call(<variable/object>);

Cela devrait renvoyer une chaîne au format suivant :

"[object String]"
OR
"[object Array]"
OR
.
.
.

Créons une nouvelle variable, newStringValue.

let newStringValue: string = 'This is a new string';

Ensuite, nous allons vérifier le type de constructeur des variables newStringValue à l’aide de la propriété Object.prototype.

console.log(Object.prototype.toString.call(newStringValue));

Production:

[object String]

Comme prévu, le type est une chaîne.