L’opérateur + sur les tableaux en PHP

Dans cet article nous allons nous pencher sur l’opérateur + et sur son action sur les tableaux en PHP.

Dans le cas des tableaux, le + représentera une union et non pas une addition aveugle de deux tableaux.

Prenons le cas le plus simple, l’union de tableaux associatifs:

1
2
3
4
5
6
7
8
9
10
11
<?php
$array1 = array(
    'cle1' => 'bleu',
    'cle2' => 'blanc',
);
 
$array2 = array(
    'cle3' => 'rouge',
);
 
print_r($array1 + $array2);

Le résultat de ce code :

Array
(
    [cle1] => bleu
    [cle2] => blanc
    [cle3] => rouge
)

Jusque là, aucun problème, les deux tableaux ont fusionné et le tableau $array2 a été ajouté à la suite de $array1. Prenons maintenant un premier cas particulier : les deux tableaux ont une clé en commun :

1
2
3
4
5
6
7
8
9
10
11
<?php
$array1 = array(
    'cle1' => 'bleu',
    'cle2' => 'blanc',
);
 
$array2 = array(
    'cle1' => 'rouge',
);
 
print_r($array1 + $array2);

Le résultat :

Array
(
    [cle1] => bleu
    [cle2] => blanc
)

On voir très nettement le comportement de l’union de deux tableaux : en cas de clés communes, c’est le tableau de gauche qui prend le pas sur le tableau de droite. Nous allons désormais passer à une partie plus intéressante : le cas de tableaux à clés numériques.

Prenons ce cas :

1
2
3
4
5
6
7
8
9
10
11
<?php
$array1 = array(
    'bleu',
    'blanc',
);
 
$array2 = array(
    'rouge',
);
 
print_r($array1 + $array2);

Le résultat :

Array
(
    [0] => bleu
    [1] => blanc
)

Ici le résultat peut paraître surprenant. En effet beaucoup s’attendent à voir ceci :

Array
(
    [0] => bleu
    [1] => blanc
    [2] => rouge
)

Pourtant c’est tout à fait logique. Nos tableaux de départ sont équivalent à ceci :

1
2
3
4
5
6
7
8
$array1 = array(
    0 => 'bleu',
    1 => 'blanc',
);
 
$array2 = array(
   0 =>  'rouge',
);

On a donc 2 clés identiques (la clé 0) donc PHP va écraser une des clés en donnant priorité au tableau de gauche… et ceci même pour des clés numériques ! PHP va donc traiter l’union des tableaux à clés numériques et tableaux associatifs de la même façon. Cela va en fait même plus loin que l’union. Voyons les exemples suivants :

1
2
3
4
5
6
7
8
9
10
11
<?php
$array1 = array(
    1 => 'bleu',
    2 => 'blanc',
);
 
$array2 = array(
    0 =>'rouge',
);
 
print_r($array1 + $array2);

ici on s’attendrait à ce résultat :

Array
(
    [0] => rouge
    [1] => bleu
    [2] => blanc
)

pourtant, voici ce qui est affiché :

Array
(
    [1] => bleu
    [2] => blanc
    [0] => rouge
)

Encore mieux :

1
2
3
4
5
6
7
<?php
$array1 = array();
$array1[1] = 'bleu';
$array1[2] = 'blanc';
$array1[0] = 'rouge';
 
print_r($array1);

On obtient le même résultat que vu plus haut :

Array
(
    [1] => bleu
    [2] => blanc
    [0] => rouge
)

La première fois que j’ai rencontré ce problème, j’avoue être resté un peu bête. Je ne comprenais pas ce qui s’était passé. En cherchant sur le web, j’ai finis par trouver la réponse: en fait PHP utilise un pointeur interne pour stocker les tableaux et non pas les clés que nous allons utiliser, même pour les clés numériques. Mieux, même en cas de clés numériques, PHP va les enregistrer comme des valeurs associatives. Forcément dans ce cas, PHP va enregistrer les différents éléments du tableau dans l’ordre d’affectation, quelque soit leur clé.

Malgré tout, PHP va tout de même avoir des comportements différents selon que l’on utilise des clés numériques ou des clés associatives :

1
2
3
4
5
6
7
8
9
<?php
$array1 = array(
    'cle1' => 'bleu',
    'cle2' => 'blanc',
);
 
$array1[] = 'rouge';
 
print_r($array1);

donnera :

Array
(
    [cle1] => bleu
    [cle2] => blanc
    [0] => rouge
)

alors que :

1
2
3
4
5
6
7
8
9
<?php
$array1 = array(
    4 => 'bleu',
    42 => 'blanc',
);
 
$array1[] = 'rouge';
 
print_r($array1);

donnera :

Array
(
    [4] => bleu
    [42] => blanc
    [43] => rouge
)

On voit que dans ce cas PHP va chercher sa clé numérique la plus haute pour l’incrémenter. Dans le premier exemple il n’y en a pas, donc il part de 0, dans le deuxième il va donc utiliser la clé 43.

Quelques fonctions PHP de fusion de tableau:

array_replace()

Comme lu dans les commentaires de la documentation de PHP, cette fonction est identique à l’union + sauf que la priorité des tableaux est inversée:

1
2
3
4
5
6
7
8
9
10
$array1 = array(
    4 => 'bleu',
    42 => 'blanc',
);
 
$array2 = array(
    42 => 'rouge',
);
 
print_r(array_replace($array1, $array2));

donnera :

Array
(
    [4] => bleu
    [42] => rouge
)

Ceux qui recherchent l’optimisation préfèreront utiliser l’opérateur + en inversant l’ordre des tableaux, ce dernier étant un peu plus rapide à l’exécution d’après certains (j’ai pas fais de tests :))

array_merge()

Cette fonction va fusionner plusieurs tableaux en donnant priorité à la dernière valeur rencontrée en cas de clés identiques (donc priorité au tableau de droite). Sauf que cela n’est valable que dans le cas d’un tableau associatif. Dans le cas de clés numériques, array_merge va renuméroter les index de clés en partant de 0 :

1
2
3
4
5
6
7
8
9
10
$array1 = array(
    4 => 'bleu',
    42 => 'blanc',
);
 
$array2 = array(
    42 => 'rouge',
);
 
print_r(array_merge($array1, $array2));

donnera :

Array
(
    [0] => bleu
    [1] => blanc
    [2] => rouge
)

Attention donc : si l’association de clés / valeurs a une importance dans votre tableau, à ne pas utiliser avec des clés numériques dans ce cas, sinon c’est la cata 🙂

Mots-clefs : , , , ,



Laisser une réponse

Vous devez être connecté pour publier un commentaire.