Saya ingin mencocokkan hanya akar URL dan bukan keseluruhan URL dari string teks. Diberikan:

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

Saya ingin mendapatkan 2 instance terakhir yang diselesaikan ke domain www.example.comatau example.com.

Saya mendengar regex lambat dan ini akan menjadi ekspresi regex kedua saya di halaman jadi Jika ada cara untuk melakukannya tanpa regex beri tahu saya.

Saya mencari versi JS / jQuery dari solusi ini.

Saya sarankan menggunakan paket npm psl (Public Suffix List) . "Daftar Sufiks Publik" adalah daftar semua sufiks dan aturan domain yang valid, bukan hanya domain Tingkat Atas Kode Negara, tetapi juga karakter unicode yang akan dianggap sebagai domain root (yaitu www. 食 狮. 公司 .cn, bckobe .jp, dll.). Baca lebih lanjut di sini .

Mencoba:

npm install --save psl

Kemudian dengan menjalankan implementasi "extractHostname" saya:

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

Saya tidak dapat menggunakan paket npm, jadi di bawah ini hanya menguji 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"));

Terlepas dari memiliki protokol atau nomor port, Anda dapat mengekstrak domain. Ini adalah solusi non-regex yang sangat sederhana, jadi saya pikir ini akan berhasil.

* Terima kasih @Timmerz, @renoirb, @rineez, @BigDong, @ ra00l, @ILikeBeansTacos, @CharlesRobertson atas saran Anda! @ ross-allen, terima kasih telah melaporkan bug!

Trik yang rapi tanpa menggunakan ekspresi reguler:

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'

Bungkus di atas dalam fungsi seperti di bawah ini dan Anda memiliki cara hebat untuk menyambar bagian domain dari URI.

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

Tidak perlu menguraikan string, cukup berikan URL Anda sebagai argumen untuk URLkonstruktor :

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

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

Coba ini:

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

Jika Anda ingin mengecualikan port dari hasil Anda, gunakan ungkapan ini sebagai gantinya:

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

Sunting: Untuk mencegah pencocokan domain tertentu, gunakan kepala pencarian yang negatif.(?!youtube.com)

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

Mem-parsing URL bisa rumit karena Anda dapat memiliki nomor port dan karakter khusus. Karena itu, saya sarankan menggunakan sesuatu seperti parseUri untuk melakukan ini untuk Anda. Saya ragu kinerja akan menjadi masalah kecuali Anda menguraikan ratusan URL.

Jawaban 2020

Anda tidak memerlukan dependensi tambahan untuk ini! Tergantung pada apakah Anda perlu mengoptimalkan kinerja atau tidak, ada dua solusi bagus:

Menggunakan URL.hostname untuk keterbacaan

Di era Babel, solusi terbersih dan termudah adalah menggunakan 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.hostnameadalah bagian dari API URL , didukung oleh semua browser utama kecuali IE ( caniuse ). Gunakan polyfill URL jika Anda perlu mendukung browser lawas.

Menggunakan solusi ini juga akan memberi Anda akses ke properti dan metode URL lainnya . Ini akan berguna jika Anda juga ingin mengekstrak pathname URL atau params string kueri , misalnya.

Gunakan RegEx untuk kinerja

URL.hostnamelebih cepat daripada menggunakan solusi jangkar atau parseUri . Namun itu masih jauh lebih lambat daripada regex 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"));

Uji sendiri di jsPerf ini

Jika Anda perlu memproses sejumlah besar URL (yang kinerjanya menjadi faktor), saya sarankan menggunakan solusi ini sebagai gantinya. Jika tidak, pilih URL.hostnameuntuk dibaca.

Saya mencoba menggunakan solusi yang Diberikan, yang Terpilih adalah kerja keras untuk tujuan saya dan "Membuat elemen" yang kacau untuk saya.

Ini belum siap untuk Port in URL. Saya harap seseorang menemukannya bermanfaat

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

Menjalankan ini:

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

Hasil:

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

Jika Anda berakhir di halaman ini dan Anda sedang mencari REGEX URL terbaik, cobalah yang ini:

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

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

Ini berfungsi untuk url tanpa http: //, dengan http, dengan https, hanya // dan jangan ambil jalur dan jalur kueri juga.

Semoga berhasil

Semua properti url, tidak ada dependensi, tidak ada JQuery, mudah dimengerti

Solusi ini memberikan jawaban Anda plus properti tambahan. Tidak diperlukan JQuery atau dependensi lain, tempel dan buka.

Pemakaian

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

Keluaran

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

Kode
Kode ini dirancang agar mudah dipahami daripada super cepat. Itu dapat dipanggil dengan mudah 100 kali per detik, jadi itu bagus untuk front end atau beberapa penggunaan server, tetapi tidak untuk throughput volume tinggi.

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
}

Cukup gunakan URL () konstruktor :

new URL(url).host

Sedang mencari solusi untuk masalah ini hari ini. Tidak ada jawaban di atas yang memuaskan. Saya ingin solusi yang bisa menjadi satu liner, tidak ada logika kondisional dan tidak ada yang harus dibungkus dalam suatu fungsi.

Inilah yang saya buat, tampaknya bekerja dengan sangat baik:

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

Sekilas mungkin terlihat rumit, tetapi bekerja cukup sederhana; kuncinya adalah menggunakan 'slice (-n)' di beberapa tempat di mana bagian yang baik harus ditarik dari ujung array split (dan [0] untuk mendapatkan dari depan array split).

Masing-masing tes ini mengembalikan "example.com":

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

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

Kode di atas akan berhasil mengurai nama host untuk url contoh berikut:

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

Kredit asli diberikan kepada: http://www.primaryobjects.com/CMS/Article145

Oke, saya tahu ini adalah pertanyaan lama, tapi saya membuat parser url yang sangat efisien jadi saya pikir saya akan membagikannya.

Seperti yang Anda lihat, struktur fungsinya sangat aneh, tetapi untuk efisiensi. Tidak ada fungsi prototipe yang digunakan, string tidak mendapatkan iterasi lebih dari sekali, dan tidak ada karakter yang diproses lebih dari yang diperlukan.

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

Ini bukan jawaban lengkap, tetapi kode di bawah ini akan membantu Anda:

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

Saya ingin seseorang membuat kode lebih cepat dari saya. Ini membantu meningkatkan diri saya juga.

oneline dengan 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]+.)/,"");
}

Saya pribadi banyak meneliti untuk solusi ini, dan yang terbaik yang bisa saya temukan sebenarnya dari "browser check" 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();

Saya menulis ulang variabel sehingga lebih "manusia" dapat dibaca, tetapi melakukan pekerjaan lebih baik dari yang diharapkan.

Nah, melakukan menggunakan ekspresi reguler akan jauh lebih mudah:

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

ini menangani kedua protokol.

singkatnya Anda bisa melakukan ini

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"

Gunakan fungsi di atas untuk mendapatkan nama domain

Parse-Url tampaknya merupakan perpustakaan JavaScript dengan pola paling kuat

Berikut ini adalah daftar fitur:

Bab 1. Normalisasi atau parsing satu URL

Bab 2. Ekstrak semua URL

Bagian 3. Ekstrak URI dengan nama tertentu

Bab 4. Ekstrak semua URL fuzzy

Bab 5. Sorot semua URL dalam teks

Bab 6. Ekstrak semua URL dalam HTML mentah atau XML

Kode:

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

Hasil:

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

parse-domain - perpustakaan ringan yang sangat solid

npm install parse-domain

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

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

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

Mengapa?

Bergantung pada use case dan volume, saya sangat menyarankan untuk tidak memecahkan masalah ini sendiri menggunakan regex atau cara manipulasi string lainnya. Inti dari masalah ini adalah bahwa Anda perlu mengetahui semua sufiks gtld dan cctld untuk mengurai string url dengan benar ke dalam domain dan subdomain, sufiks ini diperbarui secara berkala. Ini adalah masalah yang dipecahkan dan bukan yang ingin Anda selesaikan sendiri (kecuali jika Anda adalah google atau sesuatu). Kecuali Anda memerlukan nama host atau nama domain dalam keadaan darurat, jangan mencoba dan menguraikan jalan keluar dari yang ini.

Kode saya terlihat seperti ini. Ekspresi reguler dapat datang dalam berbagai bentuk, dan ini adalah kasus pengujian saya, saya pikir itu lebih skalabel.

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

Coba kode di bawah ini untuk nama domain yang tepat menggunakan 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");
  }