排序域名

Question

有没有人实施了排序的域名列表？

我已经看到了一些应用程序对它们进行排序为平串，但问题是，你最终的散射相关的所有主机的域名：

a.me.com a.you.com 湾me.com b.you.com

所以，基本逻辑我想出了逆转标签的顺序，然后排序。

一个标签的FQDN应该被视为主机名，并可能单独分类，也许在顶部。

理想情况下，我正在寻找JavaScript和Java版本。

我也不知道这个设计是否适用于较新的国际化域名。

Answer 1

您可以将域名拆分为单个字段并进行连续排序。您可以创建一个域名对象以拥有三个字段并创建一个要排序的域名列表。对于三个领域中的每一个，都要进行排序。最后，您将有相关主机的域名排序在一起。

Answer 2

这是80年代初期小尾端队赢得的大前锋vs小前锋战争的结果。在英国，域名最初的订购方式与英国“利兹大学”（University of Leeds）的“uk.ac.leeds”（假设）类似。这是大端排序 - 并使您的排序更容易。这也会使得在网址中欺骗互联网网站变得难上加难。当然，现在这个命令是小端的，假设的URL是'leeds.ac.uk'。

要合理地将相关域名排序在一起，您必须首先实现最远正确组件（.com，.uk，.org）排序的效果，然后再左下并重复...换句话说（就像@Bala说的），你必须做类似的事情，把名字分开，然后从右到左排序。

Answer 3

我不太了解Java和Javascript，但许多语言提供了某种可按字典顺序排序的数组数据结构。所以，就像你说的那样，将“a.example.com”转换为{“com”，“example”，“a”}，然后让默认排序规则运行。然后，一个字典式的排序将完全按照你想要的来进行。

如果您有本地域列表以及FQDN，我同意您希望将它们分开。任何没有周期的东西都可以先被过滤掉。或者，您可以将这些全部解析为FQDN，然后对整个列表进行排序。

一些Python代码，做这个（应该映射到Java脚本相当密切）：

hosts = ["a.foo.com", "b.foo.com", "foo.com", "c.bar.com"] 

split_hosts = [] 
for h in hosts: 
    segments = h.split('.') 
    segments.reverse() 
    split_hosts.append(segments) 

split_hosts.sort() 
for segments in split_hosts: 
    segments.reverse() 
    print ".".join(segments) 

此打印：

c.bar.com 
foo.com 
a.foo.com 
b.foo.com 

Answer 4

基于Tom's answer ...

hosts = new Array("a.foo.com", "b.foo.com", "foo.com", "c.bar.com"); 

//print("Unsorted:"); 
//for (host in hosts) 
//  print(hosts[host]); 

sorted_hosts = new Array(); 
split_hosts = new Array(); 

for(h in hosts) 
{ 
    segments = hosts[h].split('.'); 
    segments.reverse(); 
    split_hosts.push(segments); 
} 

split_hosts.sort() 

for(h in split_hosts) 
{ 
    split_hosts[h].reverse() 
    sorted_hosts.push(split_hosts[h].join(".")) 
} 

//print("Sorted:"); 
//for (host in sorted_hosts) 
//  print(sorted_hosts[host]); 

的打印报表在SquareFree JavaScript Development Environment中工作（当未注释时），这是一个方便测试ou的地方t JavaScript片段...

Answer 5

这是它是如何在Perl做：

#!/usr/bin/perl -w 
use strict; 

my @hosts = qw(
bar.org 
a.foo.com 
b.foo.com 
foo.com 
c.bar.com 
); 

print join("\n", sort { 
$a = lc($a); 
$b = lc($b); 
if ($a eq $b) { 
    return 0; 
} 
my @a = reverse(split(/\./, $a)); 
my @b = reverse(split(/\./, $b)); 
my $max = (scalar(@a), scalar(@b))[@a < @b]; 
for (my $i=0; $i < $max; $i++) { 
    if (($i < @a) && ($i < @b)) { 
    if (my $c = $a[$i] cmp $b[$i]) { 
    return $c; 
    } 
    } 
    else { 
    return scalar(@a) <=> scalar(@b); 
    } 
} 
return 0; 
} @hosts) . "\n"; 

Answer 6

我想出了这个解决方案，利用Array.prototype.sort（）和ES6发电机：

function* reverseIterateParts(domain) { 
    let currentEnd = domain.length; 
    for (let index = currentEnd-1; index >= -1; index--) { 
     if (index == -1 || domain[index] == '.') { 
      yield domain.substring(index + 1, currentEnd); 
      currentEnd = index; 
     } 
    } 
} 

arrayOfDomainNames.sort((domainA, domainB) => { 
    let partsOfA = reverseIterateParts(domainA); 
    let partsOfB = reverseIterateParts(domainB); 
    while (true) { 
     let partA = partsOfA.next(); 
     let partB = partsOfB.next(); 

     if (partA.done) { 
      if (partB.done) { 
       return 0; 
      } 
      return -1; 
     } 
     if (partB.done) { 
      return 1; 
     } 
     if (partA.value > partB.value) { 
      return 1; 
     } 
     if (partA.value < partB.value) { 
      return -1; 
     } 
    } 
});