Revue de code en TypeScript : que vérifier et comment donner un retour

Introduction : pourquoi une revue de code en TypeScript est nécessaire

La revue de code (code review) est le processus de vérification du code écrit par d'autres développeurs. Pour les développeurs TypeScript débutants, ce n'est pas qu'une simple formalité, mais un outil d'apprentissage puissant. Une bonne revue aide à détecter les erreurs à un stade précoce, à améliorer l'architecture et à maintenir un style cohérent au sein de l'équipe.

Dans cet article, nous allons détailler sur quoi se concentrer spécifiquement lors d'une revue de code en TypeScript, comment donner un retour d'information utile, et fournir des exemples de code. Ce contenu est destiné aux débutants qui commencent tout juste à travailler avec TypeScript et souhaitent améliorer leurs compétences en matière de revue.

1. Le typage : le fondement de TypeScript

La première chose à vérifier dans TypeScript est la correction des types. TypeScript ajoute un typage statique, ce qui réduit le nombre de bogues, mais seulement si les types sont utilisés correctement.

Que vérifier :

• Les types explicites pour les paramètres et les valeurs de retour. Évitez any partout où c'est possible.
• L'utilisation d'interfaces et de types plutôt que de primitifs pour les structures complexes.
• L'utilisation correcte des types Union et Intersection.
• L'absence d'assertions de type (type assertions) inutiles.

// Mauvais : type implicite et any
function processData(data: any) {
  return data.name;
}

// Bon : interface explicite
interface User {
  name: string;
  age: number;
}

function processData(data: User): string {
  return data.name;
}

Lors de la revue, faites attention aux endroits où le type any pourrait être remplacé par un type plus spécifique. Cela améliore immédiatement la lisibilité et la sécurité du code.

2. Vérification de null et undefined

TypeScript aide à éviter les erreurs avec null et undefined grâce aux vérifications strictes de null (strict null checks). Mais les développeurs oublient souvent de gérer les valeurs optionnelles.

Que vérifier :

• L'utilisation de ? pour les propriétés et paramètres optionnels.
• La vérification de null avant d'accéder aux propriétés.
• L'utilisation des opérateurs ?? et ?..

// Mauvais : pas de protection contre undefined
function getLength(str: string | undefined): number {
  return str.length; // Erreur : str peut être undefined
}

// Bon : utilisation du chaînage optionnel et de la coalescence nulle
function getLength(str: string | undefined): number {
  return str?.length ?? 0;
}

Lors de la revue de code, vérifiez que toutes les valeurs potentiellement vides sont traitées. C'est une cause fréquente de bogues en production.

3. Propreté du code et lisibilité

TypeScript est une surcouche de JavaScript, donc les principes du code propre restent d'actualité. Une bonne revue de code inclut la vérification du style et de la structure.

Que vérifier :

• Le nommage des variables et des fonctions. Les noms doivent être explicites.
• La longueur des fonctions. Si une fonction fait plus d'une chose, divisez-la.
• Les commentaires. Ils doivent expliquer le « pourquoi », pas le « quoi ».
• L'absence de nombres magiques. Extrayez les constantes dans des variables séparées.

// Mauvais : nombres magiques et nom peu clair
function calc(a: number) {
  return a * 1.2;
}

// Bon : constante et nom compréhensible
const TAX_RATE = 0.2;

function calculateTotalWithTax(amount: number): number {
  return amount * (1 + TAX_RATE);
}

Lors de la revue, posez-vous la question : « Un nouveau développeur pourrait-il comprendre ce code sans explications ? » Si non, demandez une amélioration.

4. Comment donner un retour d'information : avec douceur et de manière constructive

La revue de code n'est pas un examen, mais un dialogue. Pour les débutants, il est particulièrement important de recevoir un retour d'information sans critique personnelle. Voici quelques règles qui vous aideront à donner des commentaires utiles.