Je voudrais correspondre uniquement à la racine d'une URL et non à l'URL entière d'une chaîne de texte. Donné:

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

Je veux obtenir la résolution des 2 dernières instances vers le domaine www.example.comou example.com.

J'ai entendu dire que l'expression régulière est lente et ce serait ma deuxième expression d'expression régulière sur la page, donc s'il y a un moyen de le faire sans expression régulière, faites-le moi savoir.

Je cherche une version JS / jQuery de cette solution.

Je recommande d'utiliser le package npm psl (Public Suffix List) . La "Liste des suffixes publics" est une liste de tous les suffixes et règles de domaine valides, pas seulement les domaines de premier niveau de code de pays, mais aussi les caractères unicode qui seraient considérés comme le domaine racine (par exemple www. 食 狮. 公司 .cn, bckobe .jp, etc.). En savoir plus ici .

Essayer:

npm install --save psl

Puis avec mon exécution "extractHostname":

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

Je ne peux pas utiliser un package npm, donc ci-dessous ne teste que 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"));

Peu importe le protocole ou même le numéro de port, vous pouvez extraire le domaine. Il s'agit d'une solution non regex très simplifiée, donc je pense que cela suffira.

* Merci @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson pour vos suggestions! @ ross-allen, merci d'avoir signalé le bogue!

Une astuce intéressante sans utiliser d'expressions régulières:

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'

Enveloppez ce qui précède dans une fonction comme celle ci-dessous et vous avez vous-même un excellent moyen d'extraire la partie de domaine d'un URI.

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

Il n'est pas nécessaire d'analyser la chaîne, passez simplement votre URL comme argument au URLconstructeur :

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

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

Essaye ça:

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

Si vous souhaitez exclure le port de votre résultat, utilisez plutôt cette expression:

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

Modifier: pour empêcher la correspondance de domaines spécifiques, utilisez une anticipation négative.(?!youtube.com)

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

L'analyse d'une URL peut être délicate car vous pouvez avoir des numéros de port et des caractères spéciaux. En tant que tel, je recommande d'utiliser quelque chose comme parseUri pour le faire pour vous. Je doute que les performances soient un problème sauf si vous analysez des centaines d'URL.

Réponse 2020

Vous n'avez pas besoin de dépendances supplémentaires pour cela! Selon que vous devez optimiser les performances ou non, il existe deux bonnes solutions:

Utilisation URL.hostname pour la lisibilité

À l'ère Babel, la solution la plus propre et la plus simple est d'utiliser 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.hostnamefait partie de l' API URL , prise en charge par tous les principaux navigateurs sauf IE ( caniuse ). Utiliser un polyfill URL si vous devez prendre en charge les navigateurs hérités.

L'utilisation de cette solution vous donnera également accès à d'autres propriétés et méthodes d'URL . Cela sera utile si vous souhaitez également extraire les URL chemin accès de ou les paramètres de chaîne de requête , par exemple.

Utilisez RegEx pour les performances

URL.hostnameest plus rapide que d'utiliser la solution d'ancrage ou parseUri . Cependant, il est encore beaucoup plus lent que l' expression régulière 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"));

Testez-le vous-même sur ce jsPerf

Si vous devez traiter un très grand nombre d'URL (où les performances seraient un facteur), je recommande plutôt d'utiliser cette solution. Sinon, choisissez la URL.hostnamelisibilité.

J'ai essayé d'utiliser les solutions données, celle choisie était une surpuissance pour mon but et "Créer un élément" me dérange.

Il n'est pas encore prêt pour le port dans l'URL. J'espère que quelqu'un le trouve 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;
}

Exécuter ceci:

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

Résultat:

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

Si vous vous retrouvez sur cette page et que vous recherchez le meilleur REGEX d'URL, essayez celui-ci:

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

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

Il fonctionne pour les URL sans http: //, avec http, avec https, avec juste // et ne récupère pas le chemin et le chemin de requête également.

Bonne chance

Toutes les propriétés d'url, pas de dépendances, pas de JQuery, facile à comprendre

Cette solution donne votre réponse ainsi que des propriétés supplémentaires. Aucune JQuery ou autres dépendances requises, collez et c'est parti.

Usage

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

Production

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

Code
Le code est conçu pour être facile à comprendre plutôt que super rapide. Il peut être appelé facilement 100 fois par seconde, il est donc idéal pour le front-end ou pour quelques utilisations de serveur, mais pas pour un débit élevé.

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
}

Utilisez simplement le constructeur URL () :

new URL(url).host

Je cherchais une solution à ce problème aujourd'hui. Aucune des réponses ci-dessus ne semble satisfaisante. Je voulais une solution qui pourrait être une ligne unique, pas de logique conditionnelle et rien qui devait être enveloppé dans une fonction.

Voici ce que j'ai trouvé, qui semble très bien fonctionner:

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

Peut sembler compliqué à première vue, mais cela fonctionne assez simplement; la clé utilise 'slice (-n)' à quelques endroits où la bonne partie doit être tirée de la fin du tableau divisé (et [0] pour obtenir de l'avant du tableau divisé).

Chacun de ces tests renvoie "example.com":

"http://example.com" .split ("//") .slice (-1) [0] .split (":") [0] .split ('.'). slice (-2). joindre('.')
"http://example.com:1234".split("//").slice(-1)}0 diplomate.split(":")−00m.split('.').slice(-2 ).joindre('.')
"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 ('.'). tranche (-2) .join ('.')

Voici le 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];
}

Le code ci-dessus analysera correctement les noms d'hôtes pour les exemples d'URL suivants:

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

Le crédit d'origine va à: http://www.primaryobjects.com/CMS/Article145

D'accord, je sais que c'est une vieille question, mais j'ai fait un analyseur d'URL super efficace, donc j'ai pensé que je le partagerais.

Comme vous pouvez le voir, la structure de la fonction est très étrange, mais c'est pour l'efficacité. Aucune fonction prototype n'est utilisée, la chaîne n'est pas répétée plus d'une fois et aucun caractère n'est traité plus que nécessaire.

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

Ce n'est pas une réponse complète, mais le code ci-dessous devrait vous aider:

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

J'aimerais que quelqu'un crée du code plus rapidement que le mien. Cela aide aussi à m'améliorer.

en ligne avec 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]+.)/,"");
}

J'ai personnellement beaucoup recherché cette solution, et la meilleure que j'ai pu trouver est en fait la «vérification du navigateur» 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();

J'ai réécrit des variables pour qu'elles soient plus lisibles "par l'homme", mais cela fait mieux que prévu.

Eh bien, utiliser une expression régulière sera beaucoup plus facile:

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

cela prend en charge à la fois le protocole.

en bref, vous pouvez faire comme ça

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"

Utilisez la fonction ci-dessus pour obtenir le nom de domaine

Parse-Urls semble être la bibliothèque JavaScript avec les modèles les plus robustes

Voici un aperçu des fonctionnalités:

Chapitre 1. Normaliser ou analyser une URL

Chapitre 2. Extraire toutes les URL

Chapitre 3. Extraire des URI avec certains noms

Chapitre 4. Extraire toutes les URL floues

Chapitre 5. Mettez en surbrillance toutes les URL dans les textes

Chapitre 6. Extraire toutes les URL en HTML brut ou XML

Code:

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

Résultat:

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

parse-domain - une bibliothèque légère très solide

npm install parse-domain

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

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

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

Pourquoi?

Selon le cas d'utilisation et le volume, je déconseille fortement de résoudre ce problème vous-même en utilisant l'expression régulière ou d'autres moyens de manipulation de chaînes. Le cœur de ce problème est que vous devez connaître tous les suffixes gtld et cctld pour analyser correctement les chaînes d'URL dans le domaine et les sous-domaines, ces suffixes sont régulièrement mis à jour. C'est un problème résolu et pas un que vous voulez résoudre vous-même (sauf si vous êtes google ou quelque chose). À moins que vous n'ayez besoin du nom d'hôte ou du nom de domaine à la rigueur, n'essayez pas d'analyser votre chemin hors de celui-ci.

Mon code ressemble à ceci. Les expressions régulières peuvent prendre de nombreuses formes, et voici mes cas de test, je pense que c'est plus évolutif.

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

Essayez ci-dessous le code pour le nom de domaine exact en utilisant l'expression régulière,

Ligne de chaîne = " 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");
  }