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 Background Title Project Practice: Task Management System Frontend Frontend (React + TS) Vite + React 18 Components + Hooks Type-safe UI Arrow Backend Backend (Node.js) Express + TS RESTful API Type Definitions Arrow Data Data Storage In-Memory (Demo) Lower Section: Features Project Features Feature 1 Task CRUD Operations Feature 2 Type-safe API Feature 3 State Management Arrow Marker

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

Gestionnaire-de tâches/
├── 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

// Énumération du statut de tâche
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.

< h2 class="example">src/types/api.ts
// Type de réponse API générique
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

// Importer les définitions de types
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.

< h2 class="example">src/hooks/useTasks.ts
// Importer les Hooks React et les types
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

// Importer React et le Hook personnalisé
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

// Importer React et les types
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.

Suggestions :Participez à davantage de projets réels pour approfondir votre compréhension de TypeScript par la pratique.

Autres extensions