TypeScript + React en pratique

TypeScript fournit un support de type complet pour le développement React, améliorant la fiabilité du code.

L'utilisation de TypeScript garantit que les composants React, Props, State, etc., disposent tous d'une vérification de type complète, réduisant les erreurs d'exécution.

Voir le tutoriel React :https://www.example.com/vue3/react-tutorial.html


Diagramme SVG : Flux de travail de développement React + TypeScript Background Title React + TypeScript Type Support Components React Components React.FC<Props> interface ButtonProps { text: string React Hooks useState<T>(initial) useEffect(() => {}, []) useCallback<T>(fn) Events Event Handling React.FormEvent React.ChangeEvent React.MouseEvent Bottom half: Type Safety Advantages Brought by TypeScript Advantage 1 Compile-time Type Checking Advantage 2 Intelligent Code Completion Advantage 3 Safer Refactoring Arrow marker

Pourquoi faut-il utiliser TypeScript dans React ?

Le développement par composants React produit une grande quantité de flux de données tels que Props, State, Context, etc.

Sans définitions de type, il est difficile de suivre la source et la structure des données, et des erreurs d'exécution sont susceptibles de se produire.

TypeScript fournit un système de types complet pour React : les Props des composants ont une vérification de type, useState bénéficie d'une inférence de type, et la gestion des événements dispose d'indications de type.

Flux de données :Le flux de données dans React (Props, State, Context) nécessite des définitions de type, et TypeScript peut garantir la sécurité de type du flux de données.


Créer un projet

Utilisez un outil de scaffolding moderne pour créer un projet React qui prend en charge TypeScript.

Initialiser

# Utiliser Create React App (plus lent mais complet)
npx create-react-app my-app --template typescript

# Ou utiliser Vite (recommandé, plus rapide)
npm create vite@latest my-app -- --template react-ts

Recommandation :Vite est actuellement l'outil de build React le plus recommandé, avec une grande rapidité et une bonne expérience de développement.


Types de composants

Utilisez le type React.FC pour définir des composants fonctionnels.

src/components/Button.tsx

import React from "react";

// Définir le type Props pour le composant bouton
interface ButtonProps {
    text: string;                    // Texte du bouton (requis)
    onClick: () => void;             // Fonction de rappel du clic (requise)
    disabled?: boolean;              // Indique si disabled (facultatif, par défaut false)
    variant?: "primary" | "secondary"; // Variante de Button (facultatif)
}

// Définir le type de composant fonctionnel avec React.FC
const Button: React.FC<ButtonProps> = ({
    text,
    onClick,
    disabled = false,
    variant = "primary"
}) => {
    return (
        <button
            className={`btn btn-${variant}`}
            onClick={onClick}
            disabled={disabled}
        >
            {text}
        </button>
    );
};

export default Button;

Résultat de l'exécution:

Button 组件渲染成功

React.FC:Ceci est le type d'un composant fonction React, incluant des types intégrés tels que children, propTypes, etc.


Types de props

Définir l'interface Props d'un composant pour transmettre des données aux composants enfants.

src/components/UserCard.tsx

import React from "react";

// Définir le type utilisateur
interface User {
    id: number;           // ID utilisateur
    name: string;        // Nom d'utilisateur
    email: string;       // E-mail
    avatar?: string;     // Avatar (facultatif)
}

// Définir les Props pour le composant de carte utilisateur
interface UserCardProps {
    user: User;                       // Objet User (requis)
    onEdit: (user: User) => void;    // Callback de modification
    onDelete: (id: number) => void;  // Callback de suppression
}

const UserCard: React.FC<UserCardProps> = ({ user, onEdit, onDelete }) => {
    return (
        <div className="user-card">
            {user.avatar && <img src={user.avatar} alt={user.name} />}
            <h3>{user.name}</h3>
            <p>{user.email}</p>
            <button onClick={() => onEdit(user)}>Modifier</button>
            <button onClick={() => onDelete(user.id)}>Supprimer</button>
        </div>
    );
};

export default UserCard;
Propagation de types :Transmettez les types via Props pour garantir des types de données cohérents dans l'arborescence des composants.

useState Types

Fournissez des paramètres de type pour useState afin de garantir le bon type d'état.

src/components/Counter.tsx

import React, { useState } from "react";

const Counter: React.FC = () => {
    // Type de base : spécifier explicitement le type number
    const [count, setCount] = useState<number>(0);

    // Type d'objet : spécifier le type de l'objet
    const [user, setUser] = useState<{ name: string; age: number }>({
        name: "Alice",
        age: 25
    });

    return (
        <div>
            <p>Compteur: {count}</p>
            <button onClick={() => setCount(c => c + 1)}>+1</button>
            <button onClick={() => setCount(c => c - 1)}>-1</button>

            <p>User: {user.name}, {user.age}</p>
            <button onClick={() => setUser({ ...user, age: user.age + 1 })}>
Âge+1
            </button>
        </div>
    );
};

export default Counter;

Résultat de l'exécution:

Counter 组件渲染成功

Paramètres génériques :Le T dans useState<T> est le type de l'état. Si une valeur initiale est fournie, TypeScript peut l'inférer automatiquement.


Types de useEffect

useEffect dispose également d’une prise en charge complète des types.

src/components/DataFetcher.tsx

import React, { useState, useEffect } from "react";

// Définir le type utilisateur
interface User {
    id: number;
    name: string;
}

const DataFetcher: React.FC = () => {
    // État de la liste des utilisateurs
    const [users, setUsers] = useState<User[]>([]);
    // État de chargement
    const [loading, setLoading] = useState<boolean>(vrai);
    // État d'erreur
    const [error, setError] = useState<string | null>(null);

    useEffect(() => {
        // Simuler la récupération de données
        fetch("/api/users")
            .then(res => res.json())
            .then(data => {
                setUsers(data);
                setLoading(false);
            })
            .catch(err => {
                setError(err.message);
                setLoading(false);
            });
    }, []);  // Tableau de dépendances vide : s’exécute une seule fois lors du montage du composant

    if (loading) return <div>Chargement...</div>;
    if (error) return <div>Error: {error}</div>;

    return (
        <ul>
            {users.map(user => (
                <li key={user.id}>{user.name}</li>
            ))}
        </ul>
    );
};

export default DataFetcher;

Tableau de dépendances :Le deuxième paramètre de useEffect est le tableau de dépendances. TypeScript vérifiera si toutes les variables utilisées dans le rappel ont été déclarées dans le tableau.


Gestion des événements

Les événements React ont des définitions de type dédiées.

src/components/Form.tsx

import React, { useState } from "react";

const Form: React.FC = () => {
    // État de type string
    const [name, setName] = useState<string>("");

    // Gestion de l'événement de soumission du formulaire
    const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
        e.preventDefault();  // Empêcher la soumission par défaut du formulaire
        console.log("Envoi :", name);
    };

    // Gestion de l'événement de changement de la saisie
    const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
        setName(e.target.value);
    };

    return (
        <form onSubmit={handleSubmit}>
            <input
                type="text"
                value={name}
                onChange={handleChange}
                placeholder="Entrez le nom"
            />
            <button type="submit">Soumettre</button>
        </forme>
    );
};

export default Form;

Résultat de l'exécution:

Form 组件渲染成功

Types d'événements :React fournit des types pour chaque événement DOM, tels que FormEvent, ChangeEvent, MouseEvent, etc.


Notes

  • React.FC :Recommandé pour obtenir une prise en charge complète des types
  • Interface Props :Définir les types de Props pour chaque composant
  • Génériques de useState :Les types complexes doivent être explicitement spécifiés
  • Types d'événements :Utiliser les types d'événements fournis par React

Bonnes pratiques :Placer les définitions de types et les composants dans le même fichier, ou les gérer de manière centralisée dans un répertoire types.


Résumé

TypeScript améliore considérablement l'expérience de développement React.

  • React.FC :Type standard pour les composants fonction React
  • Props :Utiliser une interface pour définir les props d'un composant
  • useState :Utiliser des paramètres génériques pour spécifier le type de l'état
  • useEffect :Prise en charge complète des types
  • Événements :Utiliser les types d'événements React pour éviter any

Suggestion :Utilisez TypeScript directement dans les nouveaux projets, ce qui peut réduire considérablement les erreurs d'exécution.

Autres extensions