(PHP 4 >= 4.0.6, PHP 5, PHP 7, PHP 8)
array_map — Applique une fonction sur les éléments d'un tableau
Description
array_map(?callable
$callback, array
$array, array
...$arrays): array
Liste de paramètres
-
callback
-
La fonction de rappel de type callable à exécuter
pour chaque élément de chaque tableau.
null peut être passé comme valeur à callback
pour exécuter une opération zip sur plusieurs tableaux.
Si seulement array est fourni,
array_map() retournera le tableau d'entrée.
-
array
-
Un tableau à exécuter via la fonction de rappel callback.
-
arrays
-
Liste variable d'arguments tableaux supplémentaires à exécuter via
la fonction de rappel callback.
Valeurs de retour
Retourne un tableau contenant les résultats de l'application de la fonction
de rappel callback à la valeur correspondant de
array (et arrays si plus de
tableaux sont fourni) utilisé en tant qu'arguments pour la fonction de rappel.
Le tableau retourné conservera les clés du tableau passé en argument,
si et seulement si, un seul tableau est passé. Si plusieurs tableaux
sont passés comme argument, le tableau retourné aura des clés séquentielles
sous la forme d'entier.
Historique
Exemples
Exemple #1 Exemple avec array_map()
<?php
function cube($n)
{
return ($n * $n * $n);
}
$a = [1, 2, 3, 4, 5];
$b = array_map('cube', $a);
print_r($b);
?>
Le contenu de la variable $b sera :
Array
(
[0] => 1
[1] => 8
[2] => 27
[3] => 64
[4] => 125
)
Exemple #2 array_map() utilisant une fonction quelconque
<?php
$func = function(int $value): int {
return $value * 2;
};
print_r(array_map($func, range(1, 5)));
// Ou à partir de PHP 7.4.0 :
print_r(array_map(fn($value): int => $value * 2, range(1, 5)));
?>
Array
(
[0] => 2
[1] => 4
[2] => 6
[3] => 8
[4] => 10
)
Exemple #3 array_map() : utilisation de plusieurs tableaux
<?php
function show_Spanish(int $n, string $m): string
{
return "Le nombre {$n} se dit {$m} en Espagnol";
}
function map_Spanish(int $n, string $m): array
{
return [$n => $m];
}
$a = [1, 2, 3, 4, 5];
$b = ['uno', 'dos', 'tres', 'cuatro', 'cinco'];
$c = array_map('show_Spanish', $a, $b);
print_r($c);
$d = array_map('map_Spanish', $a , $b);
print_r($d);
?>
L'exemple ci-dessus va afficher :
// Contenu de $c
Array
(
[0] => Le nombre 1 se dit uno en Espagnol
[1] => Le nombre 2 se dit dos en Espagnol
[2] => Le nombre 3 se dit tres en Espagnol
[3] => Le nombre 4 se dit cuatro en Espagnol
[4] => Le nombre 5 se dit cinco en Espagnol
)
// Contenu de $d
Array
(
[0] => Array
(
[1] => uno
)
[1] => Array
(
[2] => dos
)
[2] => Array
(
[3] => tres
)
[3] => Array
(
[4] => cuatro
)
[4] => Array
(
[5] => cinco
)
)
Généralement, lors de l'utilisation de plusieurs tableaux, ils doivent
être d'égale longueur, car la fonction de rappel est appliquée de manière
similaire à tous les tableaux. Si les tableaux sont de tailles inégales,
les plus petits seront complétés avec des éléments vides pour atteindre
la taille du plus grand.
Une utilisation intéressante de cette fonction est la construction
de tableaux de tableaux, facilement réalisée en passant la valeur
null comme nom de fonction de rappel.
Exemple #4 Exécution d'une opération zip de tableaux
<?php
$a = [1, 2, 3, 4, 5];
$b = ['one', 'two', 'three', 'four', 'five'];
$c = ['uno', 'dos', 'tres', 'cuatro', 'cinco'];
$d = array_map(null, $a, $b, $c);
print_r($d);
?>
L'exemple ci-dessus va afficher :
Array
(
[0] => Array
(
[0] => 1
[1] => one
[2] => uno
)
[1] => Array
(
[0] => 2
[1] => two
[2] => dos
)
[2] => Array
(
[0] => 3
[1] => three
[2] => tres
)
[3] => Array
(
[0] => 4
[1] => four
[2] => cuatro
)
[4] => Array
(
[0] => 5
[1] => five
[2] => cinco
)
)
Exemple #5
null callback avec seulement
array
<?php
$array = [1, 2, 3];
var_dump(array_map(null, $array));
?>
L'exemple ci-dessus va afficher :
array(3) {
[0]=>
int(1)
[1]=>
int(2)
[2]=>
int(3)
}
Exemple #6
array_map() - avec des clés sous la forme de chaîne de caractères
<?php
$arr = ['stringkey' => 'value'];
function cb1($a) {
return [$a];
}
function cb2($a, $b) {
return [$a, $b];
}
var_dump(array_map('cb1', $arr));
var_dump(array_map('cb2', $arr, $arr));
var_dump(array_map(null, $arr));
var_dump(array_map(null, $arr, $arr));
?>
L'exemple ci-dessus va afficher :
array(1) {
["stringkey"]=>
array(1) {
[0]=>
string(5) "value"
}
}
array(1) {
[0]=>
array(2) {
[0]=>
string(5) "value"
[1]=>
string(5) "value"
}
}
array(1) {
["stringkey"]=>
string(5) "value"
}
array(1) {
[0]=>
array(2) {
[0]=>
string(5) "value"
[1]=>
string(5) "value"
}
}
Exemple #7 array_map() - tableaux associatifs
Même si array_map() ne supporte pas directement
l'utilisation des clés d'un tableau comme entrée, ceci peut être simulé
en utilisant array_keys().
<?php
$arr = [
'v1' => 'First release',
'v2' => 'Second release',
'v3' => 'Third release',
];
// Note: Antérieur à 7.4.0, il faut utiliser la syntaxe plus longue pour les
// fonctions anonymes à la place.
$callback = fn(string $k, string $v): string => "$k was the $v";
$result = array_map($callback, array_keys($arr), array_values($arr));
var_dump($result);
?>
L'exemple ci-dessus va afficher :
array(3) {
[0]=>
string(24) "v1 was the First release"
[1]=>
string(25) "v2 was the Second release"
[2]=>
string(24) "v3 was the Third release"
}
Voir aussi
- array_filter() - Filtre les éléments d'un tableau grâce à une fonction de rappel
- array_reduce() - Réduit itérativement un tableau
- array_walk() - Exécute une fonction fournie par l'utilisateur sur chacun des éléments d'un tableau