Bir metin dizesindeki URL'nin tamamını değil, yalnızca URL'nin kökünü eşleştirmek istiyorum. Verilen:

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

www.example.comVeya example.cometki alanına çözümlenen son 2 örneği almak istiyorum .

Normal ifade yavaş duydum ve bu benim sayfadaki ikinci normal ifade ifade olurdu, bu yüzden eğer regex olmadan bunu yapmak yine de varsa bana bildirin.

Bu çözümün JS / jQuery sürümünü arıyorum.

Ben npm paket psl (Genel Sonek Listesi) kullanmanızı öneririz . "Genel Sonek Listesi" yalnızca Ülke Kodu Üst Düzey etki alanlarının değil, aynı zamanda kök etki alanı olarak kabul edilecek unicode karakterlerin de (ör. Www. 食 狮. .jp vb.). Bununla ilgili daha fazla bilgiyi buradan edinebilirsiniz .

Deneyin:

npm install --save psl

Sonra benim "extractHostname" uygulama çalıştırmak:

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

Bir npm paketi kullanamıyorum, bu yüzden aşağıda sadece extractHostname testleri.

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

Protokol veya hatta bağlantı noktası numarasına bakılmaksızın, alan adını çıkarabilirsiniz. Bu çok basitleştirilmiş, regex olmayan bir çözümdür, bu yüzden yapacağım.

* Önerileriniz için teşekkür ederiz @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson! @ ross-allen, hatayı bildirdiğiniz için teşekkür ederiz!

Düzenli ifadeler kullanmadan düzgün bir numara:

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'

Yukarıdakileri aşağıdaki gibi bir işleve sarın ve alan adını bir URI'den koparmanın mükemmel bir yoluna sahipsiniz.

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

Sadece bir argüman olarak URL geçmesi, dize ayrıştırmak için gerek yoktur URLyapıcısı :

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

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

Bunu dene:

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

Bağlantı noktasını sonucunuzdan hariç tutmak istiyorsanız, bunun yerine bu ifadeyi kullanın:

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

Düzenleme: Belirli alan adlarının eşleşmesini önlemek için, negatif bir ileriye bakın.(?!youtube.com)

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

Bağlantı noktası numaralarına ve özel karakterlere sahip olabileceğiniz için bir URL'yi ayrıştırmak zor olabilir. Bu nedenle, sizin için bunu yapmak için parseUri gibi bir şey kullanmanızı öneririz . Yüzlerce URL'yi ayrıştırmadığınız sürece performansın bir sorun olacağından şüpheliyim.

2020 cevap

Bunun için ekstra bağımlılığa ihtiyacınız yok! Performans için optimizasyon yapmanız gerekip gerekmediğine bağlı olarak, iki iyi çözüm vardır:

URL.hostnameOkunabilirlik için kullanın

Babel döneminde en temiz ve en kolay çözüm kullanmaktır 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.hostnameIE ( caniuse ) dışındaki tüm büyük tarayıcılar tarafından desteklenen URL API'sinin bir parçasıdır . Eski tarayıcıları desteklemeniz gerekiyorsa bir URL çoklu dolgusu kullanın .

Bu çözümü kullanmak, diğer URL özelliklerine ve yöntemlerine de erişmenizi sağlar . URL'nin yol adını veya sorgu dizesi parametrelerini de ayıklamak istiyorsanız bu yararlı olacaktır .

Performans için RegEx kullanın

URL.hostnameçapa çözümü veya parseUri kullanmaktan daha hızlıdır . Ancak yine de gilly3'ün normal ifadesinden çok daha yavaş :

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

Bu jsPerf üzerinde kendiniz test edin

Çok sayıda URL'yi (performansın bir faktör olacağı yerlerde) işlemeniz gerekirse, bunun yerine bu çözümü kullanmanızı öneririz. Aksi takdirde, URL.hostnameokunabilirliği seçin .

Verilen çözümleri kullanmaya çalıştım, Seçilmiş olanı benim amacım için aşırıya kaçmıştı ve "bir element yaratmak" benim için berbattı.

Henüz URL'deki Port için hazır değil. Umarım birisi faydalı bulur

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

Bunu çalıştırıyorum:

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

Sonuç:

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

Bu sayfaya ulaşırsanız ve URL'lerin en iyi REGEX'ini arıyorsanız, bunu deneyin:

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

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

Sadece // ile http: //, http, https ile URL'ler için çalışır ve yolu ve sorgu yolunu da almaz.

İyi şanslar

Tüm URL özellikleri, bağımlılık yok, JQuery yok, anlaşılması kolay

Bu çözüm, cevabınıza ek özellikler sunar. Hiçbir JQuery veya diğer bağımlılıklar gerekli, yapıştırın ve gidin.

kullanım

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

Çıktı

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

Kod
Kod, süper hızlı değil, anlaşılması kolay olacak şekilde tasarlanmıştır. Saniyede 100 kez kolayca çağrılabilir, bu nedenle ön uç veya birkaç sunucu kullanımı için harikadır, ancak yüksek hacimli işlem için değil.

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
}

URL () yapıcısını kullanmanız yeterlidir :

new URL(url).host

Bugün bu soruna bir çözüm arıyordum. Yukarıdaki cevapların hiçbiri tatmin edici görünmüyordu. Bir astar, koşullu mantık ve bir fonksiyona sarılması gereken hiçbir şey olabilecek bir çözüm istedim.

İşte geldim, gerçekten iyi çalışıyor gibi görünüyor:

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

İlk bakışta karmaşık görünebilir, ancak oldukça basit çalışır; anahtar, iyi parçanın bölünmüş dizinin sonundan (ve [0] bölünmüş dizinin önünden almak için) çekilmesi gereken birkaç yerde 'dilim (-n)' kullanmaktır .

Bu testlerin her biri "example.com" döndürür:

"Http://example.com" .split ( "//") .slice (-1) [0] .split ( ":"). [0] .split ( '') dilim (-2). katılmak('.')
"http://example.com:1234".split("//").slice(-1)[0].split(":")[0].split('.').slice(-2 ).katılmak('.')
"Http://www.example.com:1234" .split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( '') dilim (. -2) .join ( '')
"Http://foo.www.example.com:1234" .split ( "//") .slice (-1) [0] .split ( ":") [0] .split ( ''). dilim (-2) .join ( '')

İşte jQuery tek astarı:

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

Yukarıdaki kod, aşağıdaki örnek URL'ler için ana makine adlarını başarıyla ayrıştırır:

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 başka bir.eu

Orijinal kredi şu adrese gider: http://www.primaryobjects.com/CMS/Article145

Tamam, bunun eski bir soru olduğunu biliyorum, ama süper verimli bir url ayrıştırıcısı yaptım, bu yüzden paylaşacağımı düşündüm.

Gördüğünüz gibi, fonksiyonun yapısı çok garip, ancak verimlilik için. Hiçbir prototip işlevi kullanılmaz, dize birden çok kez yinelenmez ve hiçbir karakter gereğinden fazla işlenmez.

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

Bu tam bir cevap değildir, ancak aşağıdaki kod size yardımcı olacaktır:

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

Bazılarının benimkinden daha hızlı kod oluşturmasını istiyorum. Kendimi de geliştirmeye yardımcı olur.

jquery ile oneline

$('<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]+.)/,"");
}

Şahsen bu çözüm için çok araştırma yaptım ve bulabildiğim en iyisi aslında CloudFlare'nin "tarayıcı kontrolü" nden:

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

Değişkenleri yeniden yazdım, böylece daha "insan" okunabilir, ama işi beklenenden daha iyi yapıyor.

Normal bir ifade kullanarak yapmak çok daha kolay olacak:

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

bu her iki protokolü de halleder.

kısaca böyle yapabilirsin

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"

Alan adını almak için yukarıdaki işlevi kullanın

Parse-Urls , en sağlam kalıplara sahip JavaScript kitaplığı gibi görünüyor

İşte özelliklerin bir özeti:

Bölüm 1. Bir URL'yi normalleştirme veya ayrıştırma

Bölüm 2. Tüm URL'leri çıkarın

Bölüm 3. URI'leri belirli adlarla çıkarın

Bölüm 4. Tüm bulanık URL'leri çıkarın

Bölüm 5. Metinlerdeki tüm URL'leri vurgulayın

Bölüm 6. Ham HTML veya XML'deki tüm URL'leri çıkarın

Kod:

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

Sonuç:

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

ayrıştırma alanı - çok sağlam ve hafif bir kütüphane

npm install parse-domain

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

örnek 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' ] }

ÖRNEK 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' ] }

Neden?

Kullanım durumuna ve hacmine bağlı olarak, regex veya diğer dize manipülasyon araçlarını kullanarak bu sorunu kendiniz çözmemenizi şiddetle tavsiye ederim. Bu sorunun özü, URL dizelerini etki alanına ve alt alan adlarına düzgün şekilde ayrıştırmak için tüm gtld ve cctld soneklerini bilmeniz gerektiğidir , bu sonekler düzenli olarak güncellenir. Bu çözülmüş bir sorundur ve kendiniz çözmek istediğiniz bir sorun değildir (google veya başka bir şey değilseniz). Bir tutamda ana bilgisayar adı veya etki alanı adına ihtiyaç duymadıkça, bu adresten çıkmaya çalışmayın.

Kodum böyle görünüyor. Düzenli ifadeler birçok biçimde olabilir ve işte benim test durumlarım daha ölçeklenebilir olduğunu düşünüyorum.

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

Normal ifadeyi kullanarak tam alan adı için aşağıdaki kodu deneyin,

Dize satırı = " 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");
  }