J'ai deux tableaux comme celui-ci:
array(
'11' => '11',
'22' => '22',
'33' => '33',
'44' => '44'
);
array(
'44' => '44',
'55' => '55',
'66' => '66',
'77' => '77'
);
Je veux combiner ces deux tableaux pour qu’ils ne contiennent pas de doublons et conservent leurs clés originales. Par exemple, la sortie devrait être:
array(
'11' => '11',
'22' => '22',
'33' => '33',
'44' => '44',
'55' => '55',
'66' => '66',
'77' => '77'
);
J'ai essayé cela mais cela change leurs clés d'origine:
$output = array_unique( array_merge( $array1 , $array2 ) );
Toute solution?
Il suffit d'utiliser:
$output = array_merge($array1, $array2);
Cela devrait le résoudre. Parce que vous utilisez des clés de chaîne si une clé apparaît plusieurs fois (comme '44'
dans votre exemple), une clé écrasera les clés précédentes portant le même nom. Parce que dans votre cas, ils ont tous deux la même valeur, de toute façon, cela n'a pas d'importance et cela supprimera également les doublons.
Mise à jour: Je viens de me rendre compte que PHP traite les clés numériques des chaînes comme des nombres (entiers) et se comportera ainsi, ce qui signifie qu'il renumérote aussi les clés ...
Une solution de contournement consiste à recréer les clés.
$output = array_combine($output, $output);
Update 2: J'oublie toujours qu'il y a aussi un opérateur (en gras, parce que c'est vraiment ce que vous recherchez!: D)
$output = $array1 + $array2;
Vous devriez prendre en considération que $array1 + $array2 != $array2 + $array1
$array1 = array(
'11' => 'x1',
'22' => 'x1'
);
$array2 = array(
'22' => 'x2',
'33' => 'x2'
);
avec $ array1 + $ array2
$array1 + $array2 = array(
'11' => 'x1',
'22' => 'x1',
'33' => 'x2'
);
et avec $ array2 + $ array1
$array2 + $array1 = array(
'11' => 'x1',
'22' => 'x2',
'33' => 'x2'
);
Cela marche:
$output = $array1 + $array2;
Pour ce faire, vous pouvez parcourir l'un et ajouter à l'autre:
<?php
$test1 = array(
'11' => '11',
'22' => '22',
'33' => '33',
'44' => '44'
);
$test2 = array(
'44' => '44',
'55' => '55',
'66' => '66',
'77' => '77'
);
function combineWithKeys($array1, $array2)
{
foreach($array1 as $key=>$value) $array2[$key] = $value;
asort($array2);
return $array2;
}
print_r(combineWithKeys($test1, $test2));
?>
UPDATE: KingCrunch a proposé la meilleure solution : print_r($array1+$array2);
Cela marche:
$a = array(1 => 1, 2 => 2, 3 => 3);
$b = array(4 => 4, 5 => 5, 6 => 6);
$c = $a + $b;
print_r($c);
Si vous utilisez PHP 7.4 ou une version ultérieure, vous pouvez utiliser l'opérateur de propagation ...
comme exemple suivant à partir de la documentation PHP:
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; //[1, 2, 3]
$arr3 = [0, ...$arr1]; //[0, 1, 2, 3]
$arr4 = array(...$arr1, ...$arr2, 111); //[1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; //[1, 2, 3, 1, 2, 3]
function getArr() {
return ['a', 'b'];
}
$arr6 = [...getArr(), 'c']; //['a', 'b', 'c']
$arr7 = [...new ArrayIterator(['a', 'b', 'c'])]; //['a', 'b', 'c']
function arrGen() {
for($i = 11; $i < 15; $i++) {
yield $i;
}
}
$arr8 = [...arrGen()]; //[11, 12, 13, 14]
Cela fonctionne comme dans JavaScript ES6.
Voir plus sur https://wiki.php.net/rfc/spread_operator_for_array .
https://www.php.net/manual/en/function.array-merge.php
<?php
$array1 = array("color" => "red", 2, 4);
$array2 = array("a", "b", "color" => "green", "shape" => "trapezoid", 4);
$result = array_merge($array1, $array2);
print_r($result);
?>
Attention! $ array1 + $ array2 écrase les clés, donc ma solution (pour les tableaux multidimensionnels) consiste à utiliser array_unique ()
array_unique(array_merge($a, $b), SORT_REGULAR);
Avis:
5.2.10+ Changement de la valeur par défaut de
sort_flags
en SORT_STRING.5.2.9 La valeur par défaut est SORT_REGULAR.
5.2.8- La valeur par défaut est SORT_STRING
Cela fonctionne parfaitement . J'espère que ça aide même.