Gostaria de corresponder apenas à raiz de uma URL e não à URL inteira de uma sequência de texto. Dado:

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

Quero que as 2 últimas instâncias sejam resolvidas no domínio www.example.comou example.com.

Ouvi dizer que regex é lento e essa seria minha segunda expressão regex na página. Se houver alguma maneira de fazê-lo sem regex, avise-me.

Estou procurando uma versão JS / jQuery desta solução.

Eu recomendo usar o pacote npm psl (lista pública de sufixos) . A "Lista pública de sufixos" é uma lista de todos os sufixos e regras de domínio válidos, não apenas domínios de nível superior de código de país, mas também caracteres unicode que seriam considerados o domínio raiz (por exemplo, www. 食 狮. 公司 .cn, bckobe .jp etc.). Leia mais sobre isso aqui .

Experimentar:

npm install --save psl

Em seguida, com a minha implementação "extractHostname", execute:

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

Não posso usar um pacote npm, portanto, abaixo apenas os testes 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"));

Independentemente de ter o protocolo ou mesmo o número da porta, você pode extrair o domínio. Esta é uma solução muito simplificada e não regular, por isso acho que isso funcionará.

* Obrigado @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson por suas sugestões! @ Ross-Allen, obrigado por relatar o bug!

Um truque interessante sem usar expressões regulares:

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'

Coloque o que foi dito acima em uma função como a abaixo e você terá uma excelente maneira de roubar a parte do domínio de um URI.

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

Não há necessidade de analisar a string, basta passar seu URL como argumento para o URLconstrutor :

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

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

Tente o seguinte:

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

Se você deseja excluir a porta do seu resultado, use esta expressão:

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

Editar: para impedir a correspondência de domínios específicos, use um indicador negativo.(?!youtube.com)

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

A análise de um URL pode ser complicada, pois você pode ter números de porta e caracteres especiais. Como tal, recomendo usar algo como parseUri para fazer isso por você. Duvido que o desempenho seja um problema, a menos que você esteja analisando centenas de URLs.

Resposta 2020

Você não precisa de nenhuma dependência extra para isso! Dependendo se você precisa otimizar o desempenho ou não, existem duas boas soluções:

Use URL.hostnamepara facilitar a leitura

Na era Babel, a solução mais limpa e fácil é usar 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.hostnamefaz parte da API da URL , suportada por todos os principais navegadores, exceto o IE ( caniuse ). Use um polyfill de URL se precisar oferecer suporte a navegadores herdados.

O uso desta solução também dará acesso a outras propriedades e métodos de URL . Isso será útil se você também desejar extrair o nome do caminho da URL ou os parâmetros da string de consulta , por exemplo.

Use RegEx para obter desempenho

URL.hostnameé mais rápido do que usar a solução âncora ou parseUri . No entanto, ainda é muito mais lento que o regex de 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"));

Teste você mesmo neste jsPerf

Se você precisar processar um número muito grande de URLs (onde o desempenho seria um fator), recomendo usar esta solução. Caso contrário, escolha URL.hostnamea legibilidade.

Tentei usar as soluções Given, a escolhida foi um exagero para o meu propósito e "Criando um elemento" é uma bagunça para mim.

Ainda não está pronto para o Port in URL. Espero que alguém ache útil

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

Executando isso:

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

Resultado:

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

Se você terminar nesta página e estiver procurando o melhor REGEX de URLS, tente este:

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

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

Ele funciona para URLs sem http: //, com http, com https, com apenas // e também não pega o caminho nem o caminho da consulta.

Boa sorte

Todas as propriedades de URL, sem dependências, sem JQuery, fáceis de entender

Esta solução fornece sua resposta, além de propriedades adicionais. Não é necessário JQuery ou outras dependências, cole e vá.

Uso

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

Resultado

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

Código
O código foi projetado para ser fácil de entender e não super rápido. Ele pode ser chamado facilmente 100 vezes por segundo, portanto, é ótimo para front-end ou para alguns usos de servidor, mas não para alta taxa de transferência de volume.

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 usar o construtor URL () :

new URL(url).host

Estava procurando uma solução para esse problema hoje. Nenhuma das respostas acima pareceu satisfazer. Eu queria uma solução que pudesse ser um liner, nenhuma lógica condicional e nada que tivesse que ser envolvido em uma função.

Aqui está o que eu criei, parece funcionar muito bem:

hostname = "http://www.example.com:1234"
hostname.split ("//"). fatia (-1) [0]. divisão (":") [0]. divisão ('.'). fatia (-2). junta ('.') // dá "example.com"

Pode parecer complicado à primeira vista, mas funciona de maneira bem simples; a chave está usando 'fatia (-n)' em alguns lugares onde a parte boa precisa ser puxada do final da matriz dividida (e [0] para sair da frente da matriz dividida).

Cada um desses testes retorna "example.com":

"http://example.com" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). fatia (-2). Junte-se('.')
"http://example.com:1234".split("//").slice(-1)[0}.split(":")[0}.split('.').slice(-2 ).Junte-se('.')
"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 ('.'). fatia (-2) .join ('.')

Aqui está o one-liner do 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];
}

O código acima analisará com êxito os nomes de host para os seguintes URLs de exemplo:

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

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

O crédito original é: http://www.primaryobjects.com/CMS/Article145

Ok, eu sei que essa é uma pergunta antiga, mas eu fiz um analisador de URL supereficiente, então pensei em compartilhá-lo.

Como você pode ver, a estrutura da função é muito estranha, mas é para eficiência. Nenhuma função de protótipo é usada, a sequência não é iterada mais de uma vez e nenhum caractere é processado mais do que o necessário.

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

Esta não é uma resposta completa, mas o código abaixo deve ajudá-lo:

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

Eu gostaria que alguém criasse um código mais rápido que o meu. Também ajuda a melhorar a mim mesmo.

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

Eu, pessoalmente, pesquisei bastante sobre esta solução, e a melhor que encontrei é na "verificação do navegador" do 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();

Reescrevi variáveis ​​para que fique mais legível "humano", mas ele funciona melhor do que o esperado.

Bem, usar uma expressão regular será muito mais fácil:

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

isso cuida do protocolo.

em suma, você pode fazer assim

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"

Use a função acima para obter o nome de domínio

Parse-Urls parece ser a biblioteca JavaScript com os padrões mais robustos

Aqui está um resumo dos recursos:

Capítulo 1. Normalize ou analise uma URL

Capítulo 2. Extrair todas as URLs

Capítulo 3. Extrair URIs com certos nomes

Capítulo 4. Extrair todas as URLs difusas

Capítulo 5. Destaque todas as URLs em textos

Capítulo 6. Extraia todas as URLs em HTML ou XML bruto

Código:

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

Resultado:

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

parse-domain - uma biblioteca leve muito sólida

npm install parse-domain

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

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

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

Por quê?

Dependendo do caso de uso e do volume, recomendo fortemente que você não resolva esse problema usando regex ou outros meios de manipulação de cadeia. O principal desse problema é que você precisa conhecer todos os sufixos gtld e cctld para analisar adequadamente as seqüências de URL em domínio e subdomínios; esses sufixos são atualizados regularmente. Este é um problema resolvido e não o que você deseja resolver (a menos que você seja o Google ou algo assim). A menos que você precise do nome do host ou do domínio em uma pitada, não tente analisar esse caminho.

Meu código fica assim. Expressões regulares podem vir de várias formas, e aqui estão os meus casos de teste: acho que é mais escalável.

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

Experimente o código abaixo do nome de domínio exato 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");
  }