Le chapitre 6 de Clean Code, intitulé "Objets et Structures de Données", met en lumière une distinction fondamentale dans la conception logicielle : comment nous structurons et exposons nos données. Robert C. Martin commence ce chapitre en posant une question provocante : pourquoi gardons-nous nos variables privées si c'est pour ensuite ajouter automatiquement des getters et setters qui les exposent comme si elles étaient publiques ?
Points essentiels à retenir:
- L'abstraction des données va au-delà de l'utilisation de getters et setters
- Les objets cachent leurs données et exposent des comportements
- Les structures de données exposent leurs données et n'ont pas de comportements significatifs
- Éviter de créer des hybrides qui mélangent les deux concepts
- La Loi de Déméter guide les interactions entre objets
1. L'abstraction des données
L'un des principes fondamentaux de la programmation orientée objet est l'encapsulation : nous cachons les détails d'implémentation et exposons une interface. Mais Robert C. Martin va plus loin et distingue deux approches d'abstraction très différentes.
Exemple : Point concret vs Point abstrait en TypeScript
// Point concret - expose son implémentation (coordonnées cartésiennes)
class ConcretePoint {
public x: number;
public y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
// Point abstrait - cache son implémentation
interface AbstractPoint {
getX(): number;
getY(): number;
setCartesian(x: number, y: number): void;
getR(): number;
getTheta(): number;
setPolar(r: number, theta: number): void;
}
// Implémentation possible du point abstrait
class CartesianPoint implements AbstractPoint {
private x: number;
private y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
getX(): number { return this.x; }
getY(): number { return this.y; }
setCartesian(x: number, y: number): void {
this.x = x;
this.y = y;
}
getR(): number {
return Math.sqrt(this.x * this.x + this.y * this.y);
}
getTheta(): number {
return Math.atan2(this.y, this.x);
}
setPolar(r: number, theta: number): void {
this.x = r * Math.cos(theta);
this.y = r * Math.sin(theta);
}
}
La beauté du point abstrait est qu'il est impossible de savoir si l'implémentation utilise des coordonnées cartésiennes, polaires, ou autre chose. L'interface impose également une politique d'accès : on peut lire les coordonnées individuellement, mais on doit les définir ensemble comme une opération atomique.
Abstraction vs Exposition
Robert C. Martin illustre également ce principe avec un exemple de véhicule :
Exemple : Véhicule concret vs Véhicule abstrait
// Véhicule concret - révèle les détails d'implémentation
interface ConcreteVehicle {
getFuelTankCapacityInLiters(): number;
getLitersOfGasoline(): number;
}
// Véhicule abstrait - cache l'implémentation
interface AbstractVehicle {
getPercentFuelRemaining(): number;
}
// Implémentation en React d'un indicateur de carburant
const ConcreteGauge: React.FC<{ vehicle: ConcreteVehicle }> = ({ vehicle }) => {
const capacity = vehicle.getFuelTankCapacityInLiters();
const current = vehicle.getLitersOfGasoline();
const percent = (current / capacity) * 100;
return (
<div className="fuel-gauge">
<div
className="fuel-level"
style={{ width: `${percent}%` }}
/>
<div className="fuel-text">
{current.toFixed(1)} L / {capacity.toFixed(1)} L
</div>
</div>
);
};
// Version abstraite - ne connaît pas les détails d'implémentation
const AbstractGauge: React.FC<{ vehicle: AbstractVehicle }> = ({ vehicle }) => {
const percent = vehicle.getPercentFuelRemaining();
return (
<div className="fuel-gauge">
<div
className="fuel-level"
style={{ width: `${percent}%` }}
/>
<div className="fuel-text">
{percent.toFixed(0)}%
</div>
</div>
);
};
L'option abstraite est préférable car elle ne révèle pas les détails d'implémentation. Robert C. Martin souligne que l'ajout automatique de getters et setters ne constitue pas une véritable abstraction. Une réflexion approfondie est nécessaire pour déterminer la meilleure façon de représenter les données qu'un objet contient.
2. L'antisymétrie des objets et des structures de données
Robert C. Martin établit une distinction claire entre les objets et les structures de données. Cette distinction est fondamentale pour comprendre comment structurer efficacement une application.
Les objets
Les objets cachent leurs données derrière des abstractions et exposent des fonctions qui opèrent sur ces données. Cette encapsulation permet de protéger l'état interne de l'objet et de garantir que toute manipulation passe par une interface bien définie.
En TypeScript et React, les classes et les composants avec état sont de parfaits exemples d'objets. Ils masquent leur implémentation et exposent uniquement les comportements nécessaires pour interagir avec eux.
Exemple d'un objet en TypeScript
// Classe représentant un Point en coordonnées cartésiennes ou polaires
class Point {
// Les données sont privées
private x: number;
private y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
// Interface publique exposant des comportements
getX(): number {
return this.x;
}
getY(): number {
return this.y;
}
// Méthode permettant de définir les coordonnées cartésiennes
setCartesian(x: number, y: number): void {
this.x = x;
this.y = y;
}
// Méthodes dérivées exposant des comportements
getR(): number {
return Math.sqrt(this.x * this.x + this.y * this.y);
}
getTheta(): number {
return Math.atan2(this.y, this.x);
}
// Méthode permettant de définir les coordonnées polaires
setPolar(r: number, theta: number): void {
this.x = r * Math.cos(theta);
this.y = r * Math.sin(theta);
}
}
// Utilisation de la classe Point
const point = new Point(3, 4);
console.log(point.getR()); // 5
console.log(point.getTheta()); // 0.9272952180016122
// Changement des coordonnées en polaires
point.setPolar(10, Math.PI / 4);
console.log(point.getX()); // 7.0710678118654755
console.log(point.getY()); // 7.0710678118654755
Les structures de données
Les structures de données, à l'inverse, exposent leurs données et n'ont pas de comportements significatifs. Elles sont purement destinées à stocker et à transporter des données sans logique métier associée.
En TypeScript, les interfaces et les types sont parfaits pour définir des structures de données. Dans l'écosystème React, les props et les états sont souvent représentés comme des structures de données pures.
Exemple d'une structure de données en TypeScript
// Structure de données représentant un point
interface PointData {
x: number;
y: number;
}
// Structure de données représentant un rectangle
interface RectangleData {
topLeft: PointData;
width: number;
height: number;
}
// Structure de données représentant un cercle
interface CircleData {
center: PointData;
radius: number;
}
// Module utilitaire pour travailler avec ces structures de données
// (code procédural, pas orienté objet)
const GeometryUtils = {
// Calcule l'aire d'une forme
calculateArea(shape: PointData | RectangleData | CircleData): number {
if ('radius' in shape) {
// C'est un cercle
return Math.PI * shape.radius * shape.radius;
} else if ('width' in shape && 'height' in shape) {
// C'est un rectangle
return shape.width * shape.height;
}
// Par défaut
return 0;
},
// Calcule le périmètre d'une forme
calculatePerimeter(shape: RectangleData | CircleData): number {
if ('radius' in shape) {
// C'est un cercle
return 2 * Math.PI * shape.radius;
} else if ('width' in shape && 'height' in shape) {
// C'est un rectangle
return 2 * (shape.width + shape.height);
}
// Par défaut
return 0;
}
};
// Utilisation des structures de données
const rectangle: RectangleData = {
topLeft: { x: 0, y: 0 },
width: 10,
height: 5
};
const circle: CircleData = {
center: { x: 5, y: 5 },
radius: 7
};
console.log(GeometryUtils.calculateArea(rectangle)); // 50
console.log(GeometryUtils.calculateArea(circle)); // 153.93804002589985
console.log(GeometryUtils.calculatePerimeter(rectangle)); // 30
console.log(GeometryUtils.calculatePerimeter(circle)); // 43.982297150257104
2. L'antisymétrie dans le code React
Dans le contexte de React et TypeScript, cette distinction entre objets et structures de données prend une dimension particulière. Les composants React peuvent être vus comme des objets qui encapsulent leur état et exposent des comportements via leur rendu et leurs méthodes, tandis que les props sont des structures de données qui transportent des informations.
L'approche orientée objet en React
Exemple d'approche orientée objet avec les composants React
// Approche orientée objet avec un composant de classe
// Le composant cache son état et expose des comportements
import React, { Component } from 'react';
interface ShapeProps {
initialColor: string;
}
interface ShapeState {
color: string;
isHighlighted: boolean;
}
class Shape extends Component<ShapeProps, ShapeState> {
constructor(props: ShapeProps) {
super(props);
this.state = {
color: props.initialColor,
isHighlighted: false
};
}
// Comportement exposé
highlight = (): void => {
this.setState({ isHighlighted: true });
}
// Comportement exposé
unhighlight = (): void => {
this.setState({ isHighlighted: false });
}
// Comportement exposé
changeColor = (newColor: string): void => {
this.setState({ color: newColor });
}
render() {
const { color, isHighlighted } = this.state;
return (
<div
style={{
backgroundColor: color,
padding: '20px',
border: isHighlighted ? '2px solid gold' : '1px solid gray',
borderRadius: '4px',
display: 'inline-block'
}}
onMouseEnter={this.highlight}
onMouseLeave={this.unhighlight}
>
<p>Je suis une forme de couleur {color}</p>
<button onClick={() => this.changeColor('red')}>Rouge</button>
<button onClick={() => this.changeColor('blue')}>Bleu</button>
<button onClick={() => this.changeColor('green')}>Vert</button>
</div>
);
}
}
// Utilisation du composant
const App = () => {
return <Shape initialColor="yellow" />;
}
L'approche procédurale en React
Exemple d'approche procédurale avec des structures de données
// Approche procédurale avec des structures de données et des hooks
import React from 'react';
// Structures de données pures
interface ShapeData {
color: string;
isHighlighted: boolean;
}
// Fonctions utilitaires séparées
const ShapeUtils = {
highlight(shape: ShapeData): ShapeData {
return { ...shape, isHighlighted: true };
},
unhighlight(shape: ShapeData): ShapeData {
return { ...shape, isHighlighted: false };
},
changeColor(shape: ShapeData, newColor: string): ShapeData {
return { ...shape, color: newColor };
}
};
// Composant simple qui utilise les fonctions utilitaires
const ShapeDisplay: React.FC<{ shape: ShapeData, onShapeChange: (shape: ShapeData) => void }> = ({
shape,
onShapeChange
}) => {
return (
<div
style={{
backgroundColor: shape.color,
padding: '20px',
border: shape.isHighlighted ? '2px solid gold' : '1px solid gray',
borderRadius: '4px',
display: 'inline-block'
}}
onMouseEnter={() => onShapeChange(ShapeUtils.highlight(shape))}
onMouseLeave={() => onShapeChange(ShapeUtils.unhighlight(shape))}
>
<p>Je suis une forme de couleur {shape.color}</p>
<button onClick={() => onShapeChange(ShapeUtils.changeColor(shape, 'red'))}>Rouge</button>
<button onClick={() => onShapeChange(ShapeUtils.changeColor(shape, 'blue'))}>Bleu</button>
<button onClick={() => onShapeChange(ShapeUtils.changeColor(shape, 'green'))}>Vert</button>
</div>
);
};
// Utilisation du composant
const App = () => {
const [shapeData, setShapeData] = React.useState<ShapeData>({
color: 'yellow',
isHighlighted: false
});
return <ShapeDisplay shape={shapeData} onShapeChange={setShapeData} />;
}
3. La Loi de Déméter
Robert C. Martin évoque également la Loi de Déméter, une règle de conception qui stipule qu'un module ne devrait pas connaître les détails internes des objets qu'il manipule. En d'autres termes, "ne parlez qu'à vos amis immédiats, pas aux amis de vos amis".
Éviter les "trains de wagons"
Violation de la Loi de Déméter en TypeScript (à éviter)
// Violation de la Loi de Déméter
const getUserZipCode = (user: User): string => {
return user.getAddress().getCity().getZipCode();
};
// Approche respectant la Loi de Déméter
const getUserZipCode = (user: User): string => {
return user.getZipCode();
};
Dans le contexte de React, cette règle est particulièrement pertinente lorsqu'on manipule des props et des états. Il est préférable de passer uniquement les données nécessaires aux composants enfants plutôt que de leur transmettre des objets complexes dont ils n'utiliseront qu'une petite partie.
Exemple d'application de la Loi de Déméter dans les composants React
// Mauvaise pratique - Violation de la Loi de Déméter
const ProfileCard: React.FC<{ user: User }> = ({ user }) => {
return (
<div>
<h2>{user.profile.name}</h2>
<p>{user.profile.bio}</p>
<img src={user.profile.avatar.url} alt="Avatar" />
<p>
{user.contacts.address.street}, {user.contacts.address.city}
</p>
</div>
);
};
// Bonne pratique - Respect de la Loi de Déméter
interface ProfileCardProps {
name: string;
bio: string;
avatarUrl: string;
location: string;
}
const ProfileCard: React.FC<ProfileCardProps> = ({
name,
bio,
avatarUrl,
location
}) => {
return (
<div>
<h2>{name}</h2>
<p>{bio}</p>
<img src={avatarUrl} alt="Avatar" />
<p>{location}</p>
</div>
);
};
// Utilisation
const App = () => {
const user = getUser();
return (
<ProfileCard
name={user.profile.name}
bio={user.profile.bio}
avatarUrl={user.profile.avatar.url}
location={`${user.contacts.address.street}, ${user.contacts.address.city}`}
/>
);
};
4. DTO et Active Record
Le chapitre conclut en présentant deux modèles spécifiques de structures de données : les Data Transfer Objects (DTO) et les Active Records.
Data Transfer Objects (DTO)
Les DTO sont des structures simples sans comportements, utilisées pour transférer des données entre différentes parties d'une application. En TypeScript, ils sont généralement représentés par des interfaces ou des types.
Exemple de DTO en TypeScript
// DTO pour représenter une adresse
interface AddressDTO {
readonly street: string;
readonly streetExtra?: string;
readonly city: string;
readonly state: string;
readonly zip: string;
}
// Création et utilisation d'un DTO
const address: AddressDTO = {
street: "123 Main St",
city: "San Francisco",
state: "CA",
zip: "94105"
};
// Fonction qui utilise le DTO
const formatAddress = (address: AddressDTO): string => {
const { street, streetExtra, city, state, zip } = address;
let formattedAddress = street;
if (streetExtra) {
formattedAddress += `, ${streetExtra}`;
}
formattedAddress += `, ${city}, ${state} ${zip}`;
return formattedAddress;
};
Dans React et TypeScript, les DTO sont particulièrement utiles pour définir la structure des props des composants et pour modéliser les réponses d'API.
Active Records
Les Active Records sont des structures de données qui incluent à la fois des données et des méthodes de navigation comme save, find, etc. Dans une architecture TypeScript moderne, ils sont souvent représentés par des classes avec des propriétés publiques et des méthodes de persistence.
Exemple d'Active Record en TypeScript
// Active Record pattern
class User {
// Propriétés publiques (données exposées)
public id: number;
public name: string;
public email: string;
public createdAt: Date;
constructor(data?: Partial<User>) {
this.id = data?.id || 0;
this.name = data?.name || '';
this.email = data?.email || '';
this.createdAt = data?.createdAt || new Date();
}
// Méthodes de navigation/persistence
static async findById(id: number): Promise<User | null> {
// Simule une requête à la base de données
const response = await fetch(`/api/users/${id}`);
if (!response.ok) {
return null;
}
const data = await response.json();
return new User(data);
}
async save(): Promise<boolean> {
// Simule une sauvegarde en base de données
const response = await fetch(`/api/users/${this.id || ''}`, {
method: this.id ? 'PUT' : 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
name: this.name,
email: this.email
})
});
if (!response.ok) {
return false;
}
const data = await response.json();
this.id = data.id;
this.createdAt = new Date(data.createdAt);
return true;
}
}
// Utilisation dans React
const UserForm: React.FC = () => {
const [user, setUser] = React.useState(new User());
const handleSubmit = async (e: React.FormEvent) => {
e.preventDefault();
const success = await user.save();
if (success) {
alert('Utilisateur enregistré avec succès!');
} else {
alert('Erreur lors de l\'enregistrement');
}
};
return (
<form onSubmit={handleSubmit}>
<div>
<label>Nom:</label>
<input
type="text"
value={user.name}
onChange={(e) => setUser({ ...user, name: e.target.value })}
/>
</div>
<div>
<label>Email:</label>
<input
type="email"
value={user.email}
onChange={(e) => setUser({ ...user, email: e.target.value })}
/>
</div>
<button type="submit">Enregistrer</button>
</form>
);
};
Robert C. Martin met en garde contre le mélange des Active Records avec des comportements métier, car cela crée des hybrides qui ne sont ni de bons objets ni de bonnes structures de données. La solution qu'il préconise est de traiter les Active Records comme des structures de données pures et de créer des objets séparés qui contiennent la logique métier.
5. Application pratique dans les projets React/TypeScript
Comment appliquer ces principes dans vos projets React et TypeScript ? Voici quelques conseils pratiques :
Adopter une approche hybride équilibrée
Dans une application React/TypeScript moderne, il est souvent judicieux d'adopter une approche hybride mais bien séparée :
- Utiliser des structures de données (interfaces, types) pour modéliser les données, les props et les états
- Créer des objets (classes, hooks personnalisés) pour encapsuler la logique métier et les comportements
- Maintenir une séparation claire entre les deux pour éviter les hybrides confus
Séparer la logique métier des composants UI
Une bonne pratique consiste à séparer la logique métier des composants UI :
Séparation de la logique métier et de l'UI
// 1. Structure de données pour les props du composant
interface ProductCardProps {
id: string;
name: string;
price: number;
imageUrl: string;
inStock: boolean;
// Pas de logique métier ici
}
// 2. Custom hook pour encapsuler la logique métier (objet)
const useProductActions = (productId: string) => {
const [isInCart, setIsInCart] = React.useState(false);
// Logique métier encapsulée
const addToCart = React.useCallback(async () => {
try {
await fetch('/api/cart', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ productId })
});
setIsInCart(true);
} catch (error) {
console.error('Failed to add to cart:', error);
}
}, [productId]);
const removeFromCart = React.useCallback(async () => {
try {
await fetch(`/api/cart/${productId}`, {
method: 'DELETE'
});
setIsInCart(false);
} catch (error) {
console.error('Failed to remove from cart:', error);
}
}, [productId]);
return {
isInCart,
addToCart,
removeFromCart
};
};
// 3. Composant UI qui utilise le hook et les props
const ProductCard: React.FC<ProductCardProps> = ({
id,
name,
price,
imageUrl,
inStock
}) => {
// Utilisation du hook pour la logique métier
const { isInCart, addToCart, removeFromCart } = useProductActions(id);
return (
<div className="product-card">
<img src={imageUrl} alt={name} />
<h3>{name}</h3>
<p>{price.toLocaleString('fr-FR', { style: 'currency', currency: 'EUR' })}</p>
{inStock ? (
<p className="in-stock">En stock</p>
) : (
<p className="out-of-stock">Rupture de stock</p>
)}
{isInCart ? (
<button onClick={removeFromCart}>Retirer du panier</button>
) : (
<button
onClick={addToCart}
disabled={!inStock}
>
Ajouter au panier
</button>
)}
</div>
);
};
Utiliser des services pour la logique métier
Pour les applications plus complexes, on peut créer des services qui encapsulent la logique métier :
Services pour encapsuler la logique métier
// Structure de données pour représenter un produit
interface Product {
id: string;
name: string;
price: number;
imageUrl: string;
inStock: boolean;
}
// Service qui encapsule la logique métier (objet)
class CartService {
private static instance: CartService;
private constructor() {}
// Pattern Singleton
public static getInstance(): CartService {
if (!CartService.instance) {
CartService.instance = new CartService();
}
return CartService.instance;
}
// Méthodes exposant des comportements
public async getCart(): Promise<Product[]> {
const response = await fetch('/api/cart');
return response.json();
}
public async addToCart(productId: string): Promise<void> {
await fetch('/api/cart', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ productId })
});
}
public async removeFromCart(productId: string): Promise<void> {
await fetch(`/api/cart/${productId}`, {
method: 'DELETE'
});
}
public async checkout(): Promise<{ orderId: string }> {
const response = await fetch('/api/checkout', { method: 'POST' });
return response.json();
}
}
// Custom hook qui utilise le service
const useCart = () => {
const [cart, setCart] = React.useState<Product[]>([]);
const [loading, setLoading] = React.useState(true);
const cartService = CartService.getInstance();
const fetchCart = React.useCallback(async () => {
setLoading(true);
try {
const cartItems = await cartService.getCart();
setCart(cartItems);
} catch (error) {
console.error('Failed to fetch cart:', error);
} finally {
setLoading(false);
}
}, [cartService]);
React.useEffect(() => {
fetchCart();
}, [fetchCart]);
const addToCart = React.useCallback(async (productId: string) => {
await cartService.addToCart(productId);
fetchCart();
}, [cartService, fetchCart]);
const removeFromCart = React.useCallback(async (productId: string) => {
await cartService.removeFromCart(productId);
fetchCart();
}, [cartService, fetchCart]);
const checkout = React.useCallback(async () => {
return await cartService.checkout();
}, [cartService]);
return {
cart,
loading,
addToCart,
removeFromCart,
checkout
};
};
// Composant qui utilise le hook
const Cart: React.FC = () => {
const { cart, loading, removeFromCart, checkout } = useCart();
const [checkoutStatus, setCheckoutStatus] = React.useState<string | null>(null);
const handleCheckout = async () => {
try {
const { orderId } = await checkout();
setCheckoutStatus(`Commande #${orderId} confirmée!`);
} catch (error) {
setCheckoutStatus('Erreur lors du paiement');
}
};
if (loading) return <p>Chargement du panier...</p>;
return (
<div className="cart">
<h2>Votre panier ({cart.length} articles)</h2>
{cart.length === 0 ? (
<p>Votre panier est vide</p>
) : (
<>
<ul>
{cart.map(product => (
<li key={product.id}>
{product.name} - {product.price.toLocaleString('fr-FR', { style: 'currency', currency: 'EUR' })}
<button onClick={() => removeFromCart(product.id)}>Supprimer</button>
</li>
))}
</ul>
<button onClick={handleCheckout}>Passer au paiement</button>
{checkoutStatus && <p>{checkoutStatus}</p>}
</>
)}
</div>
);
};
6. Impact de la distinction entre objets et structures de données
Robert C. Martin souligne l'impact fondamental de cette distinction :
Impact de la distinction objets/structures de données :
- Code procédural (utilisant des structures de données) : Facilite l'ajout de nouvelles fonctions sans modifier les structures existantes, mais rend difficile l'ajout de nouvelles structures de données car toutes les fonctions doivent être modifiées.
- Code orienté objet : Facilite l'ajout de nouvelles classes sans modifier les fonctions existantes, mais rend difficile l'ajout de nouvelles fonctions car toutes les classes doivent être modifiées.
Ces caractéristiques opposées sont cruciales pour guider vos choix de conception. Dans une application React/TypeScript, vous pouvez exploiter cette dichotomie :
- Utilisez des structures de données lorsque vous prévoyez d'ajouter régulièrement de nouveaux comportements, mais rarement de nouveaux types de données.
- Utilisez des objets lorsque vous prévoyez d'ajouter régulièrement de nouveaux types, mais rarement de nouveaux comportements.
Dans une application React, cela peut se traduire par :
- Utilisez des structures de données pour représenter les props, les états et les données d'API qui ont une structure stable mais dont l'utilisation peut varier.
- Utilisez des objets (classes, hooks personnalisés, services) pour encapsuler la logique métier qui reste relativement stable mais qui doit s'appliquer à différents types de données.
À Retenir
- Abstraction des données : L'abstraction va au-delà des getters et setters. Elle consiste à exposer l'essence des données sans révéler l'implémentation.
- Objets vs Structures de données : Les objets cachent leurs données et exposent des comportements, tandis que les structures de données exposent leurs données sans comportements significatifs.
- Antisymétrie : Le code procédural facilite l'ajout de fonctions mais rend difficile l'ajout de structures, tandis que le code orienté objet fait l'inverse.
- Loi de Déméter : Un module ne devrait pas connaître les détails internes des objets qu'il manipule. Évitez les chaînes d'appels du type
user.getAddress().getCity().getZipCode(). - DTO et Active Records : Utilisez les DTOs pour transférer des données et les Active Records pour la persistence, mais évitez d'y mélanger la logique métier.
- Hybrides à éviter : Ne créez pas de structures qui sont à mi-chemin entre objets et structures de données, elles cumulent les inconvénients des deux approches.
- Application React/TypeScript : Séparez clairement les données (interfaces, types) de la logique métier (hooks, services) pour maintenir un code propre et maintenable.