Extrahieren Sie den Namen des Hostnamens aus der Zeichenfolge

Ich möchte nur den Stamm einer URL und nicht die gesamte URL einer Textzeichenfolge abgleichen. Gegeben:

http://www.youtube.com/watch?v=ClkQA2Lb_iE
http://youtu.be/ClkQA2Lb_iE
http://www.example.com/12xy45
http://example.com/random

Ich möchte, dass die 2 letzten Instanzen in die Domäne www.example.comoder aufgelöst werden example.com.

Ich habe gehört, dass Regex langsam ist und dies mein zweiter Regex-Ausdruck auf der Seite wäre. Wenn es also sowieso möglich ist, es ohne Regex zu tun, lass es mich wissen.

Ich suche eine JS / jQuery-Version dieser Lösung.

Ich empfehle die Verwendung des npm-Pakets psl (Public Suffix List) . Die "Öffentliche Suffixliste" ist eine Liste aller gültigen Domain-Suffixe und -Regeln, nicht nur Ländercode-Top-Level-Domains, sondern auch Unicode-Zeichen, die als Root-Domain gelten würden (z. B. www. 食 狮. 公司 .cn, bckobe .jp usw.). Lesen Sie hier mehr darüber .

Versuchen:

npm install --save psl

Dann mit meiner Implementierung "extractHostname" ausführen:

let psl = require('psl');
let url = 'http://www.youtube.com/watch?v=ClkQA2Lb_iE';
psl.get(extractHostname(url)); // returns youtube.com

Ich kann kein npm-Paket verwenden, daher wird im Folgenden nur extractHostname getestet.

function extractHostname(url) {
    var hostname;
    //find & remove protocol (http, ftp, etc.) and get hostname

    if (url.indexOf("//") > -1) {
        hostname = url.split('/')[2];
    }
    else {
        hostname = url.split('/')[0];
    }

    //find & remove port number
    hostname = hostname.split(':')[0];
    //find & remove "?"
    hostname = hostname.split('?')[0];

    return hostname;
}

//test the code
console.log("== Testing extractHostname: ==");
console.log(extractHostname("http://www.blog.classroom.me.uk/index.php"));
console.log(extractHostname("http://www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("https://www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("www.youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("ftps://ftp.websitename.com/dir/file.txt"));
console.log(extractHostname("websitename.com:1234/dir/file.txt"));
console.log(extractHostname("ftps://websitename.com:1234/dir/file.txt"));
console.log(extractHostname("example.com?param=value"));
console.log(extractHostname("https://facebook.github.io/jest/"));
console.log(extractHostname("//youtube.com/watch?v=ClkQA2Lb_iE"));
console.log(extractHostname("http://localhost:4200/watch?v=ClkQA2Lb_iE"));

Unabhängig vom Protokoll oder der Portnummer können Sie die Domäne extrahieren. Dies ist eine sehr vereinfachte Lösung ohne Regex, daher denke ich, dass dies ausreichen wird.

* Vielen Dank an @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson für Ihre Vorschläge! @ Ross-Allen, danke, dass du den Fehler gemeldet hast!

Ein ordentlicher Trick ohne reguläre Ausdrücke:

var tmp        = document.createElement ('a');
;   tmp.href   = "http://www.example.com/12xy45";

// tmp.hostname will now contain 'www.example.com'
// tmp.host will now contain hostname and port 'www.example.com:80'

Wenn Sie das Obige in eine Funktion wie die folgende einschließen, haben Sie selbst eine hervorragende Möglichkeit, den Domain-Teil aus einer URI zu entreißen.

function url_domain(data) {
  var    a      = document.createElement('a');
         a.href = data;
  return a.hostname;
}

Die Zeichenfolge muss nicht analysiert werden. Übergeben Sie einfach Ihre URL als Argument an den URLKonstruktor :

var url = 'http://www.youtube.com/watch?v=ClkQA2Lb_iE';
var hostname = (new URL(url)).hostname;

assert(hostname === 'www.youtube.com');

Versuche dies:

var matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
var domain = matches && matches[1];  // domain will be null if no match is found

Wenn Sie den Port von Ihrem Ergebnis ausschließen möchten, verwenden Sie stattdessen diesen Ausdruck:

/^https?\:\/\/([^\/:?#]+)(?:[\/:?#]|$)/i

Bearbeiten: Um zu verhindern, dass bestimmte Domänen übereinstimmen, verwenden Sie einen negativen Lookahead.(?!youtube.com)

/^https?\:\/\/(?!(?:www\.)?(?:youtube\.com|youtu\.be))([^\/:?#]+)(?:[\/:?#]|$)/i

Das Parsen einer URL kann schwierig sein, da Sie Portnummern und Sonderzeichen haben können. Daher empfehle ich, etwas wie parseUri zu verwenden, um dies für Sie zu tun. Ich bezweifle, dass die Leistung ein Problem sein wird, wenn Sie nicht Hunderte von URLs analysieren.

Zur URL.hostnamebesseren Lesbarkeit verwenden

In der Babel-Ära ist die Verwendung die sauberste und einfachste Lösung URL.hostname.

const getHostname = (url) => {
  // use URL constructor and return hostname
  return new URL(url).hostname;
}

// tests
console.log(getHostname("/programming/8498592/extract-hostname-name-from-string/"));
console.log(getHostname("https://developer.mozilla.org/en-US/docs/Web/API/URL/hostname"));

URL.hostnameist Teil der URL-API , die von allen gängigen Browsern außer IE ( caniuse ) unterstützt wird. Verwenden Sie eine URL-Polyfüllung, wenn Sie ältere Browser unterstützen müssen.

Mit dieser Lösung erhalten Sie auch Zugriff auf andere URL-Eigenschaften und -Methoden . Dies ist nützlich, wenn Sie beispielsweise auch den Pfadnamen oder die Abfragezeichenfolgenparameter der URL extrahieren möchten .

Verwenden Sie RegEx für die Leistung

URL.hostnameist schneller als die Verwendung von Ankerlösung oder parseUri . Es ist jedoch immer noch viel langsamer als der reguläre Ausdruck von gilly3 :

const getHostnameFromRegex = (url) => {
  // run against regex
  const matches = url.match(/^https?\:\/\/([^\/?#]+)(?:[\/?#]|$)/i);
  // extract hostname (will be null if no match is found)
  return matches && matches[1];
}

// tests
console.log(getHostnameFromRegex("/programming/8498592/extract-hostname-name-from-string/"));
console.log(getHostnameFromRegex("https://developer.mozilla.org/en-US/docs/Web/API/URL/hostname"));

Testen Sie es selbst auf diesem jsPerf

Wenn Sie eine sehr große Anzahl von URLs verarbeiten müssen (wobei die Leistung eine Rolle spielt), empfehle ich stattdessen die Verwendung dieser Lösung. Andernfalls wählen Sie die URL.hostnameLesbarkeit.

Ich habe versucht, die gegebenen Lösungen zu verwenden, die gewählte war ein Overkill für meinen Zweck und "Erstellen eines Elements" bringt mich durcheinander.

Es ist noch nicht bereit für Port in URL. Ich hoffe, jemand findet es nützlich

function parseURL(url){
    parsed_url = {}

    if ( url == null || url.length == 0 )
        return parsed_url;

    protocol_i = url.indexOf('://');
    parsed_url.protocol = url.substr(0,protocol_i);

    remaining_url = url.substr(protocol_i + 3, url.length);
    domain_i = remaining_url.indexOf('/');
    domain_i = domain_i == -1 ? remaining_url.length - 1 : domain_i;
    parsed_url.domain = remaining_url.substr(0, domain_i);
    parsed_url.path = domain_i == -1 || domain_i + 1 == remaining_url.length ? null : remaining_url.substr(domain_i + 1, remaining_url.length);

    domain_parts = parsed_url.domain.split('.');
    switch ( domain_parts.length ){
        case 2:
          parsed_url.subdomain = null;
          parsed_url.host = domain_parts[0];
          parsed_url.tld = domain_parts[1];
          break;
        case 3:
          parsed_url.subdomain = domain_parts[0];
          parsed_url.host = domain_parts[1];
          parsed_url.tld = domain_parts[2];
          break;
        case 4:
          parsed_url.subdomain = domain_parts[0];
          parsed_url.host = domain_parts[1];
          parsed_url.tld = domain_parts[2] + '.' + domain_parts[3];
          break;
    }

    parsed_url.parent_domain = parsed_url.host + '.' + parsed_url.tld;

    return parsed_url;
}

Führen Sie dies aus:

parseURL('https://www.facebook.com/100003379429021_356001651189146');

Ergebnis:

Object {
    domain : "www.facebook.com",
    host : "facebook",
    path : "100003379429021_356001651189146",
    protocol : "https",
    subdomain : "www",
    tld : "com"
}

Wenn Sie auf dieser Seite landen und nach dem besten REGEX von URLs suchen, versuchen Sie Folgendes:

^(?:https?:)?(?:\/\/)?([^\/\?]+)

https://regex101.com/r/pX5dL9/1

Es funktioniert für URLs ohne http: //, mit http, mit https, mit nur // und greift nicht auf den Pfad und den Abfragepfad zu.

Viel Glück

Alle URL-Eigenschaften, keine Abhängigkeiten, keine JQuery, leicht zu verstehen

Diese Lösung gibt Ihre Antwort sowie zusätzliche Eigenschaften. Keine JQuery oder andere Abhängigkeiten erforderlich, einfügen und loslegen.

Verwendung

getUrlParts("https://news.google.com/news/headlines/technology.html?ned=us&hl=en")

Ausgabe

{
  "origin": "https://news.google.com",
  "domain": "news.google.com",
  "subdomain": "news",
  "domainroot": "google.com",
  "domainpath": "news.google.com/news/headlines",
  "tld": ".com",
  "path": "news/headlines/technology.html",
  "query": "ned=us&hl=en",
  "protocol": "https",
  "port": 443,
  "parts": [
    "news",
    "google",
    "com"
  ],
  "segments": [
    "news",
    "headlines",
    "technology.html"
  ],
  "params": [
    {
      "key": "ned",
      "val": "us"
    },
    {
      "key": "hl",
      "val": "en"
    }
  ]
}

Code
Der Code ist so konzipiert, dass er leicht zu verstehen und nicht sehr schnell ist. Es kann problemlos 100 Mal pro Sekunde aufgerufen werden, eignet sich also hervorragend für das Front-End oder einige Server-Anwendungen, jedoch nicht für einen hohen Volumendurchsatz.

function getUrlParts(fullyQualifiedUrl) {
    var url = {},
        tempProtocol
    var a = document.createElement('a')
    // if doesn't start with something like https:// it's not a url, but try to work around that
    if (fullyQualifiedUrl.indexOf('://') == -1) {
        tempProtocol = 'https://'
        a.href = tempProtocol + fullyQualifiedUrl
    } else
        a.href = fullyQualifiedUrl
    var parts = a.hostname.split('.')
    url.origin = tempProtocol ? "" : a.origin
    url.domain = a.hostname
    url.subdomain = parts[0]
    url.domainroot = ''
    url.domainpath = ''
    url.tld = '.' + parts[parts.length - 1]
    url.path = a.pathname.substring(1)
    url.query = a.search.substr(1)
    url.protocol = tempProtocol ? "" : a.protocol.substr(0, a.protocol.length - 1)
    url.port = tempProtocol ? "" : a.port ? a.port : a.protocol === 'http:' ? 80 : a.protocol === 'https:' ? 443 : a.port
    url.parts = parts
    url.segments = a.pathname === '/' ? [] : a.pathname.split('/').slice(1)
    url.params = url.query === '' ? [] : url.query.split('&')
    for (var j = 0; j < url.params.length; j++) {
        var param = url.params[j];
        var keyval = param.split('=')
        url.params[j] = {
            'key': keyval[0],
            'val': keyval[1]
        }
    }
    // domainroot
    if (parts.length > 2) {
        url.domainroot = parts[parts.length - 2] + '.' + parts[parts.length - 1];
        // check for country code top level domain
        if (parts[parts.length - 1].length == 2 && parts[parts.length - 1].length == 2)
            url.domainroot = parts[parts.length - 3] + '.' + url.domainroot;
    }
    // domainpath (domain+path without filenames) 
    if (url.segments.length > 0) {
        var lastSegment = url.segments[url.segments.length - 1]
        var endsWithFile = lastSegment.indexOf('.') != -1
        if (endsWithFile) {
            var fileSegment = url.path.indexOf(lastSegment)
            var pathNoFile = url.path.substr(0, fileSegment - 1)
            url.domainpath = url.domain
            if (pathNoFile)
                url.domainpath = url.domainpath + '/' + pathNoFile
        } else
            url.domainpath = url.domain + '/' + url.path
    } else
        url.domainpath = url.domain
    return url
}

Benutz einfach den URL () -Konstruktor :

new URL(url).host

Ich habe heute nach einer Lösung für dieses Problem gesucht. Keine der obigen Antworten schien zu befriedigen. Ich wollte eine Lösung, die ein Einzeiler sein kann, keine bedingte Logik und nichts, was in eine Funktion eingeschlossen werden muss.

Folgendes habe ich mir ausgedacht, scheint wirklich gut zu funktionieren:

hostname = "http://www.example.com:1234"
Hostname.split ("//"). Slice (-1) [0] .split (":") [0] .split ('.'). Slice (-2) .join ('.') // gibt "example.com"

Mag auf den ersten Blick kompliziert aussehen, aber es funktioniert ziemlich einfach; Der Schlüssel verwendet 'Slice (-n)' an einigen Stellen, an denen der gute Teil vom Ende gezogen werden muss des geteilten Arrays gezogen werden muss (und [0], um von der Vorderseite des geteilten Arrays zu gelangen).

Jeder dieser Tests gibt "example.com" zurück:

"http://example.com" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). Slice (-2). beitreten('.')
"http://example.com:1234".split("//").slice(-1)[0‹.split(":")[0‹.split('.').slice(-2 ).beitreten('.')
"http://www.example.com:1234" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). Slice ( -2) .join ('.')
"http://foo.www.example.com:1234" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). Slice (-2) .join ('.')

Hier ist der jQuery-Einzeiler:

$('<a>').attr('href', url).prop('hostname');

String.prototype.trim = function(){return his.replace(/^\s+|\s+$/g,"");}
function getHost(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    var _host,_arr;
    if(-1<url.indexOf("://")){
        _arr = url.split('://');
        if(-1<_arr[0].indexOf("/")||-1<_arr[0].indexOf(".")||-1<_arr[0].indexOf("\?")||-1<_arr[0].indexOf("\&")){
            _arr[0] = _arr[0].trim();
            if(0==_arr[0].indexOf("//")) _host = _arr[0].split("//")[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
            else return "";
        }
        else{
            _arr[1] = _arr[1].trim();
            _host = _arr[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
        }
    }
    else{
        if(0==url.indexOf("//")) _host = url.split("//")[1].split("/")[0].trim().split("\?")[0].split("\&")[0];
        else return "";
    }
    return _host;
}
function getHostname(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    return getHost(url).split(':')[0];
}
function getDomain(url){
    if("undefined"==typeof(url)||null==url) return "";
    url = url.trim(); if(""==url) return "";
    return getHostname(url).replace(/([a-zA-Z0-9]+.)/,"");
}

function hostname(url) {
    var match = url.match(/:\/\/(www[0-9]?\.)?(.[^/:]+)/i);
    if ( match != null && match.length > 2 && typeof match[2] === 'string' && match[2].length > 0 ) return match[2];
}

Der obige Code analysiert erfolgreich die Hostnamen für die folgenden Beispiel-URLs:

http://WWW.first.com/folder/page.html first.com

http://mail.google.com/folder/page.html mail.google.com

https://mail.google.com/folder/page.html mail.google.com

http://www2.somewhere.com/folder/page.html?q=1 irgendwo.com

https://www.another.eu/folder/page.html?q=1 another.eu

Das ursprüngliche Guthaben geht an: http://www.primaryobjects.com/CMS/Article145

Okay, ich weiß, dass dies eine alte Frage ist, aber ich habe einen supereffizienten URL-Parser erstellt, also dachte ich, ich würde ihn teilen.

Wie Sie sehen können, ist die Struktur der Funktion sehr seltsam, aber es dient der Effizienz. Es werden keine Prototypfunktionen verwendet, die Zeichenfolge wird nicht mehr als einmal iteriert und kein Zeichen wird mehr als erforderlich verarbeitet.

function getDomain(url) {
    var dom = "", v, step = 0;
    for(var i=0,l=url.length; i<l; i++) {
        v = url[i]; if(step == 0) {
            //First, skip 0 to 5 characters ending in ':' (ex: 'https://')
            if(i > 5) { i=-1; step=1; } else if(v == ':') { i+=2; step=1; }
        } else if(step == 1) {
            //Skip 0 or 4 characters 'www.'
            //(Note: Doesn't work with www.com, but that domain isn't claimed anyway.)
            if(v == 'w' && url[i+1] == 'w' && url[i+2] == 'w' && url[i+3] == '.') i+=4;
            dom+=url[i]; step=2;
        } else if(step == 2) {
            //Stop at subpages, queries, and hashes.
            if(v == '/' || v == '?' || v == '#') break; dom += v;
        }
    }
    return dom;
}

Dies ist keine vollständige Antwort, aber der folgende Code sollte Ihnen helfen:

function myFunction() {
    var str = "https://www.123rf.com/photo_10965738_lots-oop.html";
    matches = str.split('/');
    return matches[2];
}

Ich möchte, dass jemand Code schneller erstellt als ich. Es hilft auch, mich selbst zu verbessern.

online mit jquery

$('<a>').attr('href', document.location.href).prop('hostname');

// use this if you know you have a subdomain
// www.domain.com -> domain.com
function getDomain() {
  return window.location.hostname.replace(/([a-zA-Z0-9]+.)/,"");
}

Ich persönlich habe viel nach dieser Lösung gesucht, und die beste, die ich finden konnte, stammt aus CloudFlares "Browser-Check":

function getHostname(){  
            secretDiv = document.createElement('div');
            secretDiv.innerHTML = "<a href='/'>x</a>";
            secretDiv = secretDiv.firstChild.href;
            var HasHTTPS = secretDiv.match(/https?:\/\//)[0];
            secretDiv = secretDiv.substr(HasHTTPS.length);
            secretDiv = secretDiv.substr(0, secretDiv.length - 1);
            return(secretDiv);  
}  

getHostname();

Ich habe Variablen neu geschrieben, damit sie "menschlicher" lesbar sind, aber sie machen den Job besser als erwartet.

Die Verwendung eines regulären Ausdrucks ist viel einfacher:

    mainUrl = "http://www.mywebsite.com/mypath/to/folder";
    urlParts = /^(?:\w+\:\/\/)?([^\/]+)(.*)$/.exec(mainUrl);
    host = Fragment[1]; // www.mywebsite.com

import URL from 'url';

const pathname = URL.parse(url).path;
console.log(url.replace(pathname, ''));

Dies kümmert sich um beide Protokolle.

Kurz gesagt, Sie können dies tun

var url = "http://www.someurl.com/support/feature"

function getDomain(url){
  domain=url.split("//")[1];
  return domain.split("/")[0];
}
eg:
  getDomain("http://www.example.com/page/1")

  output:
   "www.example.com"

Verwenden Sie die obige Funktion, um den Domainnamen abzurufen

Parse-Urls scheint die JavaScript-Bibliothek mit den robustesten Mustern zu sein

Hier ist ein Überblick über die Funktionen:

Kapitel 1. Normalisieren oder analysieren Sie eine URL

Kapitel 2. Extrahieren Sie alle URLs

Kapitel 3. URIs mit bestimmten Namen extrahieren

Kapitel 4. Extrahieren Sie alle Fuzzy-URLs

Kapitel 5. Markieren Sie alle URLs in Texten

Kapitel 6. Extrahieren Sie alle URLs in Roh-HTML oder XML

Code:

var regex = /\w+.(com|co\.kr|be)/ig;
var urls = ['http://www.youtube.com/watch?v=ClkQA2Lb_iE',
            'http://youtu.be/ClkQA2Lb_iE',
            'http://www.example.com/12xy45',
            'http://example.com/random'];


$.each(urls, function(index, url) {
    var convertedUrl = url.match(regex);
    console.log(convertedUrl);
});

Ergebnis:

youtube.com
youtu.be
example.com
example.com

Parse-Domain - eine sehr solide, leichte Bibliothek

npm install parse-domain

const { fromUrl, parseDomain } = require("parse-domain");

Beispiel 1

parseDomain(fromUrl("http://www.example.com/12xy45"))

{ type: 'LISTED',
  hostname: 'www.example.com',
  labels: [ 'www', 'example', 'com' ],
  icann:
   { subDomains: [ 'www' ],
     domain: 'example',
     topLevelDomains: [ 'com' ] },
  subDomains: [ 'www' ],
  domain: 'example',
  topLevelDomains: [ 'com' ] }

Beispiel 2

parseDomain(fromUrl("http://subsub.sub.test.ExAmPlE.coM/12xy45"))

{ type: 'LISTED',
  hostname: 'subsub.sub.test.example.com',
  labels: [ 'subsub', 'sub', 'test', 'example', 'com' ],
  icann:
   { subDomains: [ 'subsub', 'sub', 'test' ],
     domain: 'example',
     topLevelDomains: [ 'com' ] },
  subDomains: [ 'subsub', 'sub', 'test' ],
  domain: 'example',
  topLevelDomains: [ 'com' ] }

Warum?

Je nach Anwendungsfall und Volumen empfehle ich dringend, dieses Problem nicht selbst mit Regex oder anderen Mitteln zur Manipulation von Zeichenfolgen zu lösen. Der Kern dieses Problems besteht darin, dass Sie alle Suffixe gtld und cctld kennen müssen, um URL-Zeichenfolgen ordnungsgemäß in Domänen und Subdomänen zu analysieren. Diese Suffixe werden regelmäßig aktualisiert. Dies ist ein gelöstes Problem und keines, das Sie selbst lösen möchten (es sei denn, Sie sind Google oder so). Versuchen Sie nicht, Ihren Weg aus diesem heraus zu analysieren, es sei denn, Sie benötigen zur Not den Host- oder Domainnamen.

Mein Code sieht so aus. Reguläre Ausdrücke können in vielen Formen vorliegen, und hier sind meine Testfälle, die meiner Meinung nach skalierbarer sind.

function extractUrlInfo(url){
  let reg = /^((?<protocol>http[s]?):\/\/)?(?<host>((\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])|[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)))(\:(?<port>[0-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5]))?$/
  return reg.exec(url).groups
}

var url = "https://192.168.1.1:1234"
console.log(extractUrlInfo(url))
var url = "/programming/8498592/extract-hostname-name-from-string"
console.log(extractUrlInfo(url))

Versuchen Sie den folgenden Code für den genauen Domainnamen mit Regex.

String line = " http://www.youtube.com/watch?v=ClkQA2Lb_iE ";

  String pattern3="([\\w\\W]\\.)+(.*)?(\\.[\\w]+)";

  Pattern r = Pattern.compile(pattern3);


  Matcher m = r.matcher(line);
  if (m.find( )) {

    System.out.println("Found value: " + m.group(2) );
  } else {
     System.out.println("NO MATCH");
  }