Fusionner Deux Tableaux en PHP – Exercices corrigés

La fusion de deux tableaux est une opération courante en programmation, et elle est souvent utilisée pour combiner des données provenant de différentes sources. En PHP, fusionner deux tableaux peut être réalisé de plusieurs façons, en fonction des besoins spécifiques de l’application. Dans cet article, nous explorerons différentes méthodes pour fusionner deux tableaux en PHP, et nous fournirons des exemples détaillés avec des exercices corrigés pour illustrer chaque approche.

Méthode 1 : Utilisation de la fonction array_merge()

La fonction array_merge() est l’une des méthodes les plus simples pour fusionner deux tableaux en PHP. Elle prend deux ou plusieurs tableaux en entrée et retourne un nouveau tableau contenant tous les éléments des tableaux d’entrée.

Exemple d’utilisation de la fonction array_merge() :

<?php
$array1 = array("a", "b", "c");
$array2 = array(1, 2, 3);
$result = array_merge($array1, $array2);
print_r($result);
?>

Résultat :

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => 1
    [4] => 2
    [5] => 3
)

Exercice 1 :
Fusionnez les deux tableaux suivants en utilisant la fonction array_merge() :

$array1 = array("apple", "banana", "orange");
$array2 = array("pear", "grape", "kiwi");

Correction de l’exercice 1 :

<?php
$array1 = array("apple", "banana", "orange");
$array2 = array("pear", "grape", "kiwi");
$result = array_merge($array1, $array2);
print_r($result);
?>

Résultat :

Array
(
    [0] => apple
    [1] => banana
    [2] => orange
    [3] => pear
    [4] => grape
    [5] => kiwi
)

Méthode 2 : Utilisation de l’opérateur de fusion (PHP 7.4 et versions ultérieures)

À partir de PHP 7.4, l’opérateur de fusion (??) peut être utilisé pour fusionner deux tableaux. Cet opérateur renvoie le premier opérande s’il n’est pas null, sinon il renvoie le second opérande.

Exemple d’utilisation de l’opérateur de fusion :

<?php
$array1 = ["a" => 1, "b" => 2];
$array2 = ["b" => 3, "c" => 4];
$result = $array1 + $array2;
print_r($result);
?>

Résultat :

Array
(
    [a] => 1
    [b] => 2
    [c] => 4
)

Exercice 2 :
Fusionnez les deux tableaux suivants en utilisant l’opérateur de fusion :

$array1 = ["red" => "apple", "yellow" => "banana"];
$array2 = ["yellow" => "lemon", "green" => "lime"];

Correction de l’exercice 2 :

<?php
$array1 = ["red" => "apple", "yellow" => "banana"];
$array2 = ["yellow" => "lemon", "green" => "lime"];
$result = $array1 + $array2;
print_r($result);
?>

Résultat :

Array
(
    [red] => apple
    [yellow] => banana
    [green] => lime
)

Série d’exercices avancés sur la fusion de tableaux en PHP

Exercice 1 : Fusion de tableaux multidimensionnels
Créez deux tableaux multidimensionnels et fusionnez-les en utilisant la fonction array_merge_recursive().

2 : Fusion avec gestion des clés
Fusionnez deux tableaux en préservant les clés existantes et en combinant les valeurs des clés communes.

Exercice 3 : Fusion avec gestion des doublons
Fusionnez deux tableaux en éliminant les doublons et en conservant une seule occurrence de chaque valeur.

4 : Fusion personnalisée
Implémentez une fonction personnalisée pour fusionner deux tableaux en appliquant une logique de fusion spécifique, par exemple en concaténant les chaînes de caractères ou en additionnant les nombres.

Exercice 5 : Fusion récursive
Écrivez une fonction récursive pour fusionner deux tableaux de manière à ce que les tableaux imbriqués soient également fusionnés de manière récursive.

6 : Fusion avec tri
Fusionnez deux tableaux en les triant par ordre alphabétique ou numérique après la fusion.

Exercice 7 : Gestion des valeurs null
Fusionnez deux tableaux en remplaçant les valeurs null par les valeurs correspondantes du deuxième tableau, s’ils existent.

8 : Fusion avec gestion des clés manquantes
Fusionnez deux tableaux en ajoutant les clés manquantes du deuxième tableau au premier tableau.

Exercice 9 : Fusion avec validation
Écrivez une fonction de fusion qui vérifie si les types de données des valeurs sont compatibles avant de les fusionner.

10 : Fusion de grands ensembles de données
Générez deux grands ensembles de données aléatoires et mesurez les performances de différentes méthodes de fusion pour déterminer la plus efficace.

Ces exercices devraient vous aider à approfondir vos connaissances sur la fusion de tableaux en PHP et à développer vos compétences en résolution de problèmes.

Voici des solutions pour chaque exercice :

tableaux multidimensionnels

<?php
$array1 = array(
    "fruit" => array("apple", "banana"),
    "color" => "red"
);

$array2 = array(
    "fruit" => array("orange", "grape"),
    "color" => "green"
);

$result = array_merge_recursive($array1, $array2);
print_r($result);
?>

Fusion avec gestion des clés

<?php
$array1 = array("a" => 1, "b" => 2);
$array2 = array("b" => 3, "c" => 4);
$result = $array1 + $array2;
print_r($result);
?>

gestion des doublons

<?php
$array1 = array("a", "b", "c");
$array2 = array("b", "c", "d");
$result = array_unique(array_merge($array1, $array2));
print_r($result);
?>

Fusion personnalisée

<?php
function customMerge($arr1, $arr2) {
    $result = array();
    foreach($arr1 as $key => $value) {
        if (isset($arr2[$key])) {
            $result[$key] = $value . $arr2[$key];
        } else {
            $result[$key] = $value;
        }
    }
    return $result + $arr2;
}

$array1 = array("a" => "Hello", "b" => "World");
$array2 = array("b" => " PHP", "c" => "!");
$result = customMerge($array1, $array2);
print_r($result);
?>

Fusion récursive

<?php
function recursiveMerge($arr1, $arr2) {
    foreach ($arr2 as $key => $value) {
        if (is_array($value) && isset($arr1[$key]) && is_array($arr1[$key])) {
            $arr1[$key] = recursiveMerge($arr1[$key], $value);
        } else {
            $arr1[$key] = $value;
        }
    }
    return $arr1;
}

$array1 = array("a" => array("x" => 1, "y" => 2), "b" => 3);
$array2 = array("a" => array("y" => 3, "z" => 4), "c" => 5);
$result = recursiveMerge($array1, $array2);
print_r($result);
?>

Fusion avec tri

<?php
$array1 = array("banana", "apple", "orange");
$array2 = array("grape", "kiwi", "pineapple");
$result = array_merge($array1, $array2);
sort($result);
print_r($result);
?>

Gestion des valeurs null

<?php
$array1 = array("a" => 1, "b" => null, "c" => 3);
$array2 = array("b" => 2, "d" => 4);
foreach ($array2 as $key => $value) {
    if (is_null($array1[$key])) {
        $array1[$key] = $value;
    }
}
print_r($array1);
?>

Fusion avec gestion des clés manquantes

<?php
$array1 = array("a" => 1, "b" => 2);
$array2 = array("b" => 3, "c" => 4);
$result = array_merge($array1, array_diff_key($array2, $array1));
print_r($result);
?>

Fusion avec validation

<?php
function validatedMerge($arr1, $arr2) {
    $result = array();
    foreach ($arr1 as $key => $value) {
        if (isset($arr2[$key]) && gettype($value) === gettype($arr2[$key])) {
            $result[$key] = $value . $arr2[$key];
        } else {
            $result[$key] = $value;
        }
    }
    return $result + $arr2;
}

$array1 = array("a" => "Hello", "b" => "World");
$array2 = array("b" => " PHP", "c" => 2024);
$result = validatedMerge($array1, $array2);
print_r($result);
?>

Fusion de grands ensembles de données

<?php
// Génération de grands ensembles de données aléatoires
$array1 = array();
$array2 = array();
for ($i = 0; $i < 10000; $i++) {
    $array1[] = mt_rand(1, 10000);
    $array2[] = mt_rand(1, 10000);
}

// Mesure de performances
$start = microtime(true);
$result = array_merge($array1, $array2);
sort($result);
$end = microtime(true);
echo "Temps d'exécution avec array_merge et tri : " . ($end - $start) . " secondes\n";

$start = microtime(true);
$result = $array1 + $array2;
sort($result);
$end = microtime(true);
echo "Temps d'exécution avec l'opérateur de fusion et tri : " . ($end - $start) . " secondes\n";
?>

Ces solutions devraient vous aider à résoudre les exercices avancés sur la fusion de tableaux en PHP. N’hésitez pas à les tester et à les adapter selon vos besoins spécifiques.