Me gustaría hacer coincidir solo la raíz de una URL y no la URL completa de una cadena 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

Quiero que las 2 últimas instancias se resuelvan en el dominio www.example.como example.com.

Escuché que la expresión regular es lenta y esta sería mi segunda expresión de expresión regular en la página, así que si hay alguna forma de hacerlo sin expresión regular, hágamelo saber.

Estoy buscando una versión JS / jQuery de esta solución.

Recomiendo usar el paquete npm psl (Lista de sufijos públicos) . La "Lista de sufijos públicos" es una lista de todos los sufijos y reglas de dominio válidos, no solo los dominios de nivel superior de código de país, sino también los caracteres unicode que se considerarían el dominio raíz (es decir, www. 食 狮. 公司 .cn, bckobe .jp, etc.). Lea más sobre esto aquí .

Tratar:

npm install --save psl

Luego, con mi ejecución "extractHostname", ejecute:

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

No puedo usar un paquete npm, así que a continuación solo prueba 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"));

Independientemente de tener el protocolo o incluso el número de puerto, puede extraer el dominio. Esta es una solución muy simplificada, no regex, así que creo que esto funcionará.

* Gracias @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson por sus sugerencias. @ ross-allen, ¡gracias por informar del error!

Un buen truco sin usar expresiones 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'

Envuelva lo anterior en una función como la siguiente y tendrá una excelente manera de extraer la parte del dominio de un URI.

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

No hay necesidad de analizar la cadena, solo pasa tu URL como argumento al URLconstructor :

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

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

Prueba esto:

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

Si desea excluir el puerto de su resultado, use esta expresión en su lugar:

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

Editar: para evitar que dominios específicos coincidan, use una búsqueda anticipada negativa.(?!youtube.com)

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

Analizar una URL puede ser complicado porque puede tener números de puerto y caracteres especiales. Como tal, recomiendo usar algo como parseUri para hacer esto por usted. Dudo que el rendimiento sea un problema a menos que esté analizando cientos de URL.

Respuesta 2020

¡No necesitas ninguna dependencia adicional para esto! Dependiendo de si necesita optimizar el rendimiento o no, hay dos buenas soluciones:

Usar URL.hostnamepara facilitar la lectura

En la era de Babel, la solución más limpia y fácil es 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.hostnamees parte de la API de URL , compatible con todos los principales navegadores, excepto IE ( caniuse ). Utilice un polyfill de URL si necesita admitir navegadores heredados.

El uso de esta solución también le dará acceso a otras propiedades y métodos de URL . Esto será útil si también desea extraer el nombre de ruta de la URL o los parámetros de cadena de consulta , por ejemplo.

Use RegEx para el rendimiento

URL.hostnamees más rápido que usar la solución de anclaje o parseUri . Sin embargo, todavía es mucho más lento que la expresión regular 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"));

Pruébelo usted mismo en este jsPerf

Si necesita procesar una gran cantidad de URL (donde el rendimiento sería un factor), le recomiendo usar esta solución. De lo contrario, elija la URL.hostnamelegibilidad.

Traté de usar las soluciones de Given, la Elegida fue una exageración para mi propósito y "Crear un elemento" me fastidia.

Todavía no está listo para Puerto en URL. Espero que alguien lo encuentre ú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;
}

Ejecutando esto:

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

Resultado:

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

Si termina en esta página y está buscando el mejor REGEX de URLS, pruebe este:

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

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

Funciona para urls sin http: //, con http, con https, con solo // y no toma la ruta y la ruta de consulta también.

Buena suerte

Todas las propiedades de URL, sin dependencias, sin JQuery, fácil de entender

Esta solución le da su respuesta más propiedades adicionales. No se requieren JQuery u otras dependencias, pegar y listo.

Uso

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

Salida

{
  "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
El código está diseñado para ser fácil de entender en lugar de súper rápido. Se puede invocar fácilmente 100 veces por segundo, por lo que es ideal para aplicaciones de servidor o algunos usos del servidor, pero no para un rendimiento de alto volumen.

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
}

Simplemente use el constructor URL () :

new URL(url).host

Estaba buscando una solución a este problema hoy. Ninguna de las respuestas anteriores pareció satisfacer. Quería una solución que pudiera ser un trazador de líneas, sin lógica condicional y nada que tuviese que incluir una función.

Esto es lo que se me ocurrió, parece funcionar muy bien:

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

Puede parecer complicado a primera vista, pero funciona de manera bastante simple; la clave está usando 'slice (-n)' en un par de lugares donde la parte buena tiene que ser extraída del final de la matriz dividida (y [0] para llegar desde el frente de la matriz dividida).

Cada una de estas pruebas devuelve "example.com":

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

Aquí está el jQuery one-liner:

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

El código anterior analizará correctamente los nombres de host para las siguientes URL de ejemplo:

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

El crédito original va a: http://www.primaryobjects.com/CMS/Article145

Bien, sé que esta es una vieja pregunta, pero hice un analizador de URL súper eficiente, así que pensé en compartirlo.

Como puede ver, la estructura de la función es muy extraña, pero es por eficiencia. No se utilizan funciones prototipo, la cadena no se repite más de una vez y no se procesa ningún carácter más de lo necesario.

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 no es una respuesta completa, pero el siguiente código debería ayudarlo:

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

Me gustaría que alguien creara código más rápido que el mío. Ayuda a mejorar mi yo también.

en línea 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 investigué mucho para esta solución, y la mejor que pude encontrar es en realidad la "comprobación del navegador" de 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();

Reescribí las variables para que sea más legible "humano", pero hace el trabajo mejor de lo esperado.

Bueno, usar una expresión regular será mucho más 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, ''));

Esto se encarga tanto del protocolo.

en pocas palabras puedes hacer así

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 la función anterior para obtener el nombre de dominio

Parse-Urls parece ser la biblioteca de JavaScript con los patrones más robustos

Aquí hay un resumen de las características:

Capítulo 1. Normalizar o analizar una URL

Capítulo 2. Extraiga todas las URL

Capítulo 3. Extraiga los URI con ciertos nombres

Capítulo 4. Extraiga todas las URL difusas

Capítulo 5. Resalte todas las URL en los textos

Capítulo 6. Extraiga todas las URL en HTML o XML sin procesar

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 : una biblioteca ligera muy sólida

npm install parse-domain

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

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

Ejemplo 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é?

Dependiendo del caso de uso y el volumen, le recomiendo no resolver este problema usted mismo utilizando regex u otros medios de manipulación de cadenas. El núcleo de este problema es que necesita conocer todos los sufijos gtld y cctld para analizar correctamente las cadenas de URL en dominios y subdominios, estos sufijos se actualizan regularmente. Este es un problema resuelto y no uno que desee resolver usted mismo (a menos que sea google o algo así). A menos que necesite el nombre de host o el nombre de dominio en un apuro, no intente analizar este camino.

Mi código se ve así. Las expresiones regulares pueden venir en muchas formas, y aquí están mis casos de prueba, creo que es más escalable.

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

Pruebe el siguiente código para el nombre de dominio exacto 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");
  }