Sortieren Sie eine Liste der Domänennamen (FQDNs), beginnend mit tld und arbeitend links

Ich suche nach einer Liste von Domain-Namen (eine Webfilter-Whitelist), beginnend mit der TLD und aufwärts. Ich suche alle * nix oder Windows-Tools, die dies leicht tun können, obwohl ein Skript auch in Ordnung wäre.

Also, wenn das die Liste ist, die Sie erhalten

www.activityvillage.co.uk 
ajax.googleapis.com 
akhet.co.uk 
alchemy.l8r.pl 
au.af.mil 
bbc.co.uk 
bensguide.gpo.gov 
chrome.angrybirds.com 
cms.hss.gov 
crl.godaddy.com 
digitalhistory.uh.edu 
digital.library.okstate.edu 
digital.olivesoftware.com

Dies ist, was ich als Ausgabe möchte.

chrome.angrybirds.com 
crl.godaddy.com 
ajax.googleapis.com 
digital.olivesoftware.com 
digital.library.okstate.edu 
digitalhistory.uh.edu 
bensguide.gpo.gov 
cms.hss.gov 
au.af.mil 
alchemy.l8r.pl 
www.activityvillage.co.uk 
akhet.co.uk 
bbc.co.uk

Nur für den Fall, dass Sie sich fragen, warum Squidguard einen Bug / Designfehler hat. Wenn beide www.example.comund example.combeide in einer Liste enthalten sind, wird der example.comEintrag ignoriert und Sie können nur Inhalte von aufrufen www.example.com. Ich habe mehrere große Listen, die bereinigt werden müssen, weil jemand Einträge hinzugefügt hat, ohne vorher nachzuschauen.

Dieses einfache Python-Skript macht, was Sie wollen. In diesem Beispiel benenne ich die Datei domain-sort.py:

#!/usr/bin/env python
from fileinput import input
for y in sorted([x.strip().split('.')[::-1] for x in input()]): print '.'.join(y[::-1])

Um es auszuführen, benutze:

cat file.txt | ./domain-sort.py

Beachten Sie, dass das sieht ein wenig hässliche , da ich dies als mehr oder weniger ein einfacher Einzeiler ich benutzen musste schrieb Slice - Notation von[::-1] wo negativen Werten arbeiten , um eine Kopie der gleichen Liste in umgekehrter Reihenfolge zu machen , anstatt die mehr deklarativen die Verwendung reverse()des Wird auf eine Weise implementiert, die die Kompositionsfähigkeit beeinträchtigt.

Und hier ist eine etwas längere, aber möglicherweise besser lesbare Version, reversed()die einen Iterator zurückgibt. Daher muss sie auch eingebunden werden list(), um den Iterator zu konsumieren und eine Liste zu erstellen:

#!/usr/bin/env python
from fileinput import input
for y in sorted([list(reversed(x.strip().split('.'))) for x in input()]): print '.'.join(list(reversed(y)))

Bei einer Datei mit 1.500 zufällig sortierten Zeilen dauert es ~ 0,02 Sekunden:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
Maximum resident set size (kbytes): 21632

Bei einer Datei mit 150.000 zufällig sortierten Zeilen dauert es etwas mehr als 3 Sekunden:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:03.20
Maximum resident set size (kbytes): 180128

Hier ist eine wahrscheinlich besser lesbare Version, die das reverse()und sort()an Ort und Stelle ausführt , aber in der gleichen Zeit ausgeführt wird und tatsächlich etwas mehr Speicher benötigt.

#!/usr/bin/env python
from fileinput import input

data = []
for x in input():
   d = x.strip().split('.')
   d.reverse()
   data.append(d)
data.sort()
for y in data:
   y.reverse()
   print '.'.join(y)

Bei einer Datei mit 1.500 zufällig sortierten Zeilen dauert es ~ 0,02 Sekunden:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.02
Maximum resident set size (kbytes): 22096

Bei einer Datei mit 150.000 zufällig sortierten Zeilen dauert es etwas mehr als 3 Sekunden:

Elapsed (wall clock) time (h:mm:ss or m:ss): 0:03.08
Maximum resident set size (kbytes): 219152

Hier ist ein PowerShell-Skript, das tun sollte, was Sie wollen. Grundsätzlich werden alle TLDs in ein Array geworfen, umgedreht, sortiert, in die ursprüngliche Reihenfolge zurückgeführt und dann in einer anderen Datei gespeichert.

$TLDs = Get-Content .\TLDsToSort-In.txt
$TLDStrings = @();

foreach ($TLD in $TLDs){
    $split = $TLD.split(".")
    [array]::Reverse($split)
    $TLDStrings += ,$split
}

$TLDStrings = $TLDStrings|Sort-Object

foreach ($TLD in $TLDStrings){[array]::Reverse($TLD)}

$TLDStrings | %{[string]::join('.', $_)} | Out-File .\TLDsToSort-Out.txt

Lief es auf 1.500 Datensätzen - dauerte 5 Sekunden auf einem einigermaßen leistungsstarken Desktop.

cat domain.txt | rev | sortieren | rev

Etwas weniger kryptisch oder zumindest hübscher, Perl:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

@lines =
    map { join ".", reverse split /\./ }
    sort
    map { join ".", reverse split /\./ }
    @lines;

print "$_\n" for @lines;

Dies ist ein einfaches Beispiel für eine Guttman-Rosler-Transformation : Wir konvertieren die Zeilen in die entsprechende sortierbare Form (hier teilen wir den Domänennamen in Punkte auf und kehren die Reihenfolge der Teile um), sortieren sie mit der systemeigenen lexikografischen Sortierung und konvertieren dann die Linien zurück in ihre ursprüngliche Form.

In Unix-Skripten: umkehren, sortieren und umkehren:

awk -F "." '{for(i=NF; i > 1; i--) printf "%s.", $i; print $1}' file |
  sort |
  awk -F "." '{for(i=NF; i > 1; i--) printf "%s.", $i; print $1}'

Hier ist es in (kurz und kryptisch) Perl:

#!/usr/bin/perl -w
@d = <>; chomp @d;
for (@d) { $rd{$_} = [ reverse split /\./ ] }
for $d (sort { for $i (0..$#{$rd{$a}}) {
        $i > $#{$rd{$b}} and return 1;
        $rd{$a}[$i] cmp $rd{$b}[$i] or next;
        return $rd{$a}[$i] cmp $rd{$b}[$i];
} } @d) { print "$d\n" }

awk -F"." 's="";{for(i=NF;i>0;i--) {if (i<NF) s=s "." $i; else s=$i}; print s}' <<<filename>>> | sort | awk -F"." 's="";{for(i=NF;i>0;i--) {if (i<NF) s=s "." $i; else s=$i}; print s}'

Dies bewirkt, dass jedes in der Domain hinterlegte Feld umgedreht, sortiert und zurückgedreht wird.

Dies sortiert die Domain-Liste, lexikographisch basierend auf jedem Teil des Domain-Namens, von rechts nach links.

Die umgekehrte Lösung ( rev <<<filename>>> | sort | rev; nicht) habe ich ausprobiert.