Dapatkan subdomain dari URL

Mendapatkan subdomain dari URL terdengar mudah pada awalnya.

http://www.domain.example

Pindai periode pertama lalu kembalikan apa pun yang muncul setelah "http: //" ...

Kemudian Anda ingat

http://super.duper.domain.example

Oh. Jadi kemudian Anda berpikir, oke, temukan periode terakhir, mundur satu kata dan dapatkan semuanya sebelumnya!

Kemudian Anda ingat

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

Dan Anda kembali ke titik awal. Adakah yang punya ide bagus selain menyimpan daftar semua TLD?

Adakah yang punya ide bagus selain menyimpan daftar semua TLD?

Tidak, karena setiap TLD berbeda dalam hal apa yang dianggap sebagai subdomain, domain level kedua, dll.

Perlu diingat bahwa ada domain level teratas, domain level kedua, dan subdomain. Secara teknis, semua kecuali TLD adalah subdomain.

Dalam contoh domain.com.uk, "domain" adalah subdomain, "com" adalah domain level kedua, dan "uk" adalah TLD.

Jadi pertanyaannya tetap lebih kompleks daripada pada blush pertama, dan itu tergantung pada bagaimana setiap TLD dikelola. Anda akan memerlukan database semua TLD yang menyertakan partisi khusus mereka, dan yang dihitung sebagai domain tingkat kedua dan subdomain. Tidak terlalu banyak TLD, jadi daftarnya dapat dikelola dengan wajar, tetapi mengumpulkan semua informasi itu tidaklah sepele. Mungkin sudah ada daftar seperti itu yang tersedia.

Sepertinya http://publicsuffix.org/ adalah salah satu daftar tersebut — semua sufiks umum (.com, .co.uk, dll) dalam daftar yang sesuai untuk pencarian. Masih tidak akan mudah untuk menguraikannya, tetapi setidaknya Anda tidak perlu mempertahankan daftarnya.

Sebuah "sufiks publik" adalah salah satu di mana pengguna Internet dapat langsung mendaftarkan nama. Beberapa contoh sufiks publik adalah ".com", ".co.uk" dan "pvt.k12.wy.us". Daftar Sufiks Publik adalah daftar semua sufiks publik yang diketahui.

Daftar Sufiks Publik adalah inisiatif dari Mozilla Foundation. Ini tersedia untuk digunakan di perangkat lunak apa pun, tetapi pada awalnya dibuat untuk memenuhi kebutuhan produsen browser. Ini memungkinkan browser untuk, misalnya:

• Hindari penyetelan "supercookies" yang merusak privasi untuk sufiks nama domain tingkat tinggi
• Sorot bagian terpenting dari nama domain di antarmuka pengguna
• Urutkan entri riwayat secara akurat berdasarkan situs

Melihat daftar tersebut , Anda dapat melihat bahwa ini bukanlah masalah yang sepele. Saya pikir daftar adalah satu-satunya cara yang benar untuk mencapai ini ...

Seperti yang dikatakan Adam, itu tidak mudah, dan saat ini satu-satunya cara praktis adalah menggunakan daftar.

Meskipun demikian, ada pengecualian - misalnya, .ukada beberapa domain yang langsung valid di level tersebut tetapi tidak ada .co.uk, jadi domain tersebut harus ditambahkan sebagai pengecualian.

Beginilah cara browser utama melakukan ini - penting untuk memastikan bahwa example.co.uktidak dapat menetapkan Cookie .co.ukyang kemudian akan dikirim ke situs web lain di bawah .co.uk.

Kabar baiknya adalah sudah ada daftar yang tersedia di http://publicsuffix.org/ .

Ada juga beberapa pekerjaan di IETF untuk membuat semacam standar untuk memungkinkan TLD mendeklarasikan seperti apa struktur domain mereka. Ini agak rumit meskipun oleh .uk.comyang sejenis, yang dioperasikan seolah-olah itu adalah sufiks publik, tetapi tidak dijual oleh .comregistri.

Publicsuffix.org sepertinya cara yang harus dilakukan. Ada banyak implementasi di luar sana untuk mengurai konten file data publicsuffix dengan mudah:

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

Seperti yang telah dikatakan oleh Adam dan John publicsuffix.org adalah cara yang tepat untuk melakukannya. Namun, jika karena alasan apa pun Anda tidak dapat menggunakan pendekatan ini, berikut adalah heuristik berdasarkan asumsi yang berfungsi untuk 99% dari semua domain:

Ada satu properti yang membedakan (tidak semua, tetapi hampir semua) domain "nyata" dari subdomain dan TLD dan itu adalah data MX DNS. Anda dapat membuat algoritme yang mencari ini: Hapus bagian dari nama host satu per satu dan minta DNS sampai Anda menemukan data MX. Contoh:

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

Berikut adalah contoh di 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");
}

Seperti yang sudah dikatakan, Daftar Sufiks Publik hanyalah salah satu cara untuk mengurai domain dengan benar. Untuk PHP Anda dapat mencoba TLDExtract . Berikut adalah contoh kode:

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

Baru saja menulis program untuk ini di clojure berdasarkan info dari publicsuffix.org:

https://github.com/isaksky/url_dom

Sebagai contoh:

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

Untuk perpustakaan C (dengan pembuatan tabel data dengan Python), saya menulis http://code.google.com/p/domain-registry-provider/ yang cepat dan hemat ruang.

Pustaka menggunakan ~ 30kB untuk tabel data dan ~ 10kB untuk kode C. Tidak ada overhead startup karena tabel dibuat pada waktu kompilasi. Lihat http://code.google.com/p/domain-registry-provider/wiki/DesignDoc untuk detail selengkapnya.

Untuk lebih memahami kode pembuatan tabel (Python), mulailah di sini: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/registry_tables_generator/registry_tables_generator.py

Untuk lebih memahami C API, lihat: http://code.google.com/p/domain-registry-provider/source/browse/trunk/src/domain_registry/domain_registry.h

Ini tidak berhasil dengan tepat, tetapi Anda mungkin bisa mendapatkan jawaban yang berguna dengan mencoba mengambil domain sepotong demi sepotong dan memeriksa tanggapannya, yaitu, ambil ' http: // uk ', lalu ' http://co.uk ' , lalu ' http://domain.co.uk '. Ketika Anda mendapatkan respon non-error, Anda mendapatkan domain dan sisanya adalah subdomain.

Terkadang Anda harus mencobanya :)

Edit:

Tom Leys menunjukkan di komentar, bahwa beberapa domain hanya diatur di subdomain www, yang akan memberi kami jawaban yang salah dalam tes di atas. Poin bagus! Mungkin pendekatan terbaik adalah memeriksa setiap bagian dengan ' http: // www ' serta 'http: //', dan menghitung hit sebagai klik untuk bagian nama domain tersebut? Kami masih akan kehilangan beberapa pengaturan 'alternatif' seperti 'web.domain.com', tetapi saya belum mengalami salah satunya untuk sementara waktu :)

Gunakan URIBuilder lalu dapatkan atribut URIBUilder.host membaginya menjadi array di "." Anda sekarang memiliki array dengan domain yang dipisahkan.

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

Saya baru saja menulis perpustakaan objc: https://github.com/kejinlu/KKDomain

Anda dapat menggunakan lib ini tld.js: JavaScript API ini untuk bekerja pada nama domain, subdomain, dan URI yang kompleks.

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

Jika Anda mendapatkan domain root di browser. Anda dapat menggunakan lib ini AngusFu / browser-root-domain ini .

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

Menggunakan cookie itu rumit.

Jika Anda ingin mengekstrak subdomain dan / atau domain dari daftar sembarang URL, skrip python ini mungkin bisa membantu. Berhati-hatilah, ini tidak sempurna. Ini adalah masalah yang rumit untuk dipecahkan secara umum dan sangat membantu jika Anda memiliki daftar putih domain yang Anda harapkan.

1. Dapatkan domain level teratas dari publicsuffix.org

permintaan impor

url = 'https://publicsuffix.org/list/public_suffix_list.dat'
halaman = requests.get (url)

domain = []
untuk baris di halaman.text.splitlines ():
    jika line.startswith ('//'):
        terus
    lain:
        domain = line.strip ()
        jika domain:
            domains.append (domain)

domain = [d [2:] if d.startswith ('*.') else d untuk d dalam domain]
cetak ('domain {} ditemukan'.format (len (domain)))

2. Bangun regex

impor kembali

_regex = ''
untuk domain di domain:
    _regex + = r '{} |' .format (domain.replace ('.', '\.'))

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

3. Gunakan ekspresi reguler pada daftar URL

FILE_NAME = '' # masukkan nama file CSV di sini
URL_COLNAME = '' # masukkan nama kolom URL di sini

impor panda sebagai pd

df = pd.read_csv (FILE_NAME)
urls = df [URL_COLNAME] .astype (str) + '/' # note: menambahkan / sebagai retasan untuk membantu regex

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

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

Daftar sufiks umum (.co.uk, .com, dan lain-lain) untuk dihapus bersama dengan http: // dan kemudian Anda hanya akan memiliki "sub.domain" untuk digunakan alih-alih " http: // sub. domain.suffix ", atau setidaknya itulah yang mungkin akan saya lakukan.

Masalah terbesar adalah daftar sufiks yang memungkinkan. Ada banyak sekali.

Setelah melihat sekilas daftar publicsuffix.org, tampaknya Anda dapat membuat perkiraan yang masuk akal dengan menghapus tiga segmen terakhir ("segmen" di sini berarti bagian antara dua titik) dari domain yang segmen terakhirnya terdiri dari dua karakter, dengan asumsi bahwa itu adalah kode negara dan akan dibagi lagi. Jika segmen terakhir adalah "kami" dan segmen kedua hingga terakhir juga terdiri dari dua karakter, hapus empat segmen terakhir. Di semua kasus lainnya, hapus dua segmen terakhir. misalnya:

• http: //www.domain.example

"contoh" bukan dua karakter, jadi hapus "domain.example", biarkan "www"

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

"contoh" bukan dua karakter, jadi hapus "domain.example", biarkan "super.duper"

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

"uk" adalah dua karakter (tapi bukan "us"), jadi hapus "domain.co.uk", biarkan "super.duper"

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

"us" adalah dua karakter dan merupakan "us", ditambah "wy" juga dua karakter, jadi hapus "pvt.k12.wy.us", biarkan "foo".

Perhatikan bahwa, meskipun ini berfungsi untuk semua contoh yang telah saya lihat dalam tanggapan sejauh ini, itu tetap hanya perkiraan yang masuk akal. Ini tidak sepenuhnya benar, meskipun saya curiga ini sedekat mungkin yang Anda dapatkan tanpa membuat / mendapatkan daftar aktual untuk digunakan sebagai referensi.