Regard à l'intérieur de soi : réflexion et introspection en JavaScript

Qu'est-ce que la réflexion et l'introspection en JavaScript et pourquoi en avez-vous besoin ?

Imaginez que vous êtes un programmeur-détective. Vous avez un objet, mais vous ne savez pas ce qu'il contient. Quelles sont ses propriétés ? De quelle nature est-il — un tableau, une fonction ou simplement un ensemble de données ? Dans la vie courante, nous regardons simplement le code, mais dans le monde dynamique de JavaScript, votre programme doit pouvoir le faire lui-même. C'est ce qu'on appelle la réflexion et l'introspection.

Ces termes semblent philosophiques, mais en réalité ce sont des outils puissants. L'introspection est lorsque le code se regarde lui-même : il vérifie le type d'une variable, découvre le nom d'une fonction ou énumère les propriétés d'un objet. La réflexion va plus loin — c'est la capacité du code à se modifier lui-même pendant l'exécution : ajouter de nouvelles méthodes, changer les prototypes ou même créer des objets proxy.

À première vue, cela peut sembler réservé aux auteurs de frameworks complexes. Mais en réalité, vous utilisez l'introspection tous les jours, sans même vous en rendre compte. Lorsque vous écrivez typeof x === 'string' — vous faites déjà de l'introspection. Et lorsque vous utilisez Object.assign pour copier des propriétés — vous appliquez la réflexion.

Dans cet article, nous allons passer en revue toutes les méthodes et techniques clés. Vous apprendrez à « regarder à l'intérieur » de n'importe quel objet, à travailler en toute sécurité avec des données inconnues et à écrire un code plus flexible et adaptatif. C'est parti !

Les bases de l'introspection : regarder ce que nous avons entre les mains

L'introspection commence par une question simple : « Qu'est-ce que c'est ? ». En JavaScript, il existe plusieurs opérateurs et méthodes intégrés qui aident à répondre à cette question.

L'opérateur typeof : vérification rapide du type

C'est votre premier assistant. typeof renvoie une chaîne indiquant le type de l'opérande. Il est simple, mais il comporte quelques pièges.

console.log(typeof 42);        // "number"\nconsole.log(typeof 'hello');   // "string"\nconsole.log(typeof true);      // "boolean"\nconsole.log(typeof undefined); // "undefined"\nconsole.log(typeof null);      // "object" — le voilà, le fameux bug !\nconsole.log(typeof []);        // "object" — ce n'est pas un bug, c'est une fonctionnalité\nconsole.log(typeof function(){}); // "function"

Notez que typeof null renvoie "object". C'est une erreur historique de JavaScript qui ne sera pas corrigée. typeof [] renvoie également "object", ce qui est logique car un tableau est un sous-type d'objet. Mais alors, comment distinguer un tableau d'un objet ordinaire ? Pour cela, il existe d'autres outils.

Astuce utile : typeof est parfait pour vérifier si une variable est définie, sans risque de lever une exception ReferenceError.

if (typeof someGlobalVar !== 'undefined') {\n  // Utilisation sécurisée de someGlobalVar\n}

instanceof : vérification de la chaîne de prototypes

Si typeof répond à la question « quel type primitif ? », instanceof répond à « est-ce un objet d'une classe spécifique ? ». Il vérifie si le prototype du constructeur est présent dans la chaîne de prototypes de l'objet.

const arr = [1, 2, 3];\nconsole.log(arr instanceof Array);  // true\nconsole.log(arr instanceof Object); // true — car Array hérite de Object\n\nconst date = new Date();\nconsole.log(date instanceof Date);   // true\nconsole.log(date instanceof Object); // true\n\n// Mais cela ne fonctionne pas avec les primitifs\nconsole.log('hello' instanceof String); // false — un primitif n'est pas un objet

Nuance importante : instanceof peut échouer lorsqu'on travaille avec des iframes ou différents contextes d'exécution (par exemple, dans Node.js). Chaque contexte a son propre objet global, et [] instanceof window.Array peut renvoyer false si le tableau a été créé dans une autre frame. Pour ces cas, il est préférable d'utiliser Array.isArray().

Array.isArray() et Object.prototype.toString

Blogs

Travailler avec le système de fichiers en C++ : guide pratique

Book Recommendations

Modèles de conception en PHP : Guide pratique

Performances des applications PHP : Optimisation et mise à l'échelle

Concurrence en Kotlin : Programmation asynchrone et coroutines

Développement d'API en JavaScript (Node.js) : des bases à la production

Lire aussi

Déploiement d'une application JavaScript sur VPS : guide étape par étape de A à Z String vs str en Rust : principales différences avec exemples Que doit retourner main() en C++ ? Comparaison avec C et normes Docker et PHP : techniques avancées de conteneurisation d'applications La mémoire en C# sous le microscope : comment fonctionne le ramasse-miettes et pourquoi c'est important