Comment simuler et vérifier les différentes situations d'entrée et de sortie de la fonction Array_Diff () dans un environnement de test?

M66 2025-06-06

Dans PHP, Array_Diff () est une fonction très pratique pour comparer l'ensemble de différence de tableaux et de valeurs de retour qui existent dans le premier tableau mais pas dans d'autres tableaux. Afin de s'assurer que le code fonctionne correctement dans divers scénarios, il nous est nécessaire de simuler et de vérifier les différentes conditions d'entrée et de sortie de Array_Diff () dans l'environnement de test. Cet article vous mènera étape par étape pour comprendre comment effectuer efficacement ces tests.

1. Fonction Introduction

Le prototype de fonction de array_diff () est le suivant:

 array array_diff(array $array, array ...$arrays)

Cette fonction renverra un tableau contenant toutes les valeurs dans des tableaux $ qui n'apparaissent pas dans d'autres tableaux $ (comparez uniquement les valeurs, pas les noms de clés).

Exemple:

 $a = ['apple', 'banana', 'cherry'];
$b = ['banana', 'grape'];
$result = array_diff($a, $b);
// Sortir：['apple', 'cherry']

2. Pourquoi le tester?

Même si Array_Diff () est une fonction intégrée, cela ne signifie pas que vous pouvez compter entièrement sur son comportement. Dans le développement réel, nous passons souvent dans diverses structures complexes, telles que des tableaux avec des noms clés, des tableaux multidimensionnels, des valeurs de type mixte, etc., afin que les tests puissent nous aider:

Évitez les erreurs de type
Comprendre les limites du comportement de la fonction
Vérifiez que la logique métier dépend d'un comportement spécifique

3. Préparez-vous à l'environnement de test

Vous pouvez utiliser les deux méthodes suivantes pour créer un environnement de test:

1. Environnement de développement local (PHP> = 7,4 est recommandé)

Vous pouvez rapidement le construire avec les outils suivants:

XAMPP ou MAMP
Serveur intégré PHP:

 php -S localhost:8000

2. Plateforme de test en ligne

Par exemple, exécutez des extraits de code sur https://sandbox.m66.net/php-test pour vérifier rapidement la logique.

4. Simuler plusieurs situations de test

Nous testons un par un des cas d'utilisation les plus courants aux cas de limite.

1. Comparaison simple de cordes

 $a = ['red', 'green', 'blue'];
$b = ['green', 'yellow'];
$result = array_diff($a, $b);
print_r($result);
// 预期Sortir：['red', 'blue']

2. Comparez les tableaux avec les noms clés

 $a = ['a' => 'apple', 'b' => 'banana'];
$b = ['x' => 'banana'];
$result = array_diff($a, $b);
print_r($result);
// 预期Sortir：['a' => 'apple']，Veuillez garder le nom de la clé d&#39;origine

3. Mélanger les valeurs avec les chaînes

 $a = [1, '2', 3];
$b = ['1', 2];
$result = array_diff($a, $b);
print_r($result);
// Sortir：peut être [0 => 1, 2 => 3]，Parce que lors de la comparaison, c&#39;est un type non strict

4. Plusieurs entrées de tableau

 $a = ['php', 'js', 'python'];
$b = ['js'];
$c = ['python'];
$result = array_diff($a, $b, $c);
print_r($result);
// Sortir：['php']

5. Test de tableau vide

 $a = [];
$b = ['x', 'y'];
$result = array_diff($a, $b);
print_r($result);
// Sortir：Tableau vide []

6. tableau avec des valeurs en double

 $a = ['apple', 'banana', 'apple'];
$b = ['banana'];
$result = array_diff($a, $b);
print_r($result);
// Sortir：['apple', 'apple']

5. Écrivez des tests automatisés (en utilisant phpunit)

Vous pouvez utiliser PHPUnit pour écrire des méthodes de test pour vérifier automatiquement le comportement:

 use PHPUnit\Framework\TestCase;

class ArrayDiffTest extends TestCase
{
    public function testStringDiff()
    {
        $a = ['a', 'b', 'c'];
        $b = ['b'];
        $this->assertEquals(['a', 'c'], array_values(array_diff($a, $b)));
    }

    public function testMixedTypes()
    {
        $a = [1, '2', 3];
        $b = ['1', 2];
        $expected = [0 => 1, 2 => 3];
        $this->assertEquals($expected, array_diff($a, $b));
    }

    public function testEmptyArray()
    {
        $a = [];
        $b = ['x'];
        $this->assertEmpty(array_diff($a, $b));
    }
}

6. Résumé

En se moquant de divers types d'entrées dans un environnement de test, nous pouvons avoir une compréhension approfondie de ce que Array_Diff () se comporte. Ce processus de test proactif peut non seulement aider à identifier les problèmes potentiels, mais également aider à rédiger un code plus robuste. En particulier dans les projets à grande échelle, la structure de données stable et les capacités de traitement différentiel fiables sont la base de la logique telle que la comparaison des données et le dépistage.

N'oubliez pas: le test n'est jamais une perte de temps, mais fait gagner du temps futur.

array_diff

Connexe