Le chapitre 3 de "Clean Code" est considéré comme l'un des plus importants du livre, car il aborde les fonctions, éléments fondamentaux de tout programme. Pour un développeur React/TypeScript, maîtriser l'art de créer des fonctions propres et efficaces est essentiel pour construire des composants réutilisables et maintenables. Ce chapitre vous guidera à travers les principes de Uncle Bob adaptés au monde moderne du développement frontend.
Points essentiels à retenir:
- Les fonctions doivent être courtes (idéalement 20 lignes maximum)
- Chaque fonction devrait faire une seule chose et la faire bien
- Limitez les arguments à 2, voire 3 maximum
- Évitez les effets secondaires cachés
- Les fonctions pures sont préférables en React/TypeScript
1. La taille idéale des fonctions
Robert C. Martin est catégorique : les fonctions devraient être petites, puis encore plus petites. Dans le contexte React/TypeScript moderne, cette règle est particulièrement pertinente. Les composants React peuvent rapidement devenir monolithiques si nous ne prenons pas soin de décomposer leur logique en fonctions petites et ciblées.
Planning horaire pour refactoriser vos fonctions
Consacrez 1 heure par jour pendant une semaine à l'audit et à la refactorisation de vos fonctions trop longues. Une approche progressive vous permettra d'améliorer votre codebase sans perturber votre rythme de développement habituel.
Exemple de refactorisation en React/TypeScript
// AVANT: Fonction longue et difficile à maintenir
const UserProfile = ({ userId }: { userId: string }) => {
const [user, setUser] = useState<User | null>(null);
const [loading, setLoading] = useState<boolean>(true);
const [error, setError] = useState<Error | null>(null);
const [activeTab, setActiveTab] = useState<string>('info');
useEffect(() => {
// Récupération des données utilisateur
setLoading(true);
fetch(`/api/users/${userId}`)
.then(response => {
if (!response.ok) {
throw new Error('Erreur lors de la récupération des données');
}
return response.json();
})
.then(data => {
// Transformation et validation des données
if (!data.name || !data.email) {
throw new Error('Données utilisateur incomplètes');
}
const formattedUser = {
...data,
fullName: `${data.firstName} ${data.lastName}`,
joinDate: new Date(data.joinDate).toLocaleDateString(),
isAdmin: data.roles.includes('admin')
};
setUser(formattedUser);
setLoading(false);
})
.catch(err => {
setError(err);
setLoading(false);
});
}, [userId]);
const handleTabChange = (tab: string) => {
setActiveTab(tab);
};
if (loading) return <div>Chargement...</div>;
if (error) return <div>Erreur: {error.message}</div>;
if (!user) return <div>Aucun utilisateur trouvé</div>;
return (
<div className="profile-container">
<header>
<h1>{user.fullName}</h1>
{user.isAdmin && <span className="admin-badge">Administrateur</span>}
</header>
<div className="tabs">
<button
className={activeTab === 'info' ? 'active' : ''}
onClick={() => handleTabChange('info')}
>
Informations
</button>
<button
className={activeTab === 'activity' ? 'active' : ''}
onClick={() => handleTabChange('activity')}
>
Activité
</button>
</div>
{activeTab === 'info' && (
<div className="user-info">
<p>Email: {user.email}</p>
<p>Membre depuis: {user.joinDate}</p>
{/* Plus d'informations utilisateur... */}
</div>
)}
{activeTab === 'activity' && (
<div className="user-activity">
{/* Contenu de l'activité utilisateur... */}
</div>
)}
</div>
);
};
// APRÈS: Décomposé en fonctions spécifiques
// Types
interface User {
id: string;
firstName: string;
lastName: string;
email: string;
joinDate: string;
roles: string[];
}
interface FormattedUser extends User {
fullName: string;
isAdmin: boolean;
formattedJoinDate: string;
}
// Hook personnalisé pour la logique de récupération des données
const useUserData = (userId: string) => {
const [user, setUser] = useState<FormattedUser | null>(null);
const [loading, setLoading] = useState<boolean>(true);
const [error, setError] = useState<Error | null>(null);
useEffect(() => {
const fetchUser = async () => {
try {
setLoading(true);
const response = await fetch(`/api/users/${userId}`);
if (!response.ok) {
throw new Error('Erreur lors de la récupération des données');
}
const data: User = await response.json();
validateUserData(data);
const formattedUser = formatUserData(data);
setUser(formattedUser);
} catch (err) {
setError(err instanceof Error ? err : new Error('Une erreur inconnue est survenue'));
} finally {
setLoading(false);
}
};
fetchUser();
}, [userId]);
return { user, loading, error };
};
// Fonction de validation
const validateUserData = (data: User): void => {
if (!data.firstName || !data.lastName || !data.email) {
throw new Error('Données utilisateur incomplètes');
}
};
// Fonction de transformation
const formatUserData = (data: User): FormattedUser => {
return {
...data,
fullName: `${data.firstName} ${data.lastName}`,
formattedJoinDate: new Date(data.joinDate).toLocaleDateString(),
isAdmin: data.roles.includes('admin')
};
};
// Composant d'affichage des données utilisateur
const UserInfo = ({ user }: { user: FormattedUser }) => (
<div className="user-info">
<p>Email: {user.email}</p>
<p>Membre depuis: {user.formattedJoinDate}</p>
{/* Plus d'informations utilisateur... */}
</div>
);
// Composant d'affichage de l'activité
const UserActivity = () => (
<div className="user-activity">
{/* Contenu de l'activité utilisateur... */}
</div>
);
// Composant principal
const UserProfile = ({ userId }: { userId: string }) => {
const { user, loading, error } = useUserData(userId);
const [activeTab, setActiveTab] = useState<'info' | 'activity'>('info');
if (loading) return <div>Chargement...</div>;
if (error) return <div>Erreur: {error.message}</div>;
if (!user) return <div>Aucun utilisateur trouvé</div>;
return (
<div className="profile-container">
<ProfileHeader user={user} />
<TabNavigation
activeTab={activeTab}
onTabChange={setActiveTab}
/>
{activeTab === 'info' && <UserInfo user={user} />}
{activeTab === 'activity' && <UserActivity />}
</div>
);
};
// Composant d'en-tête
const ProfileHeader = ({ user }: { user: FormattedUser }) => (
<header>
<h1>{user.fullName}</h1>
{user.isAdmin && <span className="admin-badge">Administrateur</span>}
</header>
);
// Composant de navigation par onglets
const TabNavigation = ({
activeTab,
onTabChange
}: {
activeTab: string;
onTabChange: (tab: 'info' | 'activity') => void
}) => (
<div className="tabs">
<button
className={activeTab === 'info' ? 'active' : ''}
onClick={() => onTabChange('info')}
>
Informations
</button>
<button
className={activeTab === 'activity' ? 'active' : ''}
onClick={() => onTabChange('activity')}
>
Activité
</button>
</div>
);
2. Faire une seule chose
Selon Uncle Bob, les fonctions devraient faire une seule chose, la faire bien, et ne faire que cette chose. Ce principe s'aligne parfaitement avec la philosophie React des composants à responsabilité unique.
Comment déterminer si une fonction fait une seule chose
Une méthode pratique pour vérifier si votre fonction respecte ce principe : si vous pouvez extraire une autre fonction avec un nom qui n'est pas simplement une reformulation de sa mise en œuvre, c'est que votre fonction fait probablement plus d'une chose.
Organisation horaire pour l'audit de fonctions :
- 30 minutes : Identifiez toutes les fonctions longues dans votre codebase
- 1 heure : Analysez une fonction complexe et listez ses différentes responsabilités
- 2 heures : Refactorisez cette fonction en plusieurs fonctions à responsabilité unique
- 30 minutes : Vérifiez que le comportement reste identique par des tests
3. Arguments des fonctions
Clean Code recommande de limiter le nombre d'arguments à 2, maximum 3. Au-delà, la lisibilité et la testabilité diminuent considérablement. Dans le monde React/TypeScript, on peut appliquer ce principe efficacement grâce aux objets de propriétés typés.
Les objets de paramètres en TypeScript
TypeScript vous permet de créer des interfaces pour typer les objets de paramètres, améliorant ainsi la clarté et l'auto-documentation de vos fonctions tout en réduisant le nombre d'arguments apparents.
Transformation des arguments en objet typé
// AVANT: Trop d'arguments
const createUser = (
firstName: string,
lastName: string,
email: string,
age: number,
address: string,
city: string,
country: string,
isAdmin: boolean
): User => {
// Implémentation...
};
// Utilisation difficile à lire
createUser('John', 'Doe', 'john@example.com', 30, '123 Main St', 'New York', 'USA', false);
// APRÈS: Utilisation d'un objet typé
interface UserCreationParams {
firstName: string;
lastName: string;
email: string;
age: number;
address: {
street: string;
city: string;
country: string;
};
isAdmin?: boolean; // Paramètre optionnel
}
const createUser = (params: UserCreationParams): User => {
// Implémentation...
};
// Utilisation claire et lisible
createUser({
firstName: 'John',
lastName: 'Doe',
email: 'john@example.com',
age: 30,
address: {
street: '123 Main St',
city: 'New York',
country: 'USA'
},
isAdmin: false
});
4. Fonctions pures et effets secondaires
Une fonction pure n'a pas d'effets secondaires et renvoie toujours le même résultat pour les mêmes arguments. Dans React, les fonctions pures sont particulièrement importantes pour la prévisibilité et la testabilité des composants.
Identifier les effets secondaires cachés
Les effets secondaires cachés sont l'une des principales sources de bugs. En React, utilisez useEffect pour isoler et rendre explicites ces effets. Prévoyez 1 heure par semaine pour auditer vos hooks et identifier les effets secondaires non désirés.
Fonctions pures vs fonctions avec effets secondaires
// Fonction impure avec effet secondaire caché
let globalCounter = 0;
const incrementAndFormat = (value: number): string => {
globalCounter++; // Effet secondaire caché!
return `Valeur: ${value + 1}`;
};
// Fonction pure
const formatIncrementedValue = (value: number): string => {
return `Valeur: ${value + 1}`;
};
// En React, isolez les effets secondaires avec useEffect
const CounterComponent = () => {
const [counter, setCounter] = useState(0);
// Effet secondaire isolé et explicite
useEffect(() => {
document.title = `Compteur: ${counter}`;
// Ce side effect est maintenant explicite et isolé
}, [counter]);
// Fonction pure pour le formatage
const getFormattedCount = (): string => {
return `Le compteur est à ${counter}`;
};
return (
<div>
<p>{getFormattedCount()}</p>
<button onClick={() => setCounter(c => c + 1)}>
Incrémenter
</button>
</div>
);
};
5. Les fonctions utilitaires en TypeScript
TypeScript permet de créer des fonctions utilitaires puissantes qui sont fortement typées. Ces fonctions peuvent grandement améliorer la maintenabilité et la réutilisabilité de votre code.
Planification pour créer une bibliothèque d'utilitaires
Consacrez 3 heures par semaine pendant un mois pour bâtir une bibliothèque de fonctions utilitaires réutilisables et bien testées. La rentabilité de cet investissement sera évidente à long terme.
Fonctions utilitaires typées réutilisables
// Bibliothèque d'utilitaires fortement typés
// utils/string.ts
export const capitalize = (str: string): string => {
if (!str) return '';
return str.charAt(0).toUpperCase() + str.slice(1);
};
export const truncate = (str: string, length: number): string => {
if (!str) return '';
return str.length > length ? `${str.substring(0, length)}...` : str;
};
// utils/array.ts
export const groupBy = <T>(
array: T[],
keySelector: (item: T) => string
): Record<string, T[]> => {
return array.reduce((acc, item) => {
const key = keySelector(item);
if (!acc[key]) {
acc[key] = [];
}
acc[key].push(item);
return acc;
}, {} as Record<string, T[]>);
};
// utils/validation.ts
export const isValidEmail = (email: string): boolean => {
const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return regex.test(email);
};
// Utilisation dans un composant
import { capitalize, truncate } from '../utils/string';
import { isValidEmail } from '../utils/validation';
const UserCard = ({ user }: { user: User }) => {
const displayName = capitalize(user.name);
const bio = truncate(user.bio, 100);
const hasValidEmail = isValidEmail(user.email);
return (
<div className="user-card">
<h2>{displayName}</h2>
<p>{bio}</p>
{!hasValidEmail && (
<span className="error">Email invalide</span>
)}
</div>
);
};
À Retenir
- Fonctions courtes : Limitez vos fonctions à 20 lignes maximum pour améliorer la lisibilité et la maintenabilité.
- Responsabilité unique : Chaque fonction doit faire une seule chose, ce qui s'aligne parfaitement avec la philosophie des composants React.
- Arguments limités : Utilisez les interfaces TypeScript pour créer des objets de paramètres bien typés et réduire le nombre d'arguments.
- Fonctions pures : Privilégiez les fonctions pures et isolez les effets secondaires dans des hooks useEffect explicites.
- Utilitaires réutilisables : Investissez du temps dans la création d'une bibliothèque de fonctions utilitaires typées qui améliorera la productivité de toute l'équipe.