Les fonctions de tableau PHP : le couteau suisse du développeur 🛠️

25 septembre 2024

3 mins de lecture

PHP

Les fonctions de tableau PHP : le couteau suisse du développeur 🛠️

Tu passes encore ton temps à écrire des boucles foreach ? Stop ! PHP possède une collection impressionnante de fonctions de tableau qui vont révolutionner ta façon de coder.

Plongeons dans les plus utiles !

Les 3 mousquetaires : map, filter et reduce 🤺

array_map() : transformer chaque élément

$users = [
    ['name' => 'Alice', 'age' => 25],
    ['name' => 'Bob', 'age' => 30],
];

// ❌ Avant (avec foreach)
$names = [];
foreach ($users as $user) {
    $names[] = $user['name'];
}

// ✅ Après (avec array_map)
$names = array_map(fn($user) => $user['name'], $users);
// Résultat : ['Alice', 'Bob']

array_filter() : filtrer les éléments

$numbers = array( 1, 2, 3, 4, 5, 6 );

// ❌ Avant (avec foreach)
$evenNumbers = array();
foreach ( $numbers as $number ) {
	if ( $number % 2 === 0 ) {
		$evenNumbers[] = $number;
	}
}
// résultat : [2, 4, 6]

// ✅ Après (avec array_filter)
$evenNumbers = array_filter(
	$numbers,
	fn( $n ) => $n % 2 === 0
);
// Résultat : [2, 4, 6]

array_reduce() : accumuler des valeurs

$cart = array(
	array(
		'product' => 'Laptop',
		'price'   => 999,
	),
	array(
		'product' => 'Mouse',
		'price'   => 29,
	),
);

// ❌ Avant (avec foreach)
$total = 0;
foreach ( $cart as $item ) {
	$total += $item['price'];
}
// Résultat : 1028

// ✅ Après (avec array_reduce)
$total = array_reduce(
	$cart,
	fn( $sum, $item ) => $sum + $item['price'],
	0
);
// Résultat : 1028

Les fonctions utilitaires indispensables 🔧

array_column() : extraire une colonne

$users = array(
	array(
		'id'   => 1,
		'name' => 'Alice',
		'role' => 'admin',
	),
	array(
		'id'   => 2,
		'name' => 'Bob',
		'role' => 'user',
	),
);

// ❌ Avant (avec foreach)
$names = array();
foreach ( $users as $user ) {
	if ( $user['role'] === 'admin' ) {
		$names[] = $user['name'];
	}
}
// Résultat : ['Alice', 'Bob']

// ✅ Après (avec array_column)
// Extraire tous les noms
$names = array_column( $users, 'name' );
// Résultat : ['Alice', 'Bob']


// ❌ Avant (avec foreach)
$usersByIds = array();
foreach ( $users as $user ) {
	$usersByIds[ $user['id'] ] = $user;
}
// Résultat : [1 => ['id' => 1, ...], 2 => ['id' => 2, ...]]

// ✅ Après (avec array_column)
$usersByIds = array_column( $users, null, 'id' );
// Résultat : [1 => ['id' => 1, ...], 2 => ['id' => 2, ...]]

array_chunk() : découper un tableau

$items = array( 1, 2, 3, 4, 5, 6, 7 );

// ❌ Avant (avec foreach)
$chunks = array();

foreach ( $items as $item ) {
	if ( count( $chunks ) === 0 || count( $chunks[ count( $chunks ) - 1 ] ) === 3 ) {
		$chunks[] = array();
	}
	$chunks[ count( $chunks ) - 1 ][] = $item;
}
// Résultat : [[1, 2, 3], [4, 5, 6], [7]]


// ✅ Après (avec array_chunk)
$chunks = array_chunk( $items, 3 );
// Résultat : [[1, 2, 3], [4, 5, 6], [7]]

Combinaisons puissantes 💪

La vraie magie opère quand on combine ces fonctions :

$users = array(
	array(
		'name'   => 'Alice',
		'age'    => 25,
		'active' => true,
	),
	array(
		'name'   => 'Bob',
		'age'    => 30,
		'active' => false,
	),
	array(
		'name'   => 'Charlie',
		'age'    => 35,
		'active' => true,
	),
);

// Obtenir la moyenne d'âge des utilisateurs actifs
$averageAge = array_reduce(
	array_filter( $users, fn( $user ) => $user['active'] ),
	fn( $sum, $user ) => $sum + $user['age'],
	0
) / count( array_filter( $users, fn( $user ) => $user['active'] ) );

// Résultat : 30

// Obtenir un tableau name => age pour les utilisateurs actifs
$activeUsersAges = array_column(
	array_filter( $users, fn( $user ) => $user['active'] ),
	'age',
	'name'
);

// Résultat : ['Alice' => 25, 'Charlie' => 35]

Pourquoi utiliser ces fonctions ? 🤔

Code plus propre : Moins de variables temporaires
Plus lisible : L’intention du code est claire
Moins de bugs : Moins de logique manuelle = moins d’erreurs
Performance : Ces fonctions sont optimisées en interne
Immutabilité : Les données originales ne sont pas modifiées

Pro Tips 🎯

Utilise les arrow functions (PHP 7.4+) pour des callbacks plus concis
Combine les fonctions pour des manipulations complexes
N’oublie pas que ces fonctions créent de nouveaux tableaux (important pour la mémoire)
Préfère array_column() à array_map() quand tu veux juste extraire une colonne

Pour aller plus loin 🚀

D’autres fonctions utiles à explorer :

array_merge()
array_unique()
array_intersect()
array_diff()
array_keys() et array_values()

La prochaine fois que tu t’apprêtes à écrire une boucle foreach, demande-toi si une de ces fonctions ne pourrait pas faire le travail plus élégamment !