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

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

1. Demandez à votre IA préférée d'écrire des cas de test
2. Décomposez les expressions régulières complexes en parties plus petites et plus lisibles.
3. Vérifiez les cas extrêmes
4. Valider les sorties
5. Refactorisez l'expression régulière une fois que vous avez créé les tests
6. 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
    }
}

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."));
    }
}

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.

Rapports

Code Smell 41 - Abuseurs d'expressions régulières

Maxi Contieri ・ 3 décembre 20

#oop #webdev #codenewbie #tutoriel

Code Smell 185 - Expressions régulières maléfiques

Maxi Contieri ・ 8 décembre 22

#webdev #javascript #débutants #programmation

Code Smell 97 - Messages d'erreur sans empathie

Maxi Contieri ・ 27 octobre 21

#opensource #ux #programmation #javascript

Clause de non-responsabilité

Les odeurs de code sont mon opinion.

Crédits

Photo par rc.xyz Galerie NFT sur Unsplash

---

Le feedback est le petit-déjeuner des champions.

Ken Blanchard

Citations intéressantes sur le génie logiciel

Maxi Contieri ・ 28 décembre 20

#codenewbie #programmation #citations #logiciel

---

Cet article fait partie de la série CodeSmell.

Comment trouver les parties puantes de votre code

Maxi Contieri ・ 21 mai '21

#codenewbie #tutoriel #qualitéducode #débutants

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!