Сортировать список доменных имен (FQDN), начиная с tld и работая слева

Кошка domain.txt | рев | сортировать | оборот

Вот сценарий PowerShell, который должен делать то, что вы хотите. По сути, он выбрасывает все TLD в массив, переворачивает каждый TLD, сортирует его, возвращает его в исходный порядок, а затем сохраняет в другом файле.

$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

Запустил его на 1500 записях - заняло 5 секунд на достаточно мощном рабочем столе.

В сценариях Unix: обратный, сортировка и обратный:

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

Чуть менее загадочный или, по крайней мере, более красивый Perl:

use warnings;
use strict;

my @lines = <>;
chomp @lines;

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

print "$_\n" for @lines;

Это простой пример преобразования Гутмана-Рослера: мы преобразуем строки в соответствующую сортируемую форму (здесь, разбиваем доменное имя по периодам и меняем порядок частей), сортируем их, используя собственную лексикографическую сортировку, а затем преобразуем линии обратно в исходную форму.

Вот он (короткий и загадочный) 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" }

Хорошо, я добавлю еще одно решение (через 10 лет), потому что в других решениях Python не упоминалась отсортированная клавишная функция, которая читабельна и проста для понимания:

      #!/usr/bin/env python
import sys
def kf(v):
    """Key-function to sort domains in tld order"""
    return '.'.join(reversed(v.strip().split('.')))

sys.stdout.writelines(sorted(sys.stdin, key=kf))

Еще один ответ: использование встроенной сортировки awk для лексической сортировки каждой части имени:

      awk -F. '{k="";for(x=NF;x>0;x--){k=k"."$x};o[k]=$0};END{PROCINFO["sorted_in"]="@ind_str_asc";for(n in o){print o[n]}}' < infile > outfile

Более читабельно:

      awk -F. '
  {
    k=""
    for(x=NF;x>0;x--){k=k"."$x}
    o[k]=$0
  }

  END{
    PROCINFO["sorted_in"]="@ind_str_asc"
    for(n in o){
      print o[n]
    }
  }
' < infile > outfile

В моей системе awk на самом деле является GNU Awk 5.1.0; и неясно, какие версии awk/mawk/nawk/gawk/etc поддерживают PROCINFO["sorted_in"]. Однако первый awk, который я когда-либо использовал, сортировал вывод в алфавитном порядке по ключу массива, поэтому PROCINFO на самом деле предназначен только для того, чтобы «современные» версии gawk не испортили вывод. :-)

В JavaScript:

      function compareName(a, b) {
    const aReverse = a.split('.').reverse().join('.')
    const bReverse = b.split('.').reverse().join('.')
    return aReverse.toLowerCase().localeCompare(bReverse.toLowerCase())
}

const myNames = ['a.example', 'Z.a.example', 'yl.a.example', 'example']
myNames.sort(compareName)

Использует тот же алгоритм, что и ответ @aculich .

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

То, что это делает, это переворачивает каждое поле в имени домена, сортирует и переворачивает обратно.

Это действительно сортирует список доменов, лексикографически основанный на каждой части имени домена, справа налево.

Обратное решение (rev <<<filename>>> | sort | rev) нет, я пробовал.