Odeur de code – Expressions régulières non testées-javaDidacticiel-php.cn

Odeur de code – Expressions régulières non testées

Susan Sarandon

Libérer： 2024-10-26 08:25:30

original

407 Les gens l'ont consulté

Regex sans tests demande des ennuis - Ne soyez pas paresseux. C'est gratuit avec l'IA !

TL;DR : utilisez des expressions régulières claires et concises et testez-les minutieusement.

Problèmes

Lisibilité
Aucun cas de test
Cas de bord manqués
Défis de débogage
Échecs peu clairs
Vices cachés

Solutions

Demandez à votre IA préférée d'écrire des cas de test
Décomposez les expressions régulières complexes en parties plus petites et plus lisibles.
Vérifiez les cas extrêmes
Valider les sorties
Refactorisez l'expression régulière une fois que vous avez créé les tests
Améliorer les messages d'erreur

Contexte

Les expressions régulières sont puissantes mais délicates.

Si vous écrivez une expression régulière sans tests, vous demandez des erreurs inattendues.

Si vous écrivez une expression régulière cryptique et ignorez les tests automatisés, vous pourriez manquer des cas importants, provoquant des problèmes de sécurité ou la frustration des utilisateurs.

Exemple de code

Faux

public class PasswordValidator {
    public static boolean isValidPassword(String password) {
        return password.matches(
            "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$");
        // This is a cryptic Regular Expression
    }
}

Copier après la connexion

Droite

import java.util.ArrayList;
import java.util.List;

public class PasswordValidator {
    public static List<String> validatePassword(String password) {
        List<String> errors = new ArrayList<>();

        if (password.length() < 8) {
            errors.add(
                "Password must be at least 8 characters long.");
        }
        if (!password.matches(".*[A-Z].*")) {
            errors.add(
                "Password must contain at least one uppercase letter.");
        }
        if (!password.matches(".*[a-z].*")) {
            errors.add(
                "Password must contain at least one lowercase letter.");
        }
        if (!password.matches(".*\d.*")) {
            errors.add(
                "Password must contain at least one digit.");
        }
        if (errors.isEmpty()) {
            errors.add(
                "Password is valid.");
        }
        return errors;
        // You no longer need a Regular Expression!!
    }
}

import static org.junit.Assert.*;
import org.junit.Test;

public class PasswordValidatorTest {
    // Now you have a lot of tests
    // You can use a Regular Expression,
    // a String Validator
    // an External Library
    // Whatever you want as long as it passes the tests!

    @Test
    public void testValidPassword() {
        List<String> result = 
            PasswordValidator.validatePassword(
            "StrongPass1");
        assertEquals("Password is valid.", result.get(0));
    }

    @Test
    public void testTooShortPassword() {
        List<String> result = PasswordValidator.validatePassword(
            "Short1");
        assertTrue(result.contains(
            "Password must be at least 8 characters long."));
    }

    @Test
    public void testNoUppercase() {
        List<String> result = PasswordValidator.validatePassword(
            "nouppercase1");
        assertTrue(
            result.contains(
                "Password must contain at least one uppercase letter."));
    }

    @Test
    public void testNoLowercase() {
        List<String> result = PasswordValidator.validatePassword(
            "NOLOWERCASE1");
        assertTrue(result.contains(
            "Password must contain at least one lowercase letter."));
    }

    @Test
    public void testNoNumber() {
        List<String> result = PasswordValidator.validatePassword(
            "NoNumberPass");
        assertTrue(result.contains(
            "Password must contain at least one digit."));
    }
}

Copier après la connexion

Détection

[X] Automatique

Vous pouvez détecter quand votre regex est découverte en la modifiant pour échouer et en exécutant tous vos tests.

Si votre validation renvoie « faux » sans explications conviviales, c'est un signe clair que vous devez la refactoriser et améliorer les commentaires.

Balises

Tests

Niveau

[X] Débutant

Génération d'IA

L'IA peut générer des expressions régulières mais ne parvient souvent pas à fournir des messages d'erreur utiles.

Sans instructions appropriées, les validateurs générés par l'IA peuvent ne pas réussir à guider les utilisateurs dans la correction de leurs entrées.

Détection IA

L'IA peut détecter les modèles d'expressions régulières de base et les commentaires manquants avec des invites claires.

il se peut qu'il ne crée pas automatiquement des cas de test ou des descriptions détaillés, sauf demande spécifique.

Essayez-les !

Rappelez-vous : les assistants IA font beaucoup d'erreurs

Without Proper Instructions	With Specific Instructions
ChatGPT	ChatGPT
Claude	Claude
Perplexity	Perplexity
Copilot	Copilot
Gemini	Gemini

Conclusion

Une expression régulière sans retour clair est peu conviviale et sujette aux erreurs.

Il serait utile que vous décriviez pourquoi ils ont échoué et que vous rédigiez des tests approfondis pour vous assurer que votre regex fonctionne comme prévu.