Chciałbym dopasować tylko katalog główny adresu URL, a nie cały adres URL z ciągu tekstowego. Dany:

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

Chcę uzyskać rozstrzygnięcie 2 ostatnich instancji w domenie www.example.comlub example.com.

Słyszałem, że wyrażenie regularne jest wolne i będzie to moje drugie wyrażenie wyrażenia regularnego na stronie, więc jeśli istnieje możliwość zrobienia tego bez wyrażenia regularnego, daj mi znać.

Szukam wersji tego rozwiązania JS / jQuery.

Polecam użycie pakietu npm psl (Public Suffix List) . „Publiczna lista sufiksów” to lista wszystkich prawidłowych sufiksów i reguł domeny, nie tylko domen najwyższego poziomu kodu kraju, ale także znaków Unicode, które można by uznać za domenę główną (tj. Www. 食 狮. 公司 .cn, bckobe .jp itp.). Przeczytaj więcej na ten temat tutaj .

Próbować:

npm install --save psl

Następnie uruchom moją implementację „extractHostname”:

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

Nie mogę użyć pakietu npm, więc poniżej tylko testy extractHostname.

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"));

Niezależnie od tego, czy masz protokół, czy nawet numer portu, możesz wyodrębnić domenę. Jest to bardzo uproszczone, nieregexowe rozwiązanie, więc myślę, że tak się stanie.

* Dziękuję za @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson za sugestie! @ ross-allen, dziękuję za zgłoszenie błędu!

Zgrabna sztuczka bez użycia wyrażeń regularnych:

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'

Zawinąć powyższe w funkcję taką jak poniżej, a masz doskonały sposób na wyrwanie części domeny z identyfikatora URI.

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

Nie ma potrzeby analizowania łańcucha, wystarczy przekazać adres URL jako argument do URLkonstruktora :

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

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

Spróbuj tego:

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

Jeśli chcesz wykluczyć port z wyniku, użyj tego wyrażenia:

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

Edycja: aby zapobiec dopasowaniu określonych domen, użyj negatywnego spojrzenia w przyszłość.(?!youtube.com)

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

Analiza adresu URL może być trudna, ponieważ możesz mieć numery portów i znaki specjalne. Jako taki, zalecam użycie do tego czegoś takiego jak parseUri . Wątpię, czy wydajność będzie stanowić problem, chyba że analizujesz setki adresów URL.

Odpowiedź na 2020 r

Nie potrzebujesz do tego żadnych dodatkowych zależności! W zależności od tego, czy chcesz zoptymalizować wydajność, czy nie, istnieją dwa dobre rozwiązania:

Użyj URL.hostnamedla czytelności

W erze Babel najczystszym i najłatwiejszym rozwiązaniem jest użycie 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.hostnamejest częścią interfejsu API URL , obsługiwanego przez wszystkie główne przeglądarki oprócz IE ( caniuse ). Użyj wielopełniacza adresu URL, jeśli chcesz obsługiwać starsze przeglądarki.

Korzystanie z tego rozwiązania zapewni również dostęp do innych właściwości i metod adresów URL . Będzie to przydatne, jeśli na przykład chcesz wyodrębnić nazwę ścieżki URL lub parametry ciągu zapytania .

Użyj RegEx dla wydajności

URL.hostnamejest szybszy niż użycie rozwiązania kotwicy lub parseUri . Jednak wciąż jest znacznie wolniejszy niż regex 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"));

Sprawdź to sam na tym jsPerf

Jeśli potrzebujesz przetworzyć bardzo dużą liczbę adresów URL (gdzie wydajność byłaby czynnikiem), zalecamy użycie tego rozwiązania. W przeciwnym razie wybierz URL.hostnamedla czytelności.

Próbowałem użyć rozwiązań podanych, Wybrany był dla mnie przesadą, a „Tworzenie elementu” dla mnie zadzierało.

Nie jest jeszcze gotowy na port w adresie URL. Mam nadzieję, że ktoś uzna to za przydatne

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

Uruchamianie tego:

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

Wynik:

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

Jeśli znajdziesz się na tej stronie i szukasz najlepszego REGEXU adresów URL, spróbuj tego:

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

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

Działa dla adresów URL bez http: //, z http, z https, z just // i nie przechwytuj również ścieżki i ścieżki zapytania.

Powodzenia

Wszystkie właściwości adresu URL, brak zależności, brak JQuery, łatwe do zrozumienia

To rozwiązanie daje odpowiedź i dodatkowe właściwości. Nie wymaga JQuery ani innych zależności, wklej i uruchom.

Stosowanie

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

Wynik

{
  "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"
    }
  ]
}

Kod
Kod został zaprojektowany tak, aby był łatwy do zrozumienia, a nie bardzo szybki. Można go łatwo wywołać 100 razy na sekundę, więc świetnie nadaje się do frontonu lub kilku zastosowań serwera, ale nie do dużej przepustowości.

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
}

Wystarczy użyć konstruktora URL () :

new URL(url).host

Szukałem dziś rozwiązania tego problemu. Żadna z powyższych odpowiedzi nie wydawała się satysfakcjonująca. Chciałem rozwiązania, które mogłoby być jednowierszowe, bez logiki warunkowej i niczego, co musiałoby być zawinięte w funkcję.

Oto, co wymyśliłem, wydaje się działać naprawdę dobrze:

nazwa hosta = „http://www.example.com:1234”
nazwa_hosta.split ("//"). slice (-1) [0] .split (":") [0] .split ('.'). slice (-2) .join ('.') // daje „example.com”

Na pierwszy rzut oka może wydawać się skomplikowany, ale działa dość prosto; klucz używa „slice (-n)” w kilku miejscach, w których należy wyciągnąć dobrą część z końca podzielonej tablicy (i [0], aby dostać się z przodu podzielonej tablicy).

Każdy z tych testów zwraca „example.com”:

„http://example.com” .split („//”). slice (-1) [0] .split („:”) [0] .split ('.'). slice (-2). Przystąp('.')
„http://example.com:1234".split("//").slice(-1)[0].split(":")[0].split('.').slice(-2 ).Przystąp('.')
„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 ('.')

Oto jedna linijka jQuery:

$('<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];
}

Powyższy kod pomyślnie przeanalizuje nazwy hostów dla następujących przykładowych adresów URL:

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 wherewhere.com

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

Pierwotny kredyt trafia do: http://www.primaryobjects.com/CMS/Article145

Okej, wiem, że to stare pytanie, ale zrobiłem super wydajny parser adresów URL, więc pomyślałem, że podzielę się nim.

Jak widać, struktura funkcji jest bardzo dziwna, ale pod względem wydajności. Żadne funkcje prototypowe nie są używane, ciąg nie jest iterowany więcej niż jeden raz i żaden znak nie jest przetwarzany bardziej niż to konieczne.

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

To nie jest pełna odpowiedź, ale poniższy kod powinien ci pomóc:

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

Chciałbym, żeby ktoś tworzył kod szybciej niż mój. Pomaga także poprawić siebie.

oneline z 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]+.)/,"");
}

Osobiście dużo szukałem tego rozwiązania, a najlepsze, jakie mogłem znaleźć, to w rzeczywistości „sprawdzenie przeglądarki” przez CloudFlare:

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();

Przepisałem zmienne, aby były bardziej „ludzkie”, ale spełnia to zadanie lepiej niż oczekiwano.

Cóż, używanie wyrażenia regularnego będzie o wiele łatwiejsze:

    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, ''));

zajmuje się to zarówno protokołem.

w skrócie możesz to zrobić

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"

Użyj powyższej funkcji, aby uzyskać nazwę domeny

Parse-Urls wydaje się być biblioteką JavaScript z najbardziej niezawodnymi wzorami

Oto podsumowanie funkcji:

Rozdział 1. Normalizuj lub parsuj jeden adres URL

Rozdział 2. Wyodrębnij wszystkie adresy URL

Rozdział 3. Wyodrębnij identyfikatory URI o określonych nazwach

Rozdział 4. Wyodrębnij wszystkie rozmyte adresy URL

Rozdział 5. Podświetl wszystkie adresy URL w tekstach

Rozdział 6. Wyodrębnij wszystkie adresy URL w nieprzetworzonym HTML lub XML

Kod:

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

Wynik:

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

parsowana domena - bardzo solidna i lekka biblioteka

npm install parse-domain

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

Przykład 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' ] }

Przykład 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' ] }

Czemu?

W zależności od przypadku użycia i objętości zdecydowanie odradzam samodzielne rozwiązywanie tego problemu za pomocą wyrażeń regularnych lub innych metod manipulacji ciągami. Istotą tego problemu jest to, że musisz znać wszystkie sufiksy gtld i cctld, aby poprawnie parsować ciągi adresów URL w domenie i poddomenach. Sufiksy te są regularnie aktualizowane. To rozwiązany problem, a nie taki, który chcesz rozwiązać samodzielnie (chyba że jesteś google lub coś takiego). Chyba, że ​​potrzebujesz nazwy hosta lub nazwy domeny w skrócie, nie próbuj parsować swojego wyjścia.

Mój kod wygląda tak. Wyrażenia regularne mogą przybierać różne formy, a oto moje przypadki testowe, myślę, że są bardziej skalowalne.

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))

Wypróbuj poniższy kod, aby uzyskać dokładną nazwę domeny, używając wyrażenia regularnego,

Ciąg znaków = „ 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");
  }