Chaînage optionnel TypeScript

Le chaînage optionnel est un moyen sûr d'accéder aux propriétés en TypeScript et JavaScript.

Il permet aux développeurs d'accéder en toute sécurité aux propriétés d'objets imbriqués sous forme d'appels chaînés. Lorsqu'une propriété du chemin d'accès est null ou undefined, l'expression entière est court-circuitée et renvoie undefined sans lever d'erreur.

Cela simplifie grandement le code d'accès aux propriétés d'objets profondément imbriqués.


Diagramme SVG : Comment fonctionne le chaînage optionnel Background Title How Optional Chaining Works Left side: Traditional approach Traditional approach (verbose) // Requires multiple levels of checks var city = user && user.address && user.address.city; Error-prone and redundant code Arrow Simplification Right side: Optional chaining approach Optional chaining approach (concise) // Done in one line var city = user ?.address ?.city; Safe and concise, with automatic short-circuiting Bottom part: Three usages Three forms of optional chaining Usage 1 obj?.prop — property access Usage 2 arr?. Usage 3 obj?.method() — method call Arrow marker

Pourquoi avons-nous besoin du chaînage optionnel ?

Dans le développement JavaScript/TypeScript, nous devons souvent accéder à des propriétés d'objets profondément imbriqués.

L'approche traditionnelle nécessite de vérifier chaque niveau pour l'existence des propriétés. Cela rend non seulement le code verbeux, mais peut aussi facilement omettre des vérifications et provoquer des erreurs d'exécution.

Explication du concept :Le cœur du chaînage optionnel est « l'évaluation en court-circuit ». Lorsque la valeur d'une propriété dans la chaîne est null ou undefined, l'expression entière renvoie immédiatement undefined sans continuer à accéder aux propriétés suivantes.


Syntaxe de base

Utiliser?.opérateur pour accéder en toute sécurité aux propriétés qui peuvent ne pas exister.

Par rapport aux vérifications chaînées traditionnelles avec &&, la syntaxe du chaînage optionnel est plus concise et intuitive.

Exemple

// Définir un objet utilisateur imbriqué
// Contient les informations de nom et d'adresse, et l'adresse a une ville
var user = {
    name: "EXAMPLE",
    address: {
        city: "Beijing"
    }
};

// Approche traditionnelle : utiliser && pour vérifier chaque niveau
// Cette approche est verbeuse et il est facile d'oublier des vérifications
var city1 = user && user.address && user.address.city;

// Approche de chaînage optionnel : utiliser l'opérateur ?.
// Si un niveau quelconque est null ou undefined, renvoyer directement undefined
var city2 = user?.address?.city;

console.log("Approche traditionnelle : " + city1);
console.log("Chaînage optionnel : " + city2);

Sortie :

传统方式: Beijing
可选链: Beijing

Astuce :Lorsque la propriété de l'objet existe, les deux approches produisent le même résultat. Mais le code avec chaînage optionnel est plus concis et lisible.


Gestion des propriétés inexistantes

Lorsqu'une propriété dans le chemin d'accès n'existe pas, le chaînage optionnel renvoie undefined en toute sécurité sans lever d'erreur.

C'est particulièrement utile pour gérer des données provenant d'API ou de saisies de formulaires utilisateur.

Exemple

// Définir un objet utilisateur incomplet
// Ne possède que la propriété name, pas de propriété address
var user = {
    name: "EXAMPLE"
    // La propriété address n'existe pas
};

// Utiliser le chaînage optionnel pour accéder à des propriétés profondes
// user.address est undefined, donc city est aussi undefined
var city = user?.address?.city;

// Accéder à des propriétés imbriquées encore plus profondes
// Même si country n'existe pas, cela renvoie toujours undefined sans erreur
var country = user?.address?.country?.name;

console.log("Ville : " + city);
console.log("Pays : " + country);

Sortie :

City: undefined
国家: undefined

Remarque :Le chaînage optionnel ne renvoie undefined que lors d'un accès à une propriété ; il ne crée pas de nouveaux objets ni de nouvelles propriétés.


Combinaison du chaînage optionnel avec les tableaux

Le chaînage optionnel peut être combiné avec l'accès par index de tableau pour accéder en toute sécurité aux éléments d'un tableau.

Utiliser?.[index]syntaxe pour renvoyer undefined lorsqu'un élément du tableau n'existe pas.

n'existe pas (le tableau ne contient que 2 éléments), renvoie undefined

// Définir un tableau d'utilisateurs
var users = [
    { name: "Alice" },
    { name: "Bob" }
];

// Accéder en toute sécurité au nom du premier élément du tableau
// users?.
var firstUser = users?.[0]?.name;

// Accéder en toute sécurité à un élément inexistant du tableau
// users?.
var tenthUser = users?.[9]?.name;

console.log("Premier utilisateur : " + firstUser);
console.log("Dixième utilisateur : " + tenthUser);

Sortie :

第一个用户: Alice
第十个用户: undefined

Explication :?.[index]et?.La différence est que le premier est utilisé pour les tableaux, et le second pour les propriétés d'objet.


Chaînage optionnel et appels de méthodes

Le chaînage optionnel peut être utilisé pour appeler en toute sécurité des méthodes qui peuvent ne pas exister.

Utiliser?.()syntaxe : si la méthode n'existe pas, elle renvoie undefined sans lever d'erreur.

Exemple

// Définir un objet utilisateur contenant un nom et une méthode greet
var user = {
    name: "Alice",
    // Définir une méthode de salutation
    greet: fonction() {
        return "Bonjour, " + this.name;
    }
};

// Appeler en toute sécurité une méthode existante
// user.greet existe, l'appeler normalement et renvoyer le résultat
var message1 = user.greet?.();

// Appeler en toute sécurité une méthode inexistante
// user.sayHello n'existe pas, renvoie undefined sans erreur
var message2 = user.sayHello?.();

console.log("greet: " + message1);
console.log("sayHello: " + message2);

Sortie :

greet: Hello, Alice
sayHello: undefined

Cas d'utilisation :Cela est particulièrement utile lorsqu'on manipule des fonctions de rappel facultatives ou des gestionnaires d'événements.


Affectation par chaînage optionnel

Le chaînage optionnel peut également être utilisé dans les opérations d'affectation, mais vous devez être conscient de son comportement.

L'affectation par chaînage optionnel ne modifie qu'un chemin existant ; elle ne crée pas automatiquement d'objets intermédiaires.

Exemple

// Définir un objet utilisateur simple
var user = {
    name: "Alice"
};

// Essayer d'utiliser l'affectation par chaînage optionnel
// user?.address n'existe pas, donc toute l'affectation est ignorée
// L'objet user reste inchangé
user?.address?.city = "Beijing";

console.log("Utilisateur : " + JSON.stringify(user));

Sortie :

User: {"name":"Alice"}

Remarque :L'assignation par chaînage optionnel ne peut pas être utilisée pour créer de nouvelles propriétés. Si vous avez besoin de créer des objets imbriqués, vous devriez d'abord utiliser l'approche traditionnelle pour créer les objets intermédiaires.


Coalescence des nuls et chaînage optionnel

Le chaînage optionnel est souvent utilisé avec l'opérateur de coalescence des nuls??en combinaison.

Cette combinaison peut fournir des valeurs par défaut lorsque les propriétés n'existent pas, ce qui rend le code plus robuste.

Exemple

// Définir un objet utilisateur incomplet
var user = {
    name: "Alice"
    // address n'existe pas
};

// Chaînage optionnel + coalescence des nuls : utiliser une valeur par défaut lorsque city est null ou undefined
var city = user?.address?.city ?? "Ville inconnue";

console.log("Ville : " + city);

// Comparaison : approche traditionnelle verbeuse
var country = user && user.address && user.address.country
    ? user.address.country
    : "Pays inconnu";

console.log("Pays : " + country);

Sortie :

City: Unknown City
Country: Unknown Country

Explication :??n'utilise la valeur par défaut que lorsque la valeur est null ou undefined, tandis que||utilisera également la valeur par défaut lorsque la valeur est falsy (0, "", false). Lorsque vous traitez des nombres ou des chaînes de caractères, vous devriez préférer utiliser??。


Notes

  • Évaluation en court-circuit :Le chaînage optionnel renvoie immédiatement lorsqu'il rencontre null ou undefined, et ne continue pas à accéder aux propriétés suivantes.
  • Impossible de créer des propriétés :L'affectation avec chaînage optionnel ne crée pas automatiquement les objets intermédiaires.
  • Combiner avec la coalescence nulle :Il est recommandé de toujours utiliser??pour fournir des valeurs par défaut, et d'utiliser moins||
  • Considérations de performance :Bien que le chaînage optionnel soit plus sûr, l'accès direct offre de meilleures performances lorsqu'il est garanti que la propriété existe.

Suggestion :Dans le développement réel, pour les propriétés provenant de données externes (telles que les réponses d'API, les entrées utilisateur), préférez le chaînage optionnel pour un accès sécurisé.


Résumé

Le chaînage optionnel est une fonctionnalité importante du JavaScript/TypeScript moderne pour gérer les objets imbriqués.

  • ?.:Accéder en toute sécurité aux propriétés d'un objet
  • ?.[index]:Accéder en toute sécurité aux éléments d'un tableau
  • ?.():Appeler en toute sécurité des méthodes susceptibles de ne pas exister
  • ??:Fournir des valeurs par défaut pour gérer les cas undefined

Bonnes pratiques :Utilisez toujours le chaînage optionnel pour accéder en profondeur à des propriétés qui peuvent ne pas exister. Combiné à l'opérateur de coalescence des nuls, vous pouvez écrire du code à la fois sûr et concis.

Autres extensions