Uzyskanie subdomeny z adresu URL wydaje się na początku łatwe.

http://www.domain.example

Przeskanuj pierwszy okres, a następnie zwróć to, co pojawiło się po „http: //” ...

Wtedy sobie przypominasz

http://super.duper.domain.example

O. Więc myślisz: ok, znajdź ostatnią kropkę, cofnij słowo i zbierz wszystko wcześniej!

Wtedy sobie przypominasz

http://super.duper.domain.co.uk

I wróciłeś do punktu wyjścia. Czy ktoś ma jakieś świetne pomysły poza przechowywaniem listy wszystkich domen najwyższego poziomu?

Czy ktoś ma jakieś świetne pomysły poza przechowywaniem listy wszystkich domen najwyższego poziomu?

Nie, ponieważ każda TLD różni się tym, co liczy się jako subdomena, domena drugiego poziomu itp.

Pamiętaj, że istnieją domeny najwyższego poziomu, domeny drugiego poziomu i subdomeny. Technicznie rzecz biorąc, wszystko oprócz TLD jest subdomeną.

W przykładzie domena.com.uk „domena” to subdomena, „com” to domena drugiego poziomu, a „uk” to TLD.

Pytanie pozostaje więc bardziej złożone niż na pierwszy rzut oka i zależy od tego, jak zarządzana jest każda TLD. Będziesz potrzebować bazy danych wszystkich domen TLD, które obejmują ich określone partycjonowanie, oraz tego, co liczy się jako domena drugiego poziomu i subdomena. Nie ma jednak zbyt wielu domen najwyższego poziomu, więc lista jest rozsądnie zarządzana, ale zebranie wszystkich tych informacji nie jest trywialne. Taka lista może już być dostępna.

Wygląda na to, że http://publicsuffix.org/ jest jedną z takich list - wszystkie popularne sufiksy (.com, .co.uk itp.) Na liście nadającej się do wyszukiwania. Nadal nie będzie łatwo go przeanalizować, ale przynajmniej nie musisz utrzymywać listy.

„Publiczny przyrostek” to taki, pod którym użytkownicy Internetu mogą bezpośrednio rejestrować nazwy. Niektóre przykłady publicznych sufiksów to „.com”, „.co.uk” i „pvt.k12.wy.us”. Lista publicznych sufiksów to lista wszystkich znanych publicznych sufiksów.

Lista Sufiksów Publicznych jest inicjatywą Fundacji Mozilla. Jest dostępny do użytku w dowolnym oprogramowaniu, ale pierwotnie został stworzony, aby zaspokoić potrzeby producentów przeglądarek. Pozwala przeglądarkom na przykład:

• Unikaj ustawiania szkodliwych dla prywatności „supercookies” dla sufiksów nazw domen wysokiego poziomu
• Podświetl najważniejszą część nazwy domeny w interfejsie użytkownika
• Dokładnie sortuj wpisy historii według witryny

Przeglądając listę , widać, że nie jest to trywialny problem. Myślę, że lista to jedyny właściwy sposób na osiągnięcie tego ...

Jak mówi Adam, nie jest to łatwe, a obecnie jedynym praktycznym sposobem jest użycie listy.

Nawet wtedy są wyjątki - na przykład .ukistnieje kilka domen, które są ważne od razu na tym poziomie, a które nie są.co.uk , więc należy je dodać jako wyjątki.

Tak obecnie robią to popularne przeglądarki - konieczne jest upewnienie się, że example.co.uknie mogą ustawić pliku cookie, .co.ukktóry byłby następnie wysyłany do dowolnej innej witryny pod adresem .co.uk.

Dobra wiadomość jest taka, że ​​jest już dostępna lista pod adresem http://publicsuffix.org/ .

Jest też trochę pracy w IETF stworzeniem pewnego rodzaju standardu umożliwiającego TLD deklarowanie, jak wygląda struktura ich domeny. Jest to nieco skomplikowane przez tego typu .uk.com, który działa tak, jakby był publicznym sufiksem, ale nie jest sprzedawany przez .comrejestr.

Wydaje się, że Publicsuffix.org jest właściwą drogą. Istnieje wiele implementacji, które pozwalają łatwo przeanalizować zawartość pliku danych publicsuffix:

• Perl: Domain :: PublicSuffix
• Java: http://sourceforge.net/projects/publicsuffix/
• PHP: parser-domeny-php
• C # / .NET: https://github.com/danesparza/domainname-parser
• Pyton: http://pypi.python.org/pypi/publicsuffix
• Ruby: domainatrix , public_suffix

Jak już powiedzieli Adam i John publicsuffix.org jest właściwą drogą. Ale jeśli z jakiegoś powodu nie możesz użyć tego podejścia, oto heurystyka oparta na założeniu, które działa dla 99% wszystkich domen:

Jest jedna właściwość, która odróżnia (nie wszystkie, ale prawie wszystkie) „prawdziwe” domeny od subdomen i TLD, a jest nią rekord MX DNS. Możesz stworzyć algorytm, który wyszukuje to: Usuń części nazwy hosta jeden po drugim i odpytuj DNS, aż znajdziesz rekord MX. Przykład:

super.duper.domain.co.uk => no MX record, proceed
duper.domain.co.uk       => no MX record, proceed
domain.co.uk             => MX record found! assume that's the domain

Oto przykład w php:

function getDomainWithMX($url) {
    //parse hostname from URL 
    //http://www.example.co.uk/index.php => www.example.co.uk
    $urlParts = parse_url($url);
    if ($urlParts === false || empty($urlParts["host"])) 
        throw new InvalidArgumentException("Malformed URL");

    //find first partial name with MX record
    $hostnameParts = explode(".", $urlParts["host"]);
    do {
        $hostname = implode(".", $hostnameParts);
        if (checkdnsrr($hostname, "MX")) return $hostname;
    } while (array_shift($hostnameParts) !== null);

    throw new DomainException("No MX record found");
}

Jak już wspomniano, lista sufiksów publicznych to tylko jeden sposób na poprawne przeanalizowanie domeny. W przypadku PHP możesz wypróbować TLDExtract . Oto przykładowy kod:

$extract = new LayerShifter\TLDExtract\Extract();

$result = $extract->parse('super.duper.domain.co.uk');
$result->getSubdomain(); // will return (string) 'super.duper'
$result->getSubdomains(); // will return (array) ['super', 'duper']
$result->getHostname(); // will return (string) 'domain'
$result->getSuffix(); // will return (string) 'co.uk'

Właśnie napisałem program do tego w clojure na podstawie informacji z publicsuffix.org:

https://github.com/isaksky/url_dom

Na przykład:

(parse "sub1.sub2.domain.co.uk") 
;=> {:public-suffix "co.uk", :domain "domain.co.uk", :rule-used "*.uk"}

Dla biblioteki C (z generowaniem tabel danych w Pythonie) napisałem http://code.google.com/p/domain-registry-provider/ który jest szybki i zajmuje miejsca.

Biblioteka wykorzystuje ~ 30kB dla tabel danych i ~ 10kB dla kodu C. Nie ma narzutu związanego z uruchamianiem, ponieważ tabele są konstruowane w czasie kompilacji. Zobacz http://code.google.com/p/domain-registry-provider/wiki/DesignDocWięcej informacji można .

Aby lepiej zrozumieć kod generujący tabele (Python), zacznij tutaj: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

Aby lepiej zrozumieć interfejs API C, zobacz: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h

muszla i grzmotnąć wersje

Oprócz poprawnej odpowiedzi Adama Davisa , chciałbym zamieścić własne rozwiązanie dla tej operacji.

Ponieważ lista jest duża, istnieją trzy z wielu różnych sprawdzonych rozwiązań ...

Najpierw przygotuj swoją listę TLD w ten sposób:

wget -O - https://publicsuffix.org/list/public_suffix_list.dat |
    grep '^[^/]' |
    tac > tld-list.txt

Uwaga: tacodwróci listę, aby zapewnić .co.uk wcześniejsze przetestowanie .uk.

posix wersja powłoki

splitDom() {
    local tld
    while read tld;do
        [ -z "${1##*.$tld}" ] &&
            printf "%s : %s\n" $tld ${1%.$tld} && return
    done <tld-list.txt
}

Testy:

splitDom super.duper.domain.co.uk
co.uk : super.duper.domain

splitDom super.duper.domain.com
com : super.duper.domain

grzmotnąć wersja

Aby zmniejszyć rozwidlenia (uniknąć myvar=$(function..)składni), wolę ustawiać zmienne zamiast zrzucać dane wyjściowe na standardowe wyjście, w funkcjach bash:

tlds=($(<tld-list.txt))
splitDom() {
    local tld
    local -n result=${2:-domsplit}
    for tld in ${tlds[@]};do
        [ -z "${1##*.$tld}" ] &&
            result=($tld ${1%.$tld}) && return
    done
}

Następnie:

splitDom super.duper.domain.co.uk myvar
declare -p myvar
declare -a myvar=([0]="co.uk" [1]="super.duper.domain")

splitDom super.duper.domain.com
declare -p domsplit
declare -a domsplit=([0]="com" [1]="super.duper.domain")

Szybciej grzmotnąć wersja:

Przy takim samym przygotowaniu:

declare -A TLDS='()'
while read tld ;do
    if [ "${tld##*.}" = "$tld" ];then
        TLDS[${tld##*.}]+="$tld"
      else
        TLDS[${tld##*.}]+="$tld|"
    fi
done <tld-list.txt

Ten krok jest znacznie wolniejszy, ale splitDomfunkcja będzie znacznie szybsza:

shopt -s extglob 
splitDom() {
    local domsub=${1%%.*(${TLDS[${1##*.}]%\|})}
    local -n result=${2:-domsplit}
    result=(${1#$domsub.} $domsub)
}

Testy na moim raspberry-pi:

Obie grzmotnąć skrypty zostały przetestowane z:

for dom in dom.sub.example.{,{co,adm,com}.}{com,ac,de,uk};do
    splitDom $dom myvar
    printf "%-40s %-12s %s\n" $dom ${myvar[@]}
done

posixwersja została przetestowana ze szczegółową for pętlą, ale

Wszystkie skrypty testowe generują te same dane wyjściowe:

dom.sub.example.com                      com          dom.sub.example
dom.sub.example.ac                       ac           dom.sub.example
dom.sub.example.de                       de           dom.sub.example
dom.sub.example.uk                       uk           dom.sub.example
dom.sub.example.co.com                   co.com       dom.sub.example
dom.sub.example.co.ac                    ac           dom.sub.example.co
dom.sub.example.co.de                    de           dom.sub.example.co
dom.sub.example.co.uk                    co.uk        dom.sub.example
dom.sub.example.adm.com                  com          dom.sub.example.adm
dom.sub.example.adm.ac                   ac           dom.sub.example.adm
dom.sub.example.adm.de                   de           dom.sub.example.adm
dom.sub.example.adm.uk                   uk           dom.sub.example.adm
dom.sub.example.com.com                  com          dom.sub.example.com
dom.sub.example.com.ac                   com.ac       dom.sub.example
dom.sub.example.com.de                   com.de       dom.sub.example
dom.sub.example.com.uk                   uk           dom.sub.example.com

Pełny skrypt zawierający odczyt pliku i splitDompętlę zajmuje ~ 2m z wersją posix, ~ 1m29s z pierwszym skryptem bash opartym na $tldstablicy, ale ~22sz ostatnim skryptem bash opartym na $TLDS tablicy asocjacyjnej .

                Posix version     $tldS (array)      $TLDS (associative array)
File read   :       0.04164          0.55507           18.65262
Split loop  :     114.34360         88.33438            3.38366
Total       :     114.34360         88.88945           22.03628

Więc jeśli wypełnianie tablicy asocjacyjnej jest trudniejsze, splitDomfunkcja staje się dużo szybsza!

Nie działa to dokładnie, ale być może możesz uzyskać przydatną odpowiedź, próbując pobrać domenę kawałek po kawałku i sprawdzając odpowiedź, tj. Pobierz „ http: // uk ”, a następnie „ http://co.uk ” , a następnie „ http://domain.co.uk ”. Kiedy otrzymasz odpowiedź bez błędu, masz domenę, a reszta to subdomena.

Czasami po prostu musisz spróbować :)

Edytować:

Tom Leys zwraca uwagę w komentarzach, że niektóre domeny zakładane są tylko na subdomenie www, co dałoby nam błędną odpowiedź w powyższym teście. Słuszna uwaga! Może najlepszym podejściem byłoby sprawdzenie każdej części za pomocą „ http: // www ” oraz „http: //” i policzenie trafienia jako trafienia w tej sekcji nazwy domeny? Nadal brakowałoby nam niektórych „alternatywnych” rozwiązań, takich jak „web.domain.com”, ale od jakiegoś czasu nie napotkałem żadnego z nich :)

Użyj URIBuilder, a następnie pobierz atrybut URIBUilder.host i podziel go na tablicę na „.” masz teraz tablicę z podzieloną domeną.

echo tld('http://www.example.co.uk/test?123'); // co.uk

/**
 * http://publicsuffix.org/
 * http://www.alandix.com/blog/code/public-suffix/
 * http://tobyinkster.co.uk/blog/2007/07/19/php-domain-class/
 */
function tld($url_or_domain = null)
{
    $domain = $url_or_domain ?: $_SERVER['HTTP_HOST'];
    preg_match('/^[a-z]+:\/\//i', $domain) and 
        $domain = parse_url($domain, PHP_URL_HOST);
    $domain = mb_strtolower($domain, 'UTF-8');
    if (strpos($domain, '.') === false) return null;

    $url = 'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1';

    if (($rules = file($url)) !== false)
    {
        $rules = array_filter(array_map('trim', $rules));
        array_walk($rules, function($v, $k) use(&$rules) { 
            if (strpos($v, '//') !== false) unset($rules[$k]);
        });

        $segments = '';
        foreach (array_reverse(explode('.', $domain)) as $s)
        {
            $wildcard = rtrim('*.'.$segments, '.');
            $segments = rtrim($s.'.'.$segments, '.');

            if (in_array('!'.$segments, $rules))
            {
                $tld = substr($wildcard, 2);
                break;
            }
            elseif (in_array($wildcard, $rules) or 
                    in_array($segments, $rules))
            {
                $tld = $segments;
            }
        }

        if (isset($tld)) return $tld;
    }

    return false;
}

Możesz użyć tego lib tld.js: JavaScript API do pracy ze złożonymi nazwami domen, subdomen i URI.

tldjs.getDomain('mail.google.co.uk');
// -> 'google.co.uk'

Jeśli pobierasz domenę główną w przeglądarce. Możesz użyć tego lib AngusFu / browser-root-domain .

var KEY = '__rT_dM__' + (+new Date());
var R = new RegExp('(^|;)\\s*' + KEY + '=1');
var Y1970 = (new Date(0)).toUTCString();

module.exports = function getRootDomain() {
  var domain = document.domain || location.hostname;
  var list = domain.split('.');
  var len = list.length;
  var temp = '';
  var temp2 = '';

  while (len--) {
    temp = list.slice(len).join('.');
    temp2 = KEY + '=1;domain=.' + temp;

    // try to set cookie
    document.cookie = temp2;

    if (R.test(document.cookie)) {
      // clear
      document.cookie = temp2 + ';expires=' + Y1970;
      return temp;
    }
  }
};

Używanie plików cookie jest trudne.

Jeśli chcesz wyodrębnić subdomeny i / lub domeny z dowolnej listy adresów URL, ten skrypt w języku Python może być pomocny. Uważaj jednak, to nie jest idealne. Jest to ogólnie trudny problem do rozwiązania i jest bardzo pomocny, jeśli masz białą listę domen, których się spodziewasz.

1. Uzyskaj domeny najwyższego poziomu z publicsuffix.org

żądania importu

url = 'https://publicsuffix.org/list/public_suffix_list.dat'
page = request.get (url)

domeny = []
dla linii w page.text.splitlines ():
    if line.startswith ('//'):
        kontyntynuj
    jeszcze:
        domain = line.strip ()
        jeśli domena:
            domains.append (domena)

domains = [d [2:] if d.startswith ('*.') else d for d in domains]
print ('znaleziono {} domeny'.format (len (domeny)))

2. Utwórz wyrażenie regularne

import re

_regex = ''
dla domeny w domenach:
    _regex + = r '{} |' .format (domain.replace ('.', '\.'))

subdomain_regex = r '/([^/]*)\.[^/.]+\.({})/.*$'. format (_regex)
domain_regex = r '([^ /.] + \. ({})) /.*$'. format (_regex)

3. Użyj wyrażenia regularnego na liście adresów URL

FILE_NAME = '' # wstaw tutaj nazwę pliku CSV
URL_COLNAME = '' # wstaw tutaj nazwę kolumny URL

importuj pandy jako pd

df = pd.read_csv (FILE_NAME)
urls = df [URL_COLNAME] .astype (str) + '/' # uwaga: dodanie / jako hack, aby pomóc w wyrażeniu regularnym

df ['sub_domain_extracted'] = urls.str.extract (pat = subdomain_regex, expand = True) [0]
df ['domain_extracted'] = urls.str.extract (pat = domain_regex, expand = True) [0]

df.to_csv ('extract_domains.csv', index = False)

Lista popularnych sufiksów (.co.uk, .com itd.), Które należy usunąć wraz z http: //, a wtedy będziesz mieć tylko „sub.domain” do pracy zamiast „ http: // sub. domain.suffix ”, a przynajmniej tak bym prawdopodobnie zrobił.

Największym problemem jest lista możliwych przyrostków. W końcu jest tego dużo.

Po szybkim spojrzeniu na listę publicsuffix.org wydaje się, że można dokonać rozsądnego przybliżenia, usuwając ostatnie trzy segmenty („segment” oznacza tutaj sekcję między dwiema kropkami) z domen, w których ostatni segment ma dwa znaki, przy założeniu, że jest to kod kraju i zostanie dalej podzielony. Jeśli ostatni segment to „my”, a przedostatni segment również składa się z dwóch znaków, usuń ostatnie cztery segmenty. We wszystkich innych przypadkach usuń ostatnie dwa segmenty. na przykład:

• http: //www.domain.example

„Przykład” nie składa się z dwóch znaków, więc usuń „domena.example”, pozostawiając „www”

• http: //super.duper.domain.example

„przykład” nie składa się z dwóch znaków, więc usuń „domena.example”, pozostawiając „super.duper”

• http://super.duper.domain.co.uk

„uk” to dwa znaki (ale nie „us”), więc usuń „domain.co.uk”, pozostawiając „super.duper”

• http://foo.pvt.k12.wy.us

„us” to dwa znaki i to „nas”, a „wy” to także dwa znaki, więc usuń „pvt.k12.wy.us”, pozostawiając „foo”.

Zauważ, że chociaż działa to dla wszystkich przykładów, które widziałem w dotychczasowych odpowiedziach, pozostaje tylko rozsądnym przybliżeniem. Nie jest to całkowicie poprawne, chociaż podejrzewam, że jest tak blisko, jak najprawdopodobniej bez tworzenia / uzyskiwania rzeczywistej listy do wykorzystania w celach informacyjnych.