Analysieren der Domain von einer URL

Ich muss eine Funktion erstellen, die die Domain von einer URL analysiert.

Also mit

http://google.com/dhasjkdas/sadsdds/sdda/sdads.html

oder

http://www.google.com/dhasjkdas/sadsdds/sdda/sdads.html

es sollte zurückkehren google.com

mit

http://google.co.uk/dhasjkdas/sadsdds/sdda/sdads.html

es sollte zurückkehren google.co.uk.

Check out parse_url():

$url = 'http://google.com/dhasjkdas/sadsdds/sdda/sdads.html';
$parse = parse_url($url);
echo $parse['host']; // prints 'google.com'

parse_url geht nicht wirklich gut mit schlecht verstümmelten URLs um, ist aber in Ordnung, wenn Sie im Allgemeinen anständige URLs erwarten.

$domain = str_ireplace('www.', '', parse_url($url, PHP_URL_HOST));

Dies würde google.comsowohl für http://google.com/ ... als auch für http://www.google.com/ ... zurückgeben.

Von http://us3.php.net/manual/en/function.parse-url.php#93983

Aus irgendeinem Grund gibt parse_url den Host (z. B. example.com) als Pfad zurück, wenn in der Eingabe-URL kein Schema angegeben ist. Also habe ich eine schnelle Funktion geschrieben, um den richtigen Host zu finden:

function getHost($Address) { 
   $parseUrl = parse_url(trim($Address)); 
   return trim($parseUrl['host'] ? $parseUrl['host'] : array_shift(explode('/', $parseUrl['path'], 2))); 
} 

getHost("example.com"); // Gives example.com 
getHost("http://example.com"); // Gives example.com 
getHost("www.example.com"); // Gives www.example.com 
getHost("http://example.com/xyz"); // Gives example.com 

Der Code, der zu 100% funktionieren sollte, schien es für mich nicht zu schneiden. Ich habe das Beispiel ein wenig gepatcht, aber Code gefunden, der nicht half und Probleme damit hatte. Deshalb habe ich es in ein paar Funktionen geändert (um zu sparen, dass ich ständig nach der Liste von Mozilla frage und das Cache-System entferne). Dies wurde gegen einen Satz von 1000 URLs getestet und schien zu funktionieren.

function domain($url)
{
    global $subtlds;
    $slds = "";
    $url = strtolower($url);

    $host = parse_url('http://'.$url,PHP_URL_HOST);

    preg_match("/[^\.\/]+\.[^\.\/]+$/", $host, $matches);
    foreach($subtlds as $sub){
        if (preg_match('/\.'.preg_quote($sub).'$/', $host, $xyz)){
            preg_match("/[^\.\/]+\.[^\.\/]+\.[^\.\/]+$/", $host, $matches);
        }
    }

    return @$matches[0];
}

function get_tlds() {
    $address = 'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1';
    $content = file($address);
    foreach ($content as $num => $line) {
        $line = trim($line);
        if($line == '') continue;
        if(@substr($line[0], 0, 2) == '/') continue;
        $line = @preg_replace("/[^a-zA-Z0-9\.]/", '', $line);
        if($line == '') continue;  //$line = '.'.$line;
        if(@$line[0] == '.') $line = substr($line, 1);
        if(!strstr($line, '.')) continue;
        $subtlds[] = $line;
        //echo "{$num}: '{$line}'"; echo "<br>";
    }

    $subtlds = array_merge(array(
            'co.uk', 'me.uk', 'net.uk', 'org.uk', 'sch.uk', 'ac.uk', 
            'gov.uk', 'nhs.uk', 'police.uk', 'mod.uk', 'asn.au', 'com.au',
            'net.au', 'id.au', 'org.au', 'edu.au', 'gov.au', 'csiro.au'
        ), $subtlds);

    $subtlds = array_unique($subtlds);

    return $subtlds;    
}

Dann benutze es wie

$subtlds = get_tlds();
echo domain('www.example.com') //outputs: example.com
echo domain('www.example.uk.com') //outputs: example.uk.com
echo domain('www.example.fr') //outputs: example.fr

Ich weiß, ich hätte daraus eine Klasse machen sollen, hatte aber keine Zeit.

function get_domain($url = SITE_URL)
{
    preg_match("/[a-z0-9\-]{1,63}\.[a-z\.]{2,6}$/", parse_url($url, PHP_URL_HOST), $_domain_tld);
    return $_domain_tld[0];
}

get_domain('http://www.cdl.gr'); //cdl.gr
get_domain('http://cdl.gr'); //cdl.gr
get_domain('http://www2.cdl.gr'); //cdl.gr

Wenn Sie einen Host aus einem String extrahieren möchten http://google.com/dhasjkdas/sadsdds/sdda/sdads.html, ist die Verwendung von parse_url () für Sie eine akzeptable Lösung.

Wenn Sie jedoch die Domäne oder ihre Teile extrahieren möchten, benötigen Sie ein Paket, das die öffentliche Suffixliste verwendet . Ja, Sie können Zeichenfolgenfunktionen um parse_url () verwenden, aber manchmal werden falsche Ergebnisse erzielt.

Ich empfehle TLDExtract für das Domain-Parsing. Hier ist ein Beispielcode, der diff zeigt:

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

# For 'http://google.com/dhasjkdas/sadsdds/sdda/sdads.html'

$url = 'http://google.com/dhasjkdas/sadsdds/sdda/sdads.html';

parse_url($url, PHP_URL_HOST); // will return google.com

$result = $extract->parse($url);
$result->getFullHost(); // will return 'google.com'
$result->getRegistrableDomain(); // will return 'google.com'
$result->getSuffix(); // will return 'com'

# For 'http://search.google.com/dhasjkdas/sadsdds/sdda/sdads.html'

$url = 'http://search.google.com/dhasjkdas/sadsdds/sdda/sdads.html';

parse_url($url, PHP_URL_HOST); // will return 'search.google.com'

$result = $extract->parse($url);
$result->getFullHost(); // will return 'search.google.com'
$result->getRegistrableDomain(); // will return 'google.com'

Ich habe festgestellt, dass die Lösung von @ philfreo (von php.net referenziert) ziemlich gut ist, um ein gutes Ergebnis zu erzielen, aber in einigen Fällen zeigt sie die Meldung "Notice" und "Strict Standards" von php. Hier eine feste Version dieses Codes.

function getHost($url) { 
   $parseUrl = parse_url(trim($url)); 
   if(isset($parseUrl['host']))
   {
       $host = $parseUrl['host'];
   }
   else
   {
        $path = explode('/', $parseUrl['path']);
        $host = $path[0];
   }
   return trim($host); 
} 

echo getHost("http://example.com/anything.html");           // example.com
echo getHost("http://www.example.net/directory/post.php");  // www.example.net
echo getHost("https://example.co.uk");                      // example.co.uk
echo getHost("www.example.net");                            // example.net
echo getHost("subdomain.example.net/anything");             // subdomain.example.net
echo getHost("example.net");                                // example.net

Hier ist der Code, den ich gemacht habe, dass 100% nur den Domainnamen findet, da Mozilla-Subtlds berücksichtigt werden. Sie müssen nur überprüfen, wie Sie den Cache dieser Datei erstellen, damit Sie Mozilla nicht jedes Mal abfragen.

Aus irgendeinem seltsamen Grund sind Domains wie co.uk nicht in der Liste enthalten, daher müssen Sie einige Hacking-Aktionen durchführen und sie manuell hinzufügen. Es ist nicht die sauberste Lösung, aber ich hoffe, es hilft jemandem.

//=====================================================
static function domain($url)
{
    $slds = "";
    $url = strtolower($url);

            $address = 'http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1';
    if(!$subtlds = @kohana::cache('subtlds', null, 60)) 
    {
        $content = file($address);
        foreach($content as $num => $line)
        {
            $line = trim($line);
            if($line == '') continue;
            if(@substr($line[0], 0, 2) == '/') continue;
            $line = @preg_replace("/[^a-zA-Z0-9\.]/", '', $line);
            if($line == '') continue;  //$line = '.'.$line;
            if(@$line[0] == '.') $line = substr($line, 1);
            if(!strstr($line, '.')) continue;
            $subtlds[] = $line;
            //echo "{$num}: '{$line}'"; echo "<br>";
        }
        $subtlds = array_merge(Array(
            'co.uk', 'me.uk', 'net.uk', 'org.uk', 'sch.uk', 'ac.uk', 
            'gov.uk', 'nhs.uk', 'police.uk', 'mod.uk', 'asn.au', 'com.au',
            'net.au', 'id.au', 'org.au', 'edu.au', 'gov.au', 'csiro.au',
            ),$subtlds);

        $subtlds = array_unique($subtlds);
        //echo var_dump($subtlds);
        @kohana::cache('subtlds', $subtlds);
    }


    preg_match('/^(http:[\/]{2,})?([^\/]+)/i', $url, $matches);
    //preg_match("/^(http:\/\/|https:\/\/|)[a-zA-Z-]([^\/]+)/i", $url, $matches);
    $host = @$matches[2];
    //echo var_dump($matches);

    preg_match("/[^\.\/]+\.[^\.\/]+$/", $host, $matches);
    foreach($subtlds as $sub) 
    {
        if (preg_match("/{$sub}$/", $host, $xyz))
        preg_match("/[^\.\/]+\.[^\.\/]+\.[^\.\/]+$/", $host, $matches);
    }

    return @$matches[0];
}

Sie können PHP_URL_HOST als zweiten Parameter an die Funktion parse_url übergeben

$url = 'http://google.com/dhasjkdas/sadsdds/sdda/sdads.html';
$host = parse_url($url, PHP_URL_HOST);
print $host; // prints 'google.com'

$domain = parse_url($url, PHP_URL_HOST);
echo implode('.', array_slice(explode('.', $domain), -2, 2))

Bitte ersetzen Sie die akzeptierte Lösung durch Folgendes:

parse_url () enthält immer alle Subdomains, daher analysiert diese Funktion Domainnamen nicht sehr gut. Hier sind einige Beispiele:

$url = 'http://www.google.com/dhasjkdas/sadsdds/sdda/sdads.html';
$parse = parse_url($url);
echo $parse['host']; // prints 'www.google.com'

echo parse_url('https://subdomain.example.com/foo/bar', PHP_URL_HOST);
// Output: subdomain.example.com

echo parse_url('https://subdomain.example.co.uk/foo/bar', PHP_URL_HOST);
// Output: subdomain.example.co.uk

Stattdessen können Sie diese pragmatische Lösung in Betracht ziehen. Es werden viele, aber nicht alle Domainnamen abgedeckt. Beispielsweise werden untergeordnete Domains wie 'sos.state.oh.us' nicht behandelt.

function getDomain($url) {
    $host = parse_url($url, PHP_URL_HOST);

    if(filter_var($host,FILTER_VALIDATE_IP)) {
        // IP address returned as domain
        return $host; //* or replace with null if you don't want an IP back
    }

    $domain_array = explode(".", str_replace('www.', '', $host));
    $count = count($domain_array);
    if( $count>=3 && strlen($domain_array[$count-2])==2 ) {
        // SLD (example.co.uk)
        return implode('.', array_splice($domain_array, $count-3,3));
    } else if( $count>=2 ) {
        // TLD (example.com)
        return implode('.', array_splice($domain_array, $count-2,2));
    }
}

// Your domains
    echo getDomain('http://google.com/dhasjkdas/sadsdds/sdda/sdads.html'); // google.com
    echo getDomain('http://www.google.com/dhasjkdas/sadsdds/sdda/sdads.html'); // google.com
    echo getDomain('http://google.co.uk/dhasjkdas/sadsdds/sdda/sdads.html'); // google.co.uk

// TLD
    echo getDomain('https://shop.example.com'); // example.com
    echo getDomain('https://foo.bar.example.com'); // example.com
    echo getDomain('https://www.example.com'); // example.com
    echo getDomain('https://example.com'); // example.com

// SLD
    echo getDomain('https://more.news.bbc.co.uk'); // bbc.co.uk
    echo getDomain('https://www.bbc.co.uk'); // bbc.co.uk
    echo getDomain('https://bbc.co.uk'); // bbc.co.uk

// IP
    echo getDomain('https://1.2.3.45');  // 1.2.3.45

Mit dem PHP Domain Parser von Jeremy Kendall können Sie den Domainnamen anhand einer URL analysieren. League URI Hostname Parser erledigt ebenfalls die Aufgabe.

parse_url hat bei mir nicht funktioniert. Es gab nur den Pfad zurück. Mit php5.3 + zu den Grundlagen wechseln:

$url  = str_replace('http://', '', strtolower( $s->website));
if (strpos($url, '/'))  $url = strstr($url, '/', true);

Ich habe für Sie bearbeitet:

function getHost($Address) { 
    $parseUrl = parse_url(trim($Address));
    $host = trim($parseUrl['host'] ? $parseUrl['host'] : array_shift(explode('/', $parseUrl['path'], 2))); 

    $parts = explode( '.', $host );
    $num_parts = count($parts);

    if ($parts[0] == "www") {
        for ($i=1; $i < $num_parts; $i++) { 
            $h .= $parts[$i] . '.';
        }
    }else {
        for ($i=0; $i < $num_parts; $i++) { 
            $h .= $parts[$i] . '.';
        }
    }
    return substr($h,0,-1);
}

Alle Typ-URLs (www.domain.ltd, sub1.subn.domain.ltd) ergeben: domain.ltd.

Ich füge diese Antwort spät hinzu, da dies die Antwort ist, die bei Google am häufigsten auftaucht ...

Sie können PHP verwenden, um ...

$url = "www.google.co.uk";
$host = parse_url($url, PHP_URL_HOST);
// $host == "www.google.co.uk"

um den Host zu greifen, aber nicht die private Domain, auf die sich der Host bezieht. (Beispiel www.google.co.ukist der Host, aber google.co.ukdie private Domain)

Um die private Domain zu erhalten, müssen Sie die Liste der öffentlichen Suffixe kennen, für die eine private Domain registriert werden kann . Diese Liste wird zufällig von Mozilla unter https://publicsuffix.org/ kuratiert.

Der folgende Code funktioniert, wenn bereits ein Array öffentlicher Suffixe erstellt wurde. Einfach anrufen

$domain = get_private_domain("www.google.co.uk");

mit dem restlichen Code ...

// find some way to parse the above list of public suffix
// then add them to a PHP array
$suffix = [... all valid public suffix ...];

function get_public_suffix($host) {
  $parts = split("\.", $host);
  while (count($parts) > 0) {
    if (is_public_suffix(join(".", $parts)))
      return join(".", $parts);

    array_shift($parts);
  }

  return false;
}

function is_public_suffix($host) {
  global $suffix;
  return isset($suffix[$host]);
}

function get_private_domain($host) {
  $public = get_public_suffix($host);
  $public_parts = split("\.", $public);
  $all_parts = split("\.", $host);

  $private = [];

  for ($x = 0; $x < count($public_parts); ++$x) 
    $private[] = array_pop($all_parts);

  if (count($all_parts) > 0)
    $private[] = array_pop($all_parts);

  return join(".", array_reverse($private));
}

Dies funktioniert im Allgemeinen sehr gut, wenn die Eingabe-URL nicht Junk ist. Es entfernt die Subdomain.

$host = parse_url( $Row->url, PHP_URL_HOST );
$parts = explode( '.', $host );
$parts = array_reverse( $parts );
$domain = $parts[1].'.'.$parts[0];

Beispiel

Eingang: http://www2.website.com:8080/some/file/structure?some=parameters

Ausgabe: website.com

Kombinieren Sie die Antworten von worldofjr und Alix Axel zu einer kleinen Funktion, die die meisten Anwendungsfälle behandelt:

function get_url_hostname($url) {

    $parse = parse_url($url);
    return str_ireplace('www.', '', $parse['host']);

}

get_url_hostname('http://www.google.com/example/path/file.html'); // google.com

function getTrimmedUrl($link)
{
    $str = str_replace(["www.","https://","http://"],[''],$link);
    $link = explode("/",$str);
    return strtolower($link[0]);                
}

Schauen Sie sich parse_url () an

Verwenden Sie einfach wie folgt ...

<?php
   echo $_SERVER['SERVER_NAME'];
?>