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
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
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
// 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
// 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
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
// 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
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
Autres extensionsSuggestion :Utilisez TypeScript directement dans les nouveaux projets, ce qui peut réduire considérablement les erreurs d'exécution.