So verwenden Sie einen umgekehrten Versuch zur schnellen Erkennung von Einweg-E-Mail-Domänen

Erfahren Sie, wie Sie mit einem Reverse Trie effizient Wegwerf-E-Mail-Domänen erkennen. Optimieren Sie Ihre Domain-Suchen mit einer skalierbaren, speichereffizienten Lösung, die auf schnelle und präzise Ergebnisse zugeschnitten ist.

• Lesen Sie den Artikel auf meiner Website
• Verwenden Sie den kostenlosen Einweg-E-Mail-Domain-Detektor

---

Wegwerf-E-Mails können Probleme wie gefälschte Anmeldungen und Spam verursachen. Der Benutzer holt sich eine Adresse von einem von Tausenden temporären E-Mail-Generatoren und übergibt sie. Nicht einmal der GOAT von E-Mail-Regex kann Sie hier retten.

Ich persönlich finde, dass eine große Liste aller verfügbaren E-Mail-Domains die einfachste und zugleich effektivste Lösung ist. Aber bevor Sie diese Liste zusammenstellen und eine for ... of-Schleife starten, um sie zu prüfen, denken Sie an die O(n)-Komplexität!

Eine gute Möglichkeit, sie zu identifizieren, ist die Verwendung eines Reverse Trie, einer effizienten Datenstruktur für schnelle Suchvorgänge.

Was ist ein umgekehrter Versuch?

Lassen Sie uns zunächst begreifen, was ein Trie ist. Es handelt sich um eine Datenstruktur, in der Zeichenfolgen wie folgt lauten:

• gehackt, Saibling für Saibling
• in einer Baumstruktur zusammengesetzt

Wenn wir beispielsweise Boa, Bro, Brie füttern, werden sie mithilfe der Karte wie folgt zusammengesetzt:

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

Dieser Ansatz ermöglicht direkte Suchvorgänge, ohne die gesamte Liste durchgehen zu müssen. Jedes Zeichen führt die Suche tiefer.

Es tauscht Speicher gegen Effizienz. Die Zeit, die zum Auffinden der Zeichenfolge benötigt wird, hängt nicht von der Größe der Liste ab, sondern von der Länge der Zeichenfolge!

Ein Reverse Trie speichert Zeichenfolgen in umgekehrter Reihenfolge, ideal für Domänen:

• mailinator.com wird zu moc.rotanliam
• trashmail.com wird zu moc.liambhsart

Hinweis zu dieser Implementierung

Durch die Umkehrung der Domänen beginnt die Suche bei der TLD (z. B. .com), die von vielen Domänen gemeinsam genutzt wird. Zur weiteren Optimierung speichert es TLDs als einen einzelnen Schlüssel (com), anstatt sie in Zeichen aufzuteilen. Der Rest der Domain folgt einer Standard-Trie-Struktur.

Implementierung von Reverse-Trie-Domänen

Da es sich um eine Baumstruktur handelt, verweist jeder Knoten auf seine untergeordneten Knoten:

type TrieNode = Map<string, TrieNode>;

Zuerst eine Hilfsfunktion zum Trennen der TLD vom Rest der Domain:

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

Die Verwendung von lastIndexOf stellt sicher, dass Subdomains wie foo.bar.baz.com korrekt behandelt werden.

Als nächstes baut der Konstrukteur das Trie zusammen:

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

Um zu überprüfen, ob eine Domain verfügbar ist, durchlaufen Sie den Versuch:

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
    }
}

Abschluss

Die Verwendung eines Reverse Trie bietet mehrere Vorteile:

• Schnelle Suchvorgänge: Durchlaufen Sie Zeichen Schritt für Schritt, um schnelle Ergebnisse zu erzielen.
• Speichereffizienz: Gängige Suffixe wie .com werden nur einmal gespeichert.
• Skalierbarkeit: Bewältigt mühelos große Domainlisten.

Wenn Sie mit Wegwerf-E-Mails zu tun haben, ist dies eine intelligente, skalierbare Lösung zur Implementierung.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie einen umgekehrten Versuch zur schnellen Erkennung von Einweg-E-Mail-Domänen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!