Получить доменное имя (не субдомен) в php

Ну, вы можете использовать parse_url для получения хоста:

$info = parse_url($url);
$host = $info['host'];

Затем вы можете сделать некоторые причудливые вещи, чтобы получить только TLD и хост.

$host_names = explode(".", $host);
$bottom_host_name = $host_names[count($host_names)-2] . "." . $host_names[count($host_names)-1];

Не очень элегантно, но должно работать.

Если вам нужно объяснение, вот оно:

Сначала мы берем все, что находится между схемой (http:// и т. Д.), Используя возможности parse_url для ... ну ... синтаксического анализа URL-адресов. :)

Затем мы берем имя хоста и разделяем его на массив в зависимости от того, где попадают точки, так что test.world.hello.myname станет:

array("test", "world", "hello", "myname");

После этого берем количество элементов в массиве (4).

Затем мы вычитаем из него 2, чтобы получить предпоследнюю строку (имя хоста или example в вашем примере)

Затем мы вычитаем из него 1, чтобы получить последнюю строку (поскольку ключи массива начинаются с 0), также известную как TLD.

Затем мы объединяем эти две части с точкой, и у вас есть базовое имя хоста.

Мое решение в https://gist.github.com/pocesar/5366899

и тесты здесь http://codepad.viper-7.com/GAh1tP

Он работает с любыми TLD и ужасными шаблонами поддоменов (до 3 поддоменов).

Есть тест, включенный во многие доменные имена.

Не буду вставлять сюда функцию из-за странного отступа для кода в StackOverflow (могли бы быть изолированные блоки кода, такие как github)

Невозможно получить доменное имя без использования списка TLD для сравнения, поскольку существует множество случаев с совершенно одинаковой структурой и длиной:

1. www.db.de (субдомен) по сравнению с bbc.co.uk (домен)
2. big.uk.com (SLD) по сравнению с www.uk.com (TLD)

Список общедоступных суффиксов Mozilla должен быть лучшим вариантом, поскольку он используется всеми основными браузерами:
https://publicsuffix.org/list/public_suffix_list.dat

Не стесняйтесь использовать мою функцию:

function tld_list($cache_dir=null) {
    // we use "/tmp" if $cache_dir is not set
    $cache_dir = isset($cache_dir) ? $cache_dir : sys_get_temp_dir();
    $lock_dir = $cache_dir . '/public_suffix_list_lock/';
    $list_dir = $cache_dir . '/public_suffix_list/';
    // refresh list all 30 days
    if (file_exists($list_dir) && @filemtime($list_dir) + 2592000 > time()) {
        return $list_dir;
    }
    // use exclusive lock to avoid race conditions
    if (!file_exists($lock_dir) && @mkdir($lock_dir)) {
        // read from source
        $list = @fopen('https://publicsuffix.org/list/public_suffix_list.dat', 'r');
        if ($list) {
            // the list is older than 30 days so delete everything first
            if (file_exists($list_dir)) {
                foreach (glob($list_dir . '*') as $filename) {
                    unlink($filename);
                }
                rmdir($list_dir);
            }
            // now set list directory with new timestamp
            mkdir($list_dir);
            // read line-by-line to avoid high memory usage
            while ($line = fgets($list)) {
                // skip comments and empty lines
                if ($line[0] == '/' || !$line) {
                    continue;
                }
                // remove wildcard
                if ($line[0] . $line[1] == '*.') {
                    $line = substr($line, 2);
                }
                // remove exclamation mark
                if ($line[0] == '!') {
                    $line = substr($line, 1);
                }
                // reverse TLD and remove linebreak
                $line = implode('.', array_reverse(explode('.', (trim($line)))));
                // we split the TLD list to reduce memory usage
                touch($list_dir . $line);
            }
            fclose($list);
        }
        @rmdir($lock_dir);
    }
    // repair locks (should never happen)
    if (file_exists($lock_dir) && mt_rand(0, 100) == 0 && @filemtime($lock_dir) + 86400 < time()) {
        @rmdir($lock_dir);
    }
    return $list_dir;
}
function get_domain($url=null) {
    // obtain location of public suffix list
    $tld_dir = tld_list();
    // no url = our own host
    $url = isset($url) ? $url : $_SERVER['SERVER_NAME'];
    // add missing scheme      ftp://            http:// ftps://   https://
    $url = !isset($url[5]) || ($url[3] != ':' && $url[4] != ':' && $url[5] != ':') ? 'http://' . $url : $url;
    // remove "/path/file.html", "/:80", etc.
    $url = parse_url($url, PHP_URL_HOST);
    // replace absolute domain name by relative (http://www.dns-sd.org/TrailingDotsInDomainNames.html)
    $url = trim($url, '.');
    // check if TLD exists
    $url = explode('.', $url);
    $parts = array_reverse($url);
    foreach ($parts as $key => $part) {
        $tld = implode('.', $parts);
        if (file_exists($tld_dir . $tld)) {
            return !$key ? '' : implode('.', array_slice($url, $key - 1));
        }
        // remove last part
        array_pop($parts);
    }
    return '';
}

Что в нем особенного:

• он принимает все входные данные, такие как URL-адреса, имена хостов или домены со схемой или без нее
• список загружается построчно, чтобы избежать чрезмерного использования памяти
• он создает новый файл для каждого TLD в папке кеша, поэтому get_domain() нужно только проверять file_exists(), существует ли он, поэтому нет необходимости включать огромную базу данных в каждый запрос, например TLDExtract.
• список будет автоматически обновляться каждые 30 дней

Контрольная работа:

$urls = array(
    'http://www.example.com',// example.com
    'http://subdomain.example.com',// example.com
    'http://www.example.uk.com',// example.uk.com
    'http://www.example.co.uk',// example.co.uk
    'http://www.example.com.ac',// example.com.ac
    'http://example.com.ac',// example.com.ac
    'http://www.example.accident-prevention.aero',// example.accident-prevention.aero
    'http://www.example.sub.ar',// sub.ar
    'http://www.congresodelalengua3.ar',// congresodelalengua3.ar
    'http://congresodelalengua3.ar',// congresodelalengua3.ar
    'http://www.example.pvt.k12.ma.us',// example.pvt.k12.ma.us
    'http://www.example.lib.wy.us',// example.lib.wy.us
    'com',// empty
    '.com',// empty
    'http://big.uk.com',// big.uk.com
    'uk.com',// empty
    'www.uk.com',// www.uk.com
    '.uk.com',// empty
    'stackoverflow.com',// stackoverflow.com
    '.foobarfoo',// empty
    '',// empty
    false,// empty
    ' ',// empty
    1,// empty
    'a',// empty    
);

Последняя версия с пояснениями (немецкий):
http://www.programmierer-forum.de/domainnamen-ermitteln-t244185.htm

Я думаю, что лучший способ решить эту проблему:

$second_level_domains_regex = '/\.asn\.au$|\.com\.au$|\.net\.au$|\.id\.au$|\.org\.au$|\.edu\.au$|\.gov\.au$|\.csiro\.au$|\.act\.au$|\.nsw\.au$|\.nt\.au$|\.qld\.au$|\.sa\.au$|\.tas\.au$|\.vic\.au$|\.wa\.au$|\.co\.at$|\.or\.at$|\.priv\.at$|\.ac\.at$|\.avocat\.fr$|\.aeroport\.fr$|\.veterinaire\.fr$|\.co\.hu$|\.film\.hu$|\.lakas\.hu$|\.ingatlan\.hu$|\.sport\.hu$|\.hotel\.hu$|\.ac\.nz$|\.co\.nz$|\.geek\.nz$|\.gen\.nz$|\.kiwi\.nz$|\.maori\.nz$|\.net\.nz$|\.org\.nz$|\.school\.nz$|\.cri\.nz$|\.govt\.nz$|\.health\.nz$|\.iwi\.nz$|\.mil\.nz$|\.parliament\.nz$|\.ac\.za$|\.gov\.za$|\.law\.za$|\.mil\.za$|\.nom\.za$|\.school\.za$|\.net\.za$|\.co\.uk$|\.org\.uk$|\.me\.uk$|\.ltd\.uk$|\.plc\.uk$|\.net\.uk$|\.sch\.uk$|\.ac\.uk$|\.gov\.uk$|\.mod\.uk$|\.mil\.uk$|\.nhs\.uk$|\.police\.uk$/';
$domain = $_SERVER['HTTP_HOST'];
$domain = explode('.', $domain);
$domain = array_reverse($domain);
if (preg_match($second_level_domains_regex, $_SERVER['HTTP_HOST']) {
    $domain = "$domain[2].$domain[1].$domain[0]";
} else {
    $domain = "$domain[1].$domain[0]";
}

Я рекомендую использовать библиотеку TLDExtract для всех операций с доменным именем.

$onlyHostName = implode('.', array_slice(explode('.', parse_url($link, PHP_URL_HOST)), -2));

Использование https://subdomain.domain.com/some/path в качестве примера

parse_url($link, PHP_URL_HOST) возвращает subdomain.domain.com

explode('.', parse_url($link, PHP_URL_HOST)) затем разбивает subdomain.domain.com на массив:

array(3) {
  [0]=>
  string(5) "subdomain"
  [1]=>
  string(7) "domain"
  [2]=>
  string(3) "com"
}

array_slice затем разрезает массив так, чтобы в массиве находились только последние 2 значения (обозначенные -2):

array(2) {
  [0]=>
  string(6) "domain"
  [1]=>
  string(3) "com"
}

implode затем объединяет эти два значения массива вместе, в конечном итоге давая вам результат domain.com

Примечание. Это будет работать, только если ожидаемый конечный домен содержит только один ., например something.domain.com или else.something.domain.net.

Это не сработает для something.domain.co.uk, где вы ожидали domain.co.uk

Есть два способа извлечь субдомен из хоста:

1. Первый более точный метод - использовать базу данных tld (например, public_suffix_list.dat) и сопоставьте домен с ним. В некоторых случаях это немного тяжеловато. Есть несколько классов PHP для его использования, например php-domain-parser и TLDExtract.

2. Второй способ не такой точный, как первый, но очень быстрый и во многих случаях может дать правильный ответ, я написал для него эту функцию:

   function get_domaininfo($url) {
       // regex can be replaced with parse_url
       preg_match("/^(https|http|ftp):\/\/(.*?)\//", "$url/" , $matches);
       $parts = explode(".", $matches[2]);
       $tld = array_pop($parts);
       $host = array_pop($parts);
       if ( strlen($tld) == 2 && strlen($host) <= 3 ) {
           $tld = "$host.$tld";
           $host = array_pop($parts);
       }
   
       return array(
           'protocol' => $matches[1],
           'subdomain' => implode(".", $parts),
           'domain' => "$host.$tld",
           'host'=>$host,'tld'=>$tld
       );
   }
   

   Пример:

   print_r(get_domaininfo('http://mysubdomain.domain.co.uk/index.php'));
   

   Возврат:

   Array
   (
       [protocol] => https
       [subdomain] => mysubdomain
       [domain] => domain.co.uk
       [host] => domain
       [tld] => co.uk
   )
   

Вот функция, которую я написал, чтобы захватить домен без поддоменов, независимо от того, использует ли домен ccTLD или длинный TLD нового стиля и т. Д. Нет поиска или огромного массива известных TLD, и нет регулярного выражения . Он может быть намного короче с использованием тернарного оператора и вложенности, но я расширил его для удобства чтения.

// Per Wikipedia: "All ASCII ccTLD identifiers are two letters long, 
// and all two-letter top-level domains are ccTLDs."

function topDomainFromURL($url) {
  $url_parts = parse_url($url);
  $domain_parts = explode('.', $url_parts['host']);
  if (strlen(end($domain_parts)) == 2 ) { 
    // ccTLD here, get last three parts
    $top_domain_parts = array_slice($domain_parts, -3);
  } else {
    $top_domain_parts = array_slice($domain_parts, -2);
  }
  $top_domain = implode('.', $top_domain_parts);
  return $top_domain;
}

У меня возникли проблемы с решением, предоставленным pocesar. Когда я использовал бы, например, subdomain.domain.nl, он не возвращал бы domain.nl. Вместо этого он вернет subdomain.domain.nl Другая проблема заключалась в том, что domain.com.br возвращал com.br

Я не уверен, но я исправил эти проблемы с помощью следующего кода (надеюсь, это кому-то поможет, если да, то я счастливый человек):

function get_domain($domain, $debug = false){
    $original = $domain = strtolower($domain);
    if (filter_var($domain, FILTER_VALIDATE_IP)) {
        return $domain;
    }
    $debug ? print('<strong style="color:green">&raquo;</strong> Parsing: '.$original) : false;
    $arr = array_slice(array_filter(explode('.', $domain, 4), function($value){
        return $value !== 'www';
    }), 0); //rebuild array indexes
    if (count($arr) > 2){
        $count = count($arr);
        $_sub = explode('.', $count === 4 ? $arr[3] : $arr[2]);
        $debug ? print(" (parts count: {$count})") : false;
        if (count($_sub) === 2){ // two level TLD
            $removed = array_shift($arr);
            if ($count === 4){ // got a subdomain acting as a domain
                $removed = array_shift($arr);
            }
            $debug ? print("<br>\n" . '[*] Two level TLD: <strong>' . join('.', $_sub) . '</strong> ') : false;
        }elseif (count($_sub) === 1){ // one level TLD
            $removed = array_shift($arr); //remove the subdomain
            if (strlen($arr[0]) === 2 && $count === 3){ // TLD domain must be 2 letters
                array_unshift($arr, $removed);
            }elseif(strlen($arr[0]) === 3 && $count === 3){
                array_unshift($arr, $removed);
            }else{
                // non country TLD according to IANA
                $tlds = array(
                    'aero',
                    'arpa',
                    'asia',
                    'biz',
                    'cat',
                    'com',
                    'coop',
                    'edu',
                    'gov',
                    'info',
                    'jobs',
                    'mil',
                    'mobi',
                    'museum',
                    'name',
                    'net',
                    'org',
                    'post',
                    'pro',
                    'tel',
                    'travel',
                    'xxx',
                );
                if (count($arr) > 2 && in_array($_sub[0], $tlds) !== false){ //special TLD don't have a country
                    array_shift($arr);
                }
            }
            $debug ? print("<br>\n" .'[*] One level TLD: <strong>'.join('.', $_sub).'</strong> ') : false;
        }else{ // more than 3 levels, something is wrong
            for ($i = count($_sub); $i > 1; $i--){
                $removed = array_shift($arr);
            }
            $debug ? print("<br>\n" . '[*] Three level TLD: <strong>' . join('.', $_sub) . '</strong> ') : false;
        }
    }elseif (count($arr) === 2){
        $arr0 = array_shift($arr);
        if (strpos(join('.', $arr), '.') === false && in_array($arr[0], array('localhost','test','invalid')) === false){ // not a reserved domain
            $debug ? print("<br>\n" .'Seems invalid domain: <strong>'.join('.', $arr).'</strong> re-adding: <strong>'.$arr0.'</strong> ') : false;
            // seems invalid domain, restore it
            array_unshift($arr, $arr0);
        }
    }
    $debug ? print("<br>\n".'<strong style="color:gray">&laquo;</strong> Done parsing: <span style="color:red">' . $original . '</span> as <span style="color:blue">'. join('.', $arr) ."</span><br>\n") : false;
    return join('.', $arr);
}

Вот тот, который работает для всех доменов, в том числе с доменами второго уровня, такими как «co.uk».

function strip_subdomains($url){

    # credits to gavingmiller for maintaining this list
    $second_level_domains = file_get_contents("https://raw.githubusercontent.com/gavingmiller/second-level-domains/master/SLDs.csv");

    # presume sld first ...
    $possible_sld = implode('.', array_slice(explode('.', $url), -2));

    # and then verify it
    if (strpos($second_level_domains, $possible_sld)){
        return  implode('.', array_slice(explode('.', $url), -3));
    } else {
        return  implode('.', array_slice(explode('.', $url), -2));
    }
}

Похоже, здесь есть повторяющийся вопрос: delete-subdomain-from-url-string-if-subdomain-is-found

Очень поздно я вижу, что вы отметили регулярное выражение как ключевое слово, и моя функция работает как шарм, пока я не нашел URL-адрес, который не работает:

function get_domain_regex($url){
  $pieces = parse_url($url);
  $domain = isset($pieces['host']) ? $pieces['host'] : '';
  if (preg_match('/(?P<domain>[a-z0-9][a-z0-9\-]{1,63}\.[a-z\.]{2,6})$/i', $domain, $regs)) {
    return $regs['domain'];
  }else{
    return false;
  }
}

если вы хотите его без регулярного выражения, у меня есть этот, который, я уверен, я также взял из этого сообщения

function get_domain($url){
  $parseUrl = parse_url($url);
  $host = $parseUrl['host'];
  $host_array = explode(".", $host);
  $domain = $host_array[count($host_array)-2] . "." . $host_array[count($host_array)-1];
  return $domain;
}

Они оба работают потрясающе, НО, мне потребовалось время, чтобы понять, если URL-адрес не начинается с http: // или https: //, это не сработает, поэтому убедитесь, что строка URL-адреса начинается с протокола.

Просто попробуйте это:

   preg_match('/(www.)?([^.]+\.[^.]+)$/', $yourHost, $matches);

   echo "domain name is: {$matches[0]}\n"; 

это работает для большинства доменов.

Эта функция вернет имя домена без расширения какого-либо URL-адреса, даже если вы проанализируете URL-адрес без http: // или https: //

Вы можете расширить этот код

(?:\.co)?(?:\.com)?(?:\.gov)?(?:\.net)?(?:\.org)?(?:\.id)?

с большим количеством расширений, если вы хотите обрабатывать больше доменных имен второго уровня.

    function get_domain_name($url){
      $pieces = parse_url($url);
      $domain = isset($pieces['host']) ? $pieces['host'] : $url;
      $domain = strtolower($domain);
      $domain = preg_replace('/.international$/', '.com', $domain);
      if (preg_match('/(?P<domain>[a-z0-9][a-z0-9\-]{1,90}\.[a-z\.]{2,6})$/i', $domain, $regs)) {
          if (preg_match('/(.*?)((?:\.co)?(?:\.com)?(?:\.gov)?(?:\.net)?(?:\.org)?(?:\.id)?(?:\.asn)?.[a-z]{2,6})$/i', $regs['domain'], $matches)) {
              return $matches[1];
          }else  return $regs['domain'];
      }else{
        return $url;
      }
    }

Я использую это для достижения той же цели, и это всегда работает, я надеюсь, что это поможет другим.

$url          = https://use.fontawesome.com/releases/v5.11.2/css/all.css?ver=2.7.5
$handle       = pathinfo( parse_url( $url )['host'] )['filename'];
$final_handle = substr( $handle , strpos( $handle , '.' ) + 1 );

print_r($final_handle); // fontawesome 

Самое простое решение

@preg_replace('#\/(.)*#', '', @preg_replace('#^https?://(www.)?#', '', $url))

Просто попробуйте это:

<?php
  $host = $_SERVER['HTTP_HOST'];
  preg_match("/[^\.\/]+\.[^\.\/]+$/", $host, $matches);
  echo "domain name is: {$matches[0]}\n";
?>