Pratique complète de projet TypeScript
Ce tutoriel utilise un cas de projet complet pour appliquer de manière exhaustive diverses fonctionnalités de TypeScript.
De la configuration du projet au développement réel, il démontre pleinement l'application de TypeScript dans des projets réels.
Diagramme SVG : Architecture du projet
Pourquoi avons-nous besoin d'une pratique complète de projet ?
Après avoir appris la syntaxe TypeScript, vous devez consolider vos connaissances à travers des projets réels.
Ce tutoriel présente un système complet de gestion des tâches, couvrant le frontend, le backend et les définitions de types.
Grâce à ce projet, vous pouvez maîtriser les meilleures pratiques de TypeScript dans le développement réel.
Objectifs du projet :Créer un système de gestion des tâches avec des fonctionnalités de création, d'interrogation, de mise à jour et de suppression de tâches.
Structure du projet
Organisez la structure du projet en utilisant un style Monorepo.
Structure du répertoire
├── src/
│ ├── types/# Définitions de types
│ │ ├── task.ts# Types de tâches
│ │ ├── api.ts# Types d'API
│ │ └── index.ts# Exports de types
│ │
│ ├── services/# Couche de services
│ │ ├── taskService.ts# Service de tâches
│ │ └── index.ts
│ │
│ ├── components/# Composants React
│ │ ├── TaskList.tsx# Liste des tâches
│ │ ├── TaskItem.tsx# Élément de tâche
│ │ ├── TaskForm.tsx# Formulaire de tâche
│ │ └── index.ts
│ │
│ ├── hooks/# Hooks personnalisés
│ │ ├── useTasks.ts# Gestion de l’état des tâches
│ │ └── index.ts
│ │
│ ├── App.tsx# Application principale
│ ├── App.css# Styles
│ └── main.tsx# Fichier d’entrée
│
├── index.html
├── package.json
├── tsconfig.json
└── vite.config.ts
Division des répertoires :Les répertoires sont divisés par fonction, séparant les définitions de types, la couche de service et les composants.
Définitions de types
Définissez d’abord les types de base du projet.
src/types/task.ts
export type TaskStatus = "pending" | "in-progress" | "completed";
// Énumération de la priorité de tâche
export type TaskPriority = "low" | "medium" | "high";
// Définition de l'interface Task
export interface Task {
id: string; // Identifiant de la tâche
title: string; // Titre de la tâche
description?: string; // Description de la tâche (optionnelle)
status: TaskStatus; // Statut de la tâche
priority: TaskPriority; // Priorité de la tâche
createdAt: string; // Date de création
updatedAt: string; // Heure de mise à jour
dueDate?: string; // Date d'échéance (facultative)
tags?: string[]; // Étiquettes (facultatives)
}
// Type d'entrée pour créer une tâche
export interface CreateTaskInput {
title: string;
description?: string;
priority: TaskPriority;
dueDate?: string;
tags?: string[];
}
// Type d'entrée pour mettre à jour une tâche
export interface UpdateTaskInput {
title?: string;
description?: string;
status?: TaskStatus;
priority?: TaskPriority;
dueDate?: string;
tags?: string[];
}
// Options de filtre des tâches
export interface TaskFilter {
status?: TaskStatus;
priority?: TaskPriority;
search?: string;
}
Superposition des types :Définissez les types d’entrée, les types de sortie et les types de filtre séparément pour faciliter la maintenance.
Définitions de types API
Définissez les types liés à l’API.
export interface ApiResponse<T> {
success: boolean;
data?: T;
error?: string;
message?: string;
}
// Métadonnées de pagination
export interface PaginationMeta {
total: number;
page: number;
pageSize: number;
totalPages: number;
}
// Type de réponse de pagination
export interface PaginatedResponse<T> {
items: T[];
meta: PaginationMeta;
}
// Type d'erreur de requête
export interface ApiError {
code: string;
message: string;
details?: Record<string, string>;
}
// Type de méthode HTTP
export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
// Points de terminaison API liés aux tâches
export interface TaskEndpoints {
getAll: "/api/tasks";
getById: "/api/tasks/:id";
create: "/api/tasks";
update: "/api/tasks/:id";
delete: "/api/tasks/:id";
}
Types d'API :Le format de réponse unifié et les types de gestion des erreurs facilitent l'intégration frontend-backend.
Couche de service des tâches
Implémenter la logique métier pour la gestion des tâches.
src/services/taskService.ts
import {
Tâche,
CreateTaskInput,
UpdateTaskInput,
TaskFilter,
TaskStatus,
TaskPriority
} from "../types/task";
// Générer un ID unique
function generateId(): string {
return Date.now().toString(36) + Math.random().toString(36).substr(2);
}
// Base de données simulée (stockage en mémoire)
let tasks: Task[] = [
{
id: "1",
title: "Apprendre TypeScript",
description: "Maîtriser les bases de TypeScript et les fonctionnalités avancées",
status: "terminé",
priority: "haute",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
tags: ["Apprendre", "TypeScript"]
},
{
id: "2",
title: "Développer un système de gestion de tâches",
description: "Développer avec React + TypeScript",
status: "en cours",
priority: "haute",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
étiquettes: ["Projet", "Pratique"]
}
];
// Classe de service des tâches
class TaskService {
// Récupérer toutes les tâches
getAll(filter?: TaskFilter): Task[] {
let result = [...tasks];
if (filter) {
if (filter.status) {
result = result.filter(t => t.status === filter.status);
}
if (filter.priority) {
result = result.filter(t => t.priority === filter.priorité);
}
if (filter.search) {
const search = filter.search.toLowerCase();
result = result.filter(t =>
t.title.toLowerCase().includes(search) ||
t.description?.toLowerCase().includes(search)
);
}
}
return result;
}
// Obtenir la tâche par ID
getById(id: string): Task | undefined {
return tasks.find(t => t.id === id);
}
// Créer une tâche
create(input: CreateTaskInput): Task {
const now = new Date().toISOString();
const task: Task = {
id: generateId(),
title: input.title,
description: input.description,
status: "pending",
priority: input.priority,
createdAt: now,
updatedAt: now,
dueDate: input.dueDate,
tags: input.tags
};
tasks.push(task);
return task;
}
// Mettre à jour la tâche
update(id: string, input: UpdateTaskInput): Task | null {
const index = tasks.findIndex(t => t.id === id);
if (index === -1) return null;
const task = tasks[index];
const updated: Task = {
...tâche,
...input,
updatedAt: new Date().toISOString()
};
tasks[index] = updated;
return updated;
}
// Supprimer la tâche
delete(id: string): boolean {
const index = tasks.findIndex(t => t.id === id);
if (index === -1) return false;
tasks.splice(index, 1);
return true;
}
// Mettre à jour le statut de la tâche
updateStatus(id: string, status: TaskStatus): Task | null {
return this.update(id, { status });
}
}
// Exporter l'instance du service
export const taskService = new TaskService();
Couche de service :La logique métier est centralisée dans la couche de service pour faciliter les tests et la maintenance.
Hook personnalisé
Utiliser un Hook pour gérer l’état des tâches.
import { useState, useEffect, useCallback } from "react";
import {
Tâche,
CreateTaskInput,
UpdateTaskInput,
TaskFilter,
TaskStatus,
TaskPriority
} from "../types/task";
import { taskService } from "../services/taskService";
// Type d’état renvoyé par le Hook
interface UseTasksReturn {
tasks: Task[];
loading: boolean;
error: string | null;
filter: TaskFilter;
// Méthodes d'opérations
createTask: (input: CreateTaskInput) => Promise<void>;
updateTask: (id: string, input: UpdateTaskInput) => Promise<void>;
deleteTask: (id: string) => Promise<void>;
updateStatus: (id: string, status: TaskStatus) => Promise<void>;
setFilter: (filter: TaskFilter) => void;
refresh: () => void;
}
// Initialiser le filtre par défaut
const defaultFilter: TaskFilter = {};
export function useTasks(): UseTasksReturn {
// État de la liste des tâches
const [tasks, setTasks] = useState<Task[]>([]);
// État de chargement
const [loading, setLoading] = useState(true);
// État d'erreur
const [error, setError] = useState<string | null>(null);
// Conditions de filtrage
const [filter, setFilter] = useState<TaskFilter>(defaultFilter);
// Charger la liste des tâches
const loadTasks = useCallback(() => {
setLoading(true);
setError(null);
try {
const data = taskService.getAll(filter);
setTasks(data);
} catch (err) {
setError(err instanceof Error ? err.message : "Échec du chargement");
} finally {
setLoading(false);
}
}, [filter]);
// Recharger au chargement initial et lors des changements de filtre
useEffect(() => {
loadTasks();
}, [loadTasks]);
// Créer une tâche
const createTask = useCallback(async (input: CreateTaskInput) => {
try {
taskService.create(input);
loadTasks();
} catch (err) {
setError(err instanceof Error ? err.message : "Échec de la création");
}
}, [loadTasks]);
// Mettre à jour la tâche
const updateTask = useCallback(async (id: string, input: UpdateTaskInput) => {
try {
taskService.update(id, input);
loadTasks();
} catch (err) {
setError(err instanceof Error ? err.message : "Échec de la mise à jour");
}
}, [loadTasks]);
// Supprimer la tâche
const deleteTask = useCallback(async (id: string) => {
try {
taskService.delete(id);
loadTasks();
} catch (err) {
setError(err instanceof Error ? err.message : "Échec de la suppression");
}
}, [loadTasks]);
// Mettre à jour le statut de la tâche
const updateStatus = useCallback(async (id: string, status: TaskStatus) => {
try {
taskService.updateStatus(id, status);
loadTasks();
} catch (err) {
setError(err instanceof Error ? err.message : "Échec de la mise à jour du statut");
}
}, [loadTasks]);
// Actualiser la liste des tâches
const refresh = useCallback(() => {
loadTasks();
}, [loadTasks]);
return {
tasks,
loading,
error,
filter,
createTask,
updateTask,
deleteTask,
updateStatus,
setFilter,
refresh
};
}
Hook personnalisé :Encapsuler la gestion d'état et la logique métier dans un Hook, rendant les composants plus concis.
Composants React
Utilisez le Hook pour créer un composant de liste de tâches.
src/components/TaskList.tsx
import React from "react";
import { useTasks } from "../hooks/useTasks";
import { Task, TaskStatus, TaskPriority } from "../types/task";
// Propriétés du composant d'élément de tâche
interface TaskItemProps {
task: Task;
onStatusChange: (id: string, status: TaskStatus) => void;
onDelete: (id: string) => void;
}
// Composant d'élément de tâche
const TaskItem: React.FC<TaskItemProps> = ({
tâche,
onStatusChange,
onDelete
}) => {
// Mappage des styles de statut
const statusStyles: Record<TaskStatus, string> = {
"pending": "status-pending",
"in-progress": "status-progress",
"completed": "status-completed"
};
// Mappage des styles de priorité
const priorityLabels: Record<TaskPriority, string> = {
"low": "Faible",
"medium": "Moyen",
"high": "Élevé"
};
return (
<div className={`task-item ${statusStyles[task.status]}`}>
<div className="task-content">
<h3 className="task-title">{task.title}</h3>
{task.description && (
<p className="task-description">{task.description}</p>
)}
<div className="task-meta">
<span className={`priority priority-${task.priority}`}>
{priorityLabels[task.priority]}
</span>
<span className="task-date">
{new Date(task.createdAt).toLocaleDateString()}
</span>
</div>
</div>
<div className="task-actions">
<select
value={task.status}
onChange={(e) => onStatusChange(task.id, e.target.value as TaskStatus)}
className="status-select"
>
<option value="pending">En attente</option>
<option value="in-progress">En cours</option>
<option value="completed">Terminé</option>
</select>
<button
onClick={() => onDelete(task.id)}
className="delete-btn"
>
Delete
</button>
</div>
</div>
);
};
// Composant de liste de tâches
export const TaskList: React.FC = () => {
// Utiliser un Hook personnalisé pour obtenir l'état des tâches
const {
tasks,
loading,
error,
updateStatus,
deleteTask
} = useTasks();
// Afficher l'état de chargement
if (loading) {
return <div className="loading">Chargement...</div>;
}
// Afficher l'état d'erreur
if (error) {
return <div className="error">Erreur: {error}</div>;
}
// Afficher l'état vide
if (tasks.length === 0) {
return (
<div className="empty">
<p>Aucune tâche pour le moment</p>
<p>Cliquez sur le bouton ci-dessus pour créer une nouvelle tâche</p>
</div>
);
}
// Afficher la liste des tâches
return (
<div className="task-list">
{tasks.map(task => (
<TaskItem
key={task.id}
task={task}
onStatusChange={updateStatus}
onDelete={deleteTask}
/>
))}
</div>
);
};
export default TaskList;
Découpage des composants :Divisez TaskItem en un composant indépendant, ce qui rend le code plus clair.
Composant principal de l'application
Intégrez tous les composants pour former une application complète.
src/App.tsx
import React, { useState } from "react";
import { TaskList } from "./components/TaskList";
import { useTasks } from "./hooks/useTasks";
import { CreateTaskInput, TaskPriority } from "./types/task";
import "./App.css";
// Propriétés du composant de formulaire de tâche
interface TaskFormProps {
onSubmit: (input: CreateTaskInput) => void;
}
// Composant de formulaire de tâche
const TaskForm: React.FC<TaskFormProps> = ({ onSubmit }) => {
// État du formulaire
const [title, setTitle] = useState("");
const [description, setDescription] = useState("");
const [priority, setPriority] = useState<TaskPriority>("moyen");
// Gestion de la soumission
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
if (!title.trim()) {
alert("Veuillez saisir un titre de tâche");
return;
}
onSubmit({
title: title.trim(),
description: description.trim() || undefined,
priorité
});
// Réinitialiser le formulaire
setTitle("");
setDescription("");
setPriority("medium");
};
return (
<form onSubmit={handleSubmit} className="task-form">
<input
type="text"
value={title}
onChange={(e) => setTitle(e.target.value)}
placeholder="Saisir le titre de la tâche"
className="form-input"
/>
<input
type="text"
value={description}
onChange={(e) => setDescription(e.target.value)}
placeholder="Saisir la description de la tâche (facultatif)"
className="form-input"
/>
<select
value={priority}
onChange={(e) => setPriority(e.target.value as TaskPriority)}
className="form-select"
>
<option value="low">Priorité basse</option>
<option value="medium">Priorité moyenne</option>
<option value="high">Priorité élevée</option>
</select>
<button type="submit" className="submit-btn">
Ajouter une tâche
</button>
</forme>
);
};
// Composant principal de l'application
const App: React.FC = () => {
// Utiliser un Hook personnalisé
const { createTask, error } = useTasks();
// Afficher le message d'erreur
const renderError = () => {
if (!error) return null;
return <div className="app-error">{error}</div>;
};
return (
<div className="app">
<header className="app-header">
<h1>Système de gestion des tâches TypeScript</h1>
<p>Projet pratique complet</p>
</header>
{renderError()}
<main className="app-main">
<TaskForm onSubmit={createTask} />
<TaskList />
</main>
<footer className="app-footer">
<p>Propulsé par TypeScript + React</p>
</footer>
</div>
);
};
export default App;
Composition de composants :Construire une interface utilisateur complexe en composant des composants simples.
Configuration du projet
La configuration TypeScript et de build du projet.
tsconfig.json
"compilerOptions": {
"target": "ES2020",
"useDefineForClassFields": true,
"lib": ["ES2020", "DOM", "DOM.Iterable"],
"module": "ESNext",
"skipLibCheck": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react-jsx",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true
},
"include": ["src"],
"references": [{ "": "./tsconfig.node.json" }]
}
Mode strict :Activez strict pour la vérification de type la plus complète.
Notes
- Les types d'abord :Définissez d'abord les types, puis écrivez le code d'implémentation.
- Interface vs type :Utilisez des interfaces pour les types d'objets, des alias de type pour les types union.
- Architecture en couches :Organisez les types, les services, en couches.
- Encapsulation des Hooks :Encapsulez la logique métier dans les Hooks.
Bonnes pratiques :Les définitions de types sont la base d'un projet TypeScript ; concevez-les avec soin.
Résumé
À travers ce projet complet, nous avons mis en pratique les concepts fondamentaux de TypeScript.
- Définitions de types :Interfaces telles que Task, CreateTaskInput, TaskFilter.
- Couche de service :TaskService encapsule la logique métier.
- Hooks personnalisés :useTasks gère l'état.
- Composants React :Développement de composants avec sûreté de typage.
- Configuration du projet :Configuration TypeScript stricte.
Autres extensionsSuggestions :Participez à davantage de projets réels pour approfondir votre compréhension de TypeScript par la pratique.