Comment utiliser un essai inversé pour une détection rapide de domaine de messagerie jetable

Apprenez à utiliser un Trie inversé pour détecter efficacement les domaines de messagerie jetables. Optimisez vos recherches de domaine avec une solution évolutive et économe en mémoire, conçue pour des résultats rapides et précis.

• Lire l'article sur mon site
• Utilisez le détecteur de domaine de messagerie jetable gratuit

Les e-mails jetables peuvent provoquer des problèmes tels que de fausses inscriptions et du spam. L'utilisateur récupère une adresse parmi des milliers de générateurs de courrier électronique temporaires et la remet. Même le GOAT des regex de courrier électronique ne peut pas vous sauver ici.

Personnellement, je trouve qu'avoir une grande liste de tous les domaines de messagerie jetables est la solution la plus simple mais la plus efficace. Mais avant d'assembler cette liste et de démarrer une boucle for ... of pour la vérifier, pensez à la complexité O(n) !

Un excellent moyen de les identifier consiste à utiliser un Trie inversé, une structure de données efficace pour des recherches rapides.

Qu'est-ce qu'un essai inversé ?

Tout d'abord, comprenons ce qu'est un Trie. C'est une structure de données où les chaînes sont :

• haché, omble par omble
• assemblés en arborescence

exemple, si nous nourrissons du boa, du frère, du brie, il les assemblerait en utilisant Map comme :

b
 ├── o ── a
 └── r ── o  
     └─── i ── e

Cette approche permet des recherches directes sans parcourir toute la liste. Chaque personnage guide la recherche plus en profondeur.

Il échange la mémoire contre l'efficacité. Le temps nécessaire pour trouver la chaîne ne dépend pas de la taille de la liste, mais de la longueur de la chaîne !

Un trie inversé stocke les chaînes dans l'ordre inverse, idéal pour les domaines :

• mailinator.com devient moc.rotanliam
• trashmail.com devient moc.liambhsart

Remarque sur cette implémentation

En inversant les domaines, les recherches commencent au TLD (par exemple, .com), qui est partagé sur de nombreux domaines. Pour optimiser davantage, il stocke les TLD sous la forme d'une clé unique (com), plutôt que de les diviser en caractères. Le reste du domaine suit une structure Trie standard.

Implémentation des domaines Trie inversés

Puisqu'il s'agit d'une structure arborescente, chaque nœud référencera ses enfants :

type TrieNode = Map<string, TrieNode>;

Tout d'abord, une fonction utilitaire pour séparer le TLD du reste du domaine :

private splitTLDFromRest(input: string) {
    const dot = input.lastIndexOf('.');
    const TLD = input.substring(dot + 1);
    const rest = input.substring(0, dot);
    return [TLD, rest];
}

L'utilisation de lastIndexOf garantit que les sous-domaines tels que foo.bar.baz.com sont gérés correctement.

Ensuite, le constructeur assemblera le Trie :

export class ReverseTrieDomains {
    private root: TrieNode = new Map();

    // ...

    constructor(...domains: string[]) {
        for (const domain of domains) {
            // For "didof.dev"
            const [TLD, rest] = this.splitTLDFromRest(domain);
            // dev, didof

            // Keep the refence to the TLD node for final set
            let node = this.root.get(TLD);
            if (!node) node = new Map();

            // Start from TLD node, walk along the string in reverse
            let currentNode: TrieNode = node;
            for (let i = rest.length - 1; i >= 0; i--) {
                const char = rest[i];
                let childNode = currentNode.get(char);
                if (!childNode) {
                    childNode = new Map();
                    currentNode.set(char, childNode);
                }
                currentNode = childNode;
            }

            this.root.set(TLD, node);
        }
    }
}

Pour vérifier si un domaine est jetable, parcourez le Trie :

export class ReverseTrieDomains {
    // ...

    public has(domain: string) {
        const [TLD, rest] = this.splitTLDFromRest(domain)

        const node = this.root.get(TLD)
        if (!node) return false

        let currentNode: TrieNode = node
        let isFullDomainFound = false
        for (let i = rest.length - 1; i >= 0; i--) {
            const char = rest[i]
            const childNode = currentNode.get(char)
            if (!childNode) return false
            currentNode = childNode
            if (i === 0) {
                isFullDomainFound = currentNode.size === 0;
            }
        }

        return isFullDomainFound
    }
}

Conclusion

L'utilisation d'un Trie inversé offre plusieurs avantages :

• Recherches rapides : parcourez les caractères étape par étape pour des résultats rapides.
• Efficacité de la mémoire : les suffixes courants comme .com ne sont stockés qu'une seule fois.
• Évolutivité : gère sans effort de grandes listes de domaines.

Si vous avez affaire à des e-mails jetables, il s'agit d'une solution intelligente et évolutive à mettre en œuvre.

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!