Extrair o nome do host da cadeia

Gostaria de combinar apenas a raiz de um URL e não o URL inteiro de uma cadeia 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 duas últimas instâncias sejam resolvidas para o domínio www.example.com ou example.com .

Eu ouvi regex é lento e esta seria a minha segunda expressão regex na página por isso Se houver qualquer maneira de fazê-lo sem regex me avise.

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

Experimentar:

 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; } // To address those who want the "root domain," use this function: function extractRootDomain(url) { var domain = extractHostname(url), splitArr = domain.split('.'), arrLen = splitArr.length; //extracting the root domain here //if there is a subdomain if (arrLen > 2) { domain = splitArr[arrLen - 2] + '.' + splitArr[arrLen - 1]; //check to see if it's using a Country Code Top Level Domain (ccTLD) (ie ".me.uk") if (splitArr[arrLen - 2].length == 2 && splitArr[arrLen - 1].length == 2) { //this is using a ccTLD domain = splitArr[arrLen - 3] + '.' + domain; } } return domain; } //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")); //test extractRootDomain console.log("== Testing extractRootDomain: =="); console.log(extractRootDomain("http://www.blog.classroom.me.uk/index.php")); console.log(extractRootDomain("http://www.youtube.com/watch?v=ClkQA2Lb_iE")); console.log(extractRootDomain("https://www.youtube.com/watch?v=ClkQA2Lb_iE")); console.log(extractRootDomain("www.youtube.com/watch?v=ClkQA2Lb_iE")); console.log(extractRootDomain("ftps://ftp.websitename.com/dir/file.txt")); console.log(extractRootDomain("websitename.com:1234/dir/file.txt")); console.log(extractRootDomain("ftps://websitename.com:1234/dir/file.txt")); console.log(extractRootDomain("example.com?param=value")); console.log(extractRootDomain("https://facebook.github.io/jest/")); console.log(extractRootDomain("//youtube.com/watch?v=ClkQA2Lb_iE")); 

Um truque legal 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' 

Envolva o acima em uma function como a abaixo e você terá uma ótima maneira de arrebatar a parte do domínio de um URI.

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

Tente isto:

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

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

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

Editar: para impedir a correspondência de domínios específicos, use uma visão antecipada negativa. (?!youtube.com)

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

Não há necessidade de analisar a string, apenas passe sua URL como um argumento para o construtor de URL :

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

Analisar um URL pode ser complicado porque você pode ter números de porta e caracteres especiais. Como tal, eu recomendo usar algo como parseUri para fazer isso por você. Eu duvido que o desempenho seja um problema, a menos que você esteja analisando centenas de URLs.

Eu tentei usar as soluções dadas, o escolhido foi um exagero para o meu propósito e “Criando um elemento” um 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ê acabar nesta página e estiver procurando pelo 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 não pega o caminho e o caminho de consulta também.

Boa sorte

Aqui está o one-liner da jQuery:

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

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 código mais rápido que o meu. Ajuda também a melhorar meu eu.

 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 

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, sem lógica condicional e nada que tivesse que ser envolvido em uma function.

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

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

Pode parecer complicado à primeira vista, mas funciona de maneira simples; a chave é usar ‘slice (-n)’ em alguns lugares onde a parte boa deve ser puxada do final do array dividido (e [0] para obter a partir da frente do array dividido).

Cada um desses testes retorna “example.com”:

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

Todas as propriedades de URL, sem dependencies, sem JQuery, fáceis de entender

Esta solução dá sua resposta mais propriedades adicionais. Nenhuma JQuery ou outras dependencies necessárias, cole e vá.

Uso

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

Saída

 { "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 é projetado para ser fácil de entender, em vez de super rápido. Ele pode ser chamado facilmente 100 vezes por segundo, por isso é ótimo para front-end ou alguns usos de servidor, mas não para alto volume de processamento.

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

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

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

Ok, eu sei que esta é uma pergunta antiga, mas fiz um analisador de url super eficiente, então pensei em compartilhá-lo.

Como você pode ver, a estrutura da function é muito estranha, mas é para eficiência. Nenhuma function prototype é usada, a string 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 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; } 

Eu pessoalmente pesquisei muito por essa solução, e a melhor que consegui encontrar foi na “verificação do navegador” da CloudFlare:

 function getHostname(){ secretDiv = document.createElement('div'); secretDiv.innerHTML = "x"; 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(); 

Eu reescrevi variables ​​para que seja mais legível “humano”, mas faz o trabalho melhor que o esperado.

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 

em pouco, 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 function acima para obter o nome de domínio

Tente abaixo o código para o 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"); }