Vorrei abbinare solo la radice di un URL e non l'intero URL di una stringa di testo. Dato:

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

Voglio ottenere le ultime 2 istanze che si risolvono nel dominio www.example.como example.com.

Ho sentito che regex è lento e questa sarebbe la mia seconda espressione regex sulla pagina, quindi se c'è modo di farlo senza regex fammi sapere.

Sto cercando una versione JS / jQuery di questa soluzione.

Consiglio di usare il pacchetto npm psl (Elenco suffissi pubblico) . L '"Elenco dei suffissi pubblici" è un elenco di tutti i suffissi e le regole di dominio validi, non solo i domini di primo livello del codice Paese, ma anche i caratteri unicode che verrebbero considerati il ​​dominio principale (ovvero www. 食 狮. 公司 .cn, bckobe .jp, ecc.). Leggi di più qui .

Provare:

npm install --save psl

Quindi con la mia esecuzione di implementazione "extractHostname":

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

Non riesco a usare un pacchetto npm, quindi sotto solo i test 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"));

Indipendentemente dal protocollo o dal numero di porta, è possibile estrarre il dominio. Questa è una soluzione molto semplice, non regex, quindi penso che lo farà.

* Grazie @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson per i tuoi suggerimenti! @ ross-allen, grazie per aver segnalato il bug!

Un trucco pulito senza usare espressioni regolari:

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'

Avvolgi quanto sopra in una funzione come quella sotto e avrai un modo fantastico di strappare la parte del dominio da un URI.

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

Non è necessario analizzare la stringa, basta passare l'URL come argomento al URLcostruttore :

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

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

Prova questo:

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

Se si desidera escludere la porta dal risultato, utilizzare invece questa espressione:

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

Modifica: per impedire la corrispondenza di domini specifici, utilizzare un lookahead negativo.(?!youtube.com)

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

L'analisi di un URL può essere complicata perché puoi avere numeri di porta e caratteri speciali. Come tale, ti consiglio di usare qualcosa come parseUri per fare questo per te. Dubito che le prestazioni saranno un problema a meno che tu non stia analizzando centinaia di URL.

2020 risposta

Non hai bisogno di dipendenze extra per questo! A seconda che sia necessario ottimizzare le prestazioni o meno, esistono due buone soluzioni:

Uso URL.hostname per la leggibilità

Nell'era Babele, la soluzione più semplice e pulita è usare 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.hostnamefa parte dell'API URL , supportata da tutti i principali browser tranne IE ( caniuse ). Utilizzare un polyfill URL se è necessario supportare i browser legacy.

L'uso di questa soluzione ti darà anche accesso ad altre proprietà e metodi dell'URL . Ciò sarà utile se si desidera estrarre anche il nome del percorso dell'URL o i parametri della stringa di query , ad esempio.

Utilizzare RegEx per le prestazioni

URL.hostnameè più veloce rispetto all'utilizzo della soluzione di ancoraggio o parseUri . Tuttavia è ancora molto più lento del regex di 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"));

Provalo tu stesso su questo jsPerf

Se devi elaborare un numero molto elevato di URL (dove le prestazioni sarebbero un fattore), ti consiglio di utilizzare questa soluzione. Altrimenti, scegli URL.hostnameper leggibilità.

Ho provato ad usare le soluzioni fornite, quella scelta era una cosa eccessiva per il mio scopo e "Creare un elemento" mi ha incasinato.

Non è ancora pronto per Port in URL. Spero che qualcuno lo trovi utile

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

Eseguendo questo:

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

Risultato:

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

Se finisci in questa pagina e stai cercando il miglior REGEX di URL, prova questo:

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

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

Funziona per gli URL senza http: //, con http, con https, con solo // e non afferrare anche il percorso e il percorso della query.

In bocca al lupo

Tutte le proprietà dell'URL, nessuna dipendenza, niente JQuery, facile da capire

Questa soluzione fornisce la risposta più proprietà aggiuntive. Nessuna JQuery o altre dipendenze richieste, incolla e vai.

uso

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

Produzione

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

Codice
Il codice è progettato per essere facile da capire piuttosto che super veloce. Può essere chiamato facilmente 100 volte al secondo, quindi è ottimo per front-end o per alcuni usi del server, ma non per un volume elevato.

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
}

Basta usare il costruttore URL () :

new URL(url).host

Stavo cercando una soluzione a questo problema oggi. Nessuna delle risposte di cui sopra sembrava soddisfare. Volevo una soluzione che potesse essere una linea, nessuna logica condizionale e niente che dovesse essere racchiuso in una funzione.

Ecco cosa mi è venuto in mente, sembra funzionare davvero bene:

hostname = "http://www.example.com:1234"
hostname.split ("//"). slice (-1) [0] .split (":") [0] .split ('.'). slice (-2) .join ('.') // dà "esempio.com"

A prima vista può sembrare complicato, ma funziona piuttosto semplicemente; la chiave sta usando 'slice (-n)' in un paio di punti in cui la parte buona deve essere estratta dalla fine della matrice divisa (e [0] per ottenere dalla parte anteriore della matrice divisa).

Ognuno di questi test restituisce "esempio.com":

"Http://example.com" .split ( "//") .slice (-1) [0] .split ( ":"). [0] .split ( '') slice (-2). aderire('.')
"http://example.com:1234".split("//").slice(-1)[0].split(":")[0].split('.').slice(-2 ).aderire('.')
"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 ( '')

Ecco il one-liner 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];
}

Il codice sopra analizzerà correttamente i nomi host per i seguenti URL di esempio:

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

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

Il credito originale va a: http://www.primaryobjects.com/CMS/Article145

Ok, so che questa è una vecchia domanda, ma ho creato un parser url super efficiente quindi ho pensato di condividerlo.

Come puoi vedere, la struttura della funzione è molto strana, ma è per efficienza. Non vengono utilizzate funzioni prototipo, la stringa non viene ripetuta più di una volta e nessun carattere viene elaborato più del necessario.

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

Questa non è una risposta completa, ma il codice seguente dovrebbe aiutarti:

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

Vorrei che qualcuno creasse un codice più veloce del mio. Aiuta anche a migliorare me stesso.

on line con 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]+.)/,"");
}

Personalmente ho cercato molto per questa soluzione, e la migliore che ho potuto trovare è in realtà dal "controllo del browser" di 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();

Ho riscritto le variabili in modo che sia più "umano" leggibile, ma fa il lavoro meglio del previsto.

Bene, fare usando un'espressione regolare sarà molto più semplice:

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

questo si occupa sia del protocollo.

in breve puoi fare così

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"

Utilizzare la funzione sopra per ottenere il nome di dominio

Parse-Urls sembra essere la libreria JavaScript con i modelli più robusti

Ecco una carrellata delle funzionalità:

Capitolo 1. Normalizza o analizza un URL

Capitolo 2. Estrarre tutti gli URL

Capitolo 3. Estrarre gli URI con determinati nomi

Capitolo 4. Estrai tutti gli URL fuzzy

Capitolo 5. Evidenzia tutti gli URL nei testi

Capitolo 6. Estrarre tutti gli URL in HTML o XML non elaborati

Codice:

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

Risultato:

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

parse-domain - una libreria leggera molto solida

npm install parse-domain

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

Esempio 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' ] }

Esempio 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' ] }

Perché?

A seconda del caso d'uso e del volume, consiglio vivamente di non risolvere questo problema da soli utilizzando regex o altri mezzi di manipolazione delle stringhe. Il nocciolo di questo problema è che devi conoscere tutti i suffissi gtld e cctld per analizzare correttamente le stringhe dell'URL nel dominio e nei sottodomini, questi suffissi vengono aggiornati regolarmente. Questo è un problema risolto e non uno che vuoi risolvere da solo (a meno che tu non sia google o qualcosa del genere). A meno che non sia necessario il nome host o il nome di dominio in un pizzico, non provare ad uscire da questo.

Il mio codice è simile a questo. Le espressioni regolari possono presentarsi in molte forme, e qui sono i miei casi di test, penso che sia più scalabile.

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

Prova sotto il codice per il nome di dominio esatto usando 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");
  }