Natuurlijk! Hier is een stapsgewijze gids voor het ontwerpen van een toepassing die gegevens valideert en robuuste foutafhandeling uitvoert, gericht op e-mailadressen en telefoonnummers. Ik geef ook een voorbeeldimplementatie in Python. **Stap-voor-stap uitleg** 1. **Definieer validatieregels** - **E-mailadressen:** - Moeten een geldig formaat hebben: `local-part@domain` - Gebruik een regex die de meeste geldige e-mailformaten accepteert - Bijvoorbeeld: minimaal één teken voor `@`, een domeinnaam met punt, en een top-level domein - **Telefoonnummers:** - Moeten een geldig formaat hebben (bijvoorbeeld: cijfers, optioneel spaties, koppeltekens, of haakjes) - Vaak wordt een regex gebruikt om verschillende formaten te accepteren - Bijvoorbeeld: landcode optioneel, gevolgd door cijfers 2. **Implementatie in Python** - Maak functies voor validatie - Gebruik try-except blokken voor foutafhandeling - Geef duidelijke foutmeldingen bij invaliditeit 3. **Robuuste foutafhandeling** - Controleer of gegevens correct zijn - Geef informatieve foutmeldingen - Zorg dat de applicatie niet crasht door exception handling 4. **Voorbeeld** Hieronder vind je een voorbeeldimplementatie. --- **Voorbeeldcode in Python:** ```python import re def validate_email(email): """ Validatie van een e-mailadres met regex. """ email_regex = re.compile( r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$" ) if email_regex.match(email): return True else: raise ValueError(f"Onjuist e-mailadres: {email}") def validate_telefoonnummer(telefoon): """ Validatie van een telefoonnummer. Accepteert formaten zoals: - 0612345678 - +31 6 12345678 - +31-6-12345678 - 06-12345678 """ telefoon_regex = re.compile( r"^(\+?\d{1,3}[\s-]?)?(\(?\d+\)?[\s-]?)?\d+([\s-]?\d+)*$" ) if telefoon_regex.match(telefoon): return True else: raise ValueError(f"Onjuist telefoonnummer: {telefoon}") def main(): gegevens = [ {"email": "voorbeeld@voorbeeld.com", "telefoon": "+31 6 12345678"}, {"email": "foutief@voorbeeld", "telefoon": "06-12-34-56-78"}, {"email": "correct@domein.nl", "telefoon": "0612345678"}, {"email": "ongeldig@@voorbeeld.com", "telefoon": "abc123"}, ] for index, item in enumerate(gegevens): print(f"\nValideren item {index + 1}:") try: if validate_email(item["email"]): print(f"E-mail '{item['email']}' is geldig.") except ValueError as e: print(e) try: if validate_telefoonnummer(item["telefoon"]): print(f"Telefoon '{item['telefoon']}' is geldig.") except ValueError as e: print(e) if __name__ == "__main__": main() ``` --- **Samenvatting:** - Definieer regex-patronen voor elke gegevenssoort. - Maak functies die deze patronen controleren en exception handling gebruiken. - In de hoofdfunctie validateer je gegevens en behandel je fouten op een informatieve manier. - Zorg dat je validatie flexibel is, maar ook streng genoeg om onjuiste data te voorkomen. Wil je verdere hulp bij het aanpassen van deze validatieregels of het uitbreiden van de toepassing?

Ik help je graag bij het ontwerpen van een robuuste validatietoepassing. Hier is een complete uitleg in het Nederlands: ## Validatieregels **E-mailadressen:** - Moet een @ bevatten - Domeinnaam na de @ moet een punt bevatten - Geen spaties toegestaan - Speciale tekens voor de @ zijn beperkt (alleen letters, cijfers, ., -, _) - Domein extensie moet minstens 2 tekens lang zijn **Telefoonnummers (Nederlands):** - Begint met +31 of 06 (mobiel) of vaste lijn - Minimaal 10 cijfers - Optioneel spaties, streepjes, haakjes - Landcode +31 of 0 ## Stap-voor-stap implementatie ```python import re from typing import Dict, List, Optional, Tuple from dataclasses import dataclass @dataclass class ValidatieResultaat: is_geldig: bool fouten: List[str] genormaliseerd: Optional[str] = None class GegevensValidator: def __init__(self): # Regex patronen voor validatie self.email_pattern = re.compile( r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' ) self.telefoon_pattern = re.compile( r'^(\+31|0|0031)[1-9][0-9]{7,8}$' ) def normaliseer_telefoonnummer(self, telefoon: str) -> str: """Verwijder niet-cijferige tekens en normaliseer naar +31 formaat""" # Verwijder alle niet-cijferige tekens cijfers = re.sub(r'\D', '', telefoon) # Normaliseer naar +31 formaat if cijfers.startswith('0'): return '+31' + cijfers[1:] elif cijfers.startswith('0031'): return '+31' + cijfers[4:] elif cijfers.startswith('31'): return '+' + cijfers else: return '+' + cijfers def valideer_email(self, email: str) -> ValidatieResultaat: """Valideer en normaliseer e-mailadres""" fouten = [] # Basis checks if not email: fouten.append("E-mailadres mag niet leeg zijn") return ValidatieResultaat(False, fouten) email = email.strip().lower() # Regex validatie if not self.email_pattern.match(email): fouten.append("Ongeldig e-mail formaat") # Extra checks if '..' in email: fouten.append("E-mail mag niet twee punten achter elkaar bevatten") if email.count('@') != 1: fouten.append("E-mail moet precies één @ bevatten") return ValidatieResultaat( is_geldig=len(fouten) == 0, fouten=fouten, genormaliseerd=email if len(fouten) == 0 else None ) def valideer_telefoon(self, telefoon: str) -> ValidatieResultaat: """Valideer en normaliseer telefoonnummer""" fouten = [] if not telefoon: fouten.append("Telefoonnummer mag niet leeg zijn") return ValidatieResultaat(False, fouten) # Normaliseer eerst genormaliseerd = self.normaliseer_telefoonnummer(telefoon) # Valideer het genormaliseerde nummer if not self.telefoon_pattern.match(genormaliseerd): fouten.append("Ongeldig telefoonnummer formaat") # Controleer lengte cijfers = re.sub(r'\D', '', genormaliseerd) if len(cijfers) < 10: fouten.append("Telefoonnummer moet minstens 10 cijfers bevatten") return ValidatieResultaat( is_geldig=len(fouten) == 0, fouten=fouten, genormaliseerd=genormaliseerd if len(fouten) == 0 else None ) class ValidatieManager: def __init__(self): self.validator = GegevensValidator() def valideer_gegevens(self, gegevens: Dict[str, str]) -> Dict[str, ValidatieResultaat]: """Valideer meerdere gegevens in één keer""" resultaten = {} if 'email' in gegevens: resultaten['email'] = self.validator.valideer_email(gegevens['email']) if 'telefoon' in gegevens: resultaten['telefoon'] = self.validator.valideer_telefoon(gegevens['telefoon']) return resultaten def zijn_alle_gegevens_geldig(self, resultaten: Dict[str, ValidatieResultaat]) -> bool: """Controleer of alle validaties succesvol zijn""" return all(resultaat.is_geldig for resultaat in resultaten.values()) # Voorbeeldgebruik def toon_voorbeeld(): validator = ValidatieManager() # Testgegevens test_gegevens = { 'email': 'voorbeeld@domein.nl', 'telefoon': '06-12345678' } print("=== Validatie Voorbeeld ===") print(f"Input gegevens: {test_gegevens}") # Voer validatie uit resultaten = validator.valideer_gegevens(test_gegevens) # Toon resultaten for veld, resultaat in resultaten.items(): status = "✓ GELDIG" if resultaat.is_geldig else "✗ ONGELDIG" print(f"\n{veld.upper()}: {status}") if resultaat.genormaliseerd: print(f" Genormaliseerd: {resultaat.genormaliseerd}") if not resultaat.is_geldig: print(" Fouten:") for fout in resultaat.fouten: print(f" - {fout}") # Controleer overall status if validator.zijn_alle_gegevens_geldig(resultaten): print("\n🎉 Alle gegevens zijn geldig!") else: print("\n❌ Er zijn validatiefouten gevonden.") # Uitgebreide test cases def test_validatie(): validator = GegevensValidator() test_cases = [ # E-mail test cases ("test@example.com", "email", True), ("ongeldig@", "email", False), ("geen-at-teken.com", "email", False), # Telefoon test cases ("0612345678", "telefoon", True), ("+31612345678", "telefoon", True), ("06-12345678", "telefoon", True), ("12345", "telefoon", False), ] print("\n=== Uitgebreide Test Cases ===") for invoer, type, verwacht in test_cases: if type == "email": resultaat = validator.valideer_email(invoer) else: resultaat = validator.valideer_telefoon(invoer) status = "✓" if resultaat.is_geldig == verwacht else "✗" print(f"{status} {type}: '{invoer}' -> {resultaat.is_geldig} (verwacht: {verwacht})") if __name__ == "__main__": toon_voorbeeld() test_validatie() ``` ## Belangrijke kenmerken van deze implementatie: 1. **Robuuste foutafhandeling** - Duidelijke foutmeldingen per validatiefout 2. **Genormaliseerde output** - Consistent formaat voor geldige gegevens 3. **Uitbreidbaar** - Makkelijk nieuwe validatieregels toe te voegen 4. **Testbaar** - Inclusief test cases voor verschillende scenario's 5. **Type hints** - Betere code kwaliteit en onderhoudbaarheid Deze aanvolg zorgt voor professionele gegevensvalidatie met duidelijke foutmeldingen en genormaliseerde uitvoer!