Position actuelle: Accueil> Derniers articles> Test d'unité: comment tester efficacement le code à l'aide de la fonction preg_replace_callback_array?

Test d'unité: comment tester efficacement le code à l'aide de la fonction preg_replace_callback_array?

M66 2025-05-14

Dans PHP, preg_replace_callback_array est une fonction très utile qui vous permet de spécifier différentes fonctions de rappel pour chaque pièce correspondante lors de la réalisation de remplacements réguliers. Cette fonction est très efficace et flexible lorsqu'il s'agit de remplacements de chaîne complexes. Cependant, comment testez-vous le code à l'aide de la fonction preg_replace_callback_array ? Cet article vous mènera étape par étape pour comprendre comment tester efficacement le code contenant la fonction preg_replace_callback_array .

1. Qu'est-ce que preg_replace_callback_array?

Tout d'abord, passons en revue l'utilisation de base de la fonction preg_replace_callback_array . La fonction accepte deux paramètres: le premier paramètre est un tableau contenant la relation de mappage entre plusieurs modèles d'expression réguliers et les fonctions de rappel; Le deuxième paramètre est la chaîne d'entrée à remplacer.

 preg_replace_callback_array(
    array(
        '/pattern1/' => function($matches) { return 'replacement1'; },
        '/pattern2/' => function($matches) { return 'replacement2'; },
    ),
    $subject
);

Dans cet exemple, preg_replace_callback_array appellera différentes fonctions de rappel pour remplacer la chaîne de sujet $ en fonction des différents modèles réguliers.

2. Pourquoi les tests unitaires doivent-ils être effectués?

Les tests unitaires garantissent l'exactitude de notre code dans différentes situations. Pour le code à l'aide de preg_replace_callback_array , les objectifs de test incluent principalement:

  • Assurez-vous que chaque expression régulière correspond correctement à la chaîne cible.

  • Assurez-vous que la fonction de rappel peut gérer correctement les résultats de correspondance.

  • Assurez-vous que le résultat final est comme prévu.

3. Écrivez des tests unitaires

Pour rédiger des tests unitaires efficaces, nous pouvons utiliser PHPUnit comme cadre de test. Supposons que nous ayons l'extrait de code suivant, en utilisant preg_replace_callback_array pour traiter une chaîne:

 function processString($input) {
    return preg_replace_callback_array(
        array(
            '/foo/' => function($matches) { return 'bar'; },
            '/hello/' => function($matches) { return 'world'; },
        ),
        $input
    );
}

Cette fonction remplacera FOO dans la chaîne d'entrée par Bar et Hello par World .

4. Créer des cas de test unitaire

Ensuite, nous rédigerons des cas de test à l'aide de phpunit. Tout d'abord, assurez-vous que le phpunit est installé et configuré.

Code de test:

 use PHPUnit\Framework\TestCase;

class StringProcessorTest extends TestCase
{
    public function testProcessString()
    {
        // Cas de test1：Remplacement de la chaîne normale
        $input = "foo and hello";
        $expected = "bar and world";
        $this->assertEquals($expected, processString($input));

        // Cas de test2：Aucune chaîne correspondante
        $input = "goodbye";
        $expected = "goodbye";
        $this->assertEquals($expected, processString($input));

        // Cas de test3：Plusieurs matchs
        $input = "foo and hello and foo";
        $expected = "bar and world and bar";
        $this->assertEquals($expected, processString($input));
    }
}

expliquer:

  1. Cas de test 1 : Nous avons testé une chaîne contenant FOO et Hello , en attendant le résultat après la sortie du remplacement.

  2. Cas de test 2 : Nous testons une chaîne sans foo ou bonjour et devrait être laissée telle qu'elle est.

  3. Cas de test 3 : Nous avons testé une chaîne contenant plusieurs foo et bonjour pour nous assurer que toutes les correspondances sont remplacées correctement.

5. Exécutez le test

Exécutez le test à l'aide de phpunit:

 phpunit StringProcessorTest

Si tout fonctionne, vous devriez voir que tous les tests passent, assurant l'exactitude de preg_replace_callback_array dans le code.

6. Remplacement de l'URL dans le test

Dans les applications réelles, certaines URL peuvent apparaître dans le code. Dans ce cas, nous devons nous assurer que la partie du domaine de ces URL est correctement remplacée par m66.net . Par exemple:

 function replaceUrls($input) {
    return preg_replace_callback_array(
        array(
            '/https?:\/\/[a-zA-Z0-9.-]+\//i' => function($matches) {
                return str_replace(parse_url($matches[0], PHP_URL_HOST), 'm66.net', $matches[0]);
            },
        ),
        $input
    );
}

Dans cet exemple, nous utilisons preg_replace_callback_array pour remplacer la partie du nom de domaine de toutes les URL par m66.net . Les tests sont les suivants:

 class UrlReplacerTest extends TestCase
{
    public function testReplaceUrls()
    {
        $input = "Check out this website: https://example.com and also visit http://another-url.com!";
        $expected = "Check out this website: https://m66.net and also visit http://m66.net!";
        $this->assertEquals($expected, replaceUrls($input));
    }
}

Avec cette méthode, vous pouvez vous assurer que la partie de nom de domaine URL dans le code est remplacée correctement.

7. Conclusion

Lorsque vous utilisez preg_replace_callback_array , les tests unitaires peuvent nous aider à garantir l'exactitude de notre code, en particulier en collaboration entre les fonctions de remplacement régulier et de rappel. Grâce à des cas de test raisonnables, nous pouvons vérifier si la sortie dans différentes situations d'entrée répond aux attentes, améliorant ainsi la qualité et la fiabilité du code.

Connexe