TypeScript Academy · Leçon

Comprendre unknown et any

Pourquoi unknown constitue l’alternative sûre du point de vue du typage à any.

Comprendre unknown et any est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.

Deux types universels

TypeScript possède deux types capables de contenir n'importe quelle valeur : any et unknown. Ils semblent similaires, mais leur comportement est très différent. Choisir le bon type est une compétence fondamentale pour écrire du code sûr du point de vue des types.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any désactive la vérification des types

any est une échappatoire qui désactive le vérificateur de types pour cette valeur. Vous pouvez accéder à n'importe quelle propriété ou l'appeler comme une fonction : le compilateur reste silencieux, même si cela provoquait une erreur à l'exécution.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown vous oblige à vérifier

unknown accepte également n'importe quelle valeur, mais vous ne pouvez pas l'utiliser tant que vous n'avez pas établi ce qu'elle est. Le compilateur bloque l'accès aux propriétés et les appels tant que vous n'avez pas réduit le type.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

Réduire unknown avec typeof

Une garde typeof réduit unknown à un type concret à l'intérieur du bloc. Une fois le type réduit, toutes ses méthodes deviennent accessibles en toute sécurité.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Pourquoi unknown est plus sûr

unknown représente une incertitude honnête : « Je ne sais pas encore ce que c'est. » Il vous pousse à valider la valeur avant de l'utiliser, ce qui permet de détecter les erreurs lors de la compilation. any dissimule simplement l'incertitude et les erreurs.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

Affecter à unknown et depuis unknown

Toute valeur peut être affectée à unknown. En revanche, unknown ne peut être affecté qu'à unknown ou à any — pas à des types spécifiques sans réduction préalable. Cette asymétrie est ce qui le rend sûr.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any se propage dans votre code

Une caractéristique dangereuse de any est sa propagation. Dès qu'une valeur est de type any, tout ce qui en dérive devient également de type any, ce qui érode silencieusement la sûreté des types dans tout votre programme.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown contient le risque

Avec unknown, l'incertitude reste localisée. Vous devez réduire explicitement le type à chaque frontière, de sorte que les opérations dangereuses ne puissent pas se propager ailleurs. Le risque reste là où il doit être.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

Typer les frontières des API et du JSON

Les données externes — JSON, réponses réseau, entrées utilisateur — n'offrent aucune garantie. Les typer comme unknown plutôt que any vous oblige à les valider avant de leur faire confiance, ce qui constitue le choix sûr par défaut.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Quand any est acceptable

any peut parfois être pragmatique : pour des prototypes rapides, une migration progressive depuis JavaScript ou l'interopérabilité avec des bibliothèques non typées. Mais considérez-le comme un marqueur temporaire, pas comme une habitude. Préférez unknown chaque fois que possible.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Une comparaison concrète

Comparaison côte à côte : la version avec any se compile, mais peut provoquer une erreur à l'exécution ; la version avec unknown refuse de compiler l'accès dangereux. Le compilateur fait son travail : il vous protège.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Vérification rapide

Évaluez votre compréhension de unknown et de any.

Récapitulatif : unknown et any

Points essentiels :

any désactive la vérification des types et se propage aux valeurs qui en dérivent.
unknown accepte n'importe quelle valeur, mais en bloque l'utilisation tant que vous ne l'avez pas réduite.
Utilisez unknown pour les données externes (JSON, API, entrées utilisateur) afin d'imposer leur validation.
Réservez any aux migrations ou à l'interopérabilité avec du code non typé, comme marqueur temporaire.

Ensuite, nous explorerons le type vide : never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Questions Fréquemment Posées

La leçon « Comprendre unknown et any » est-elle gratuite ?

Oui — le texte complet de « Comprendre unknown et any » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Comprendre unknown et any » ?

Pourquoi unknown constitue l’alternative sûre du point de vue du typage à any. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Comprendre unknown et any » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Comprendre unknown et any
Le type never et les états impossibles
Le type void dans les fonctions
Manipuler unknown avec la sécurité du typage

← Retour à TypeScript Academy