Mendapatkan bagian dari URL (Regex)

URL yang diberikan (satu baris):
http://test.example.com/dir/subdir/file.html

Bagaimana saya bisa mengekstrak bagian-bagian berikut ini dengan menggunakan ekspresi reguler:

1. Subdomain (tes)
2. Domain (example.com)
3. Path tanpa file (/ dir / subdir /)
4. File (file.html)
5. Path dengan file (/dir/subdir/file.html)
6. URL tanpa jalur ( http://test.example.com )
7. (tambahkan yang lain yang menurut Anda akan berguna)

Regex harus berfungsi dengan benar bahkan jika saya memasukkan URL berikut:

http://example.example.com/example/example/example.html

Regex tunggal untuk mem-parsing dan memecah URL lengkap termasuk parameter kueri dan jangkar misalnya

https://www.google.com/dir/1/2/search.html?arg=0-a&arg1=1-b&arg3-c#hash

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(.*)?(#[\w\-]+)?$

Posisi RexEx:

url: RegExp ['$ &'],

protokol: RegExp. $ 2,

host: RegExp. $ 3,

jalur: RegExp. $ 4,

file: RegExp. $ 6,

permintaan: RegExp. $ 7,

hash: RegExp. $ 8

Anda selanjutnya dapat menguraikan host ('.' dibatasi) dengan cukup mudah.

Apa yang akan saya lakukan adalah menggunakan sesuatu seperti ini:

/*
    ^(.*:)//([A-Za-z0-9\-\.]+)(:[0-9]+)?(.*)$
*/
proto $1
host $2
port $3
the-rest $4

selanjutnya mengurai 'sisanya' untuk menjadi sespesifik mungkin. Melakukannya dalam satu regex, well, agak gila.

Saya menyadari bahwa saya terlambat ke pesta, tetapi ada cara sederhana untuk membiarkan browser mengurai url untuk Anda tanpa regex:

var a = document.createElement('a');
a.href = 'http://www.example.com:123/foo/bar.html?fox=trot#foo';

['href','protocol','host','hostname','port','pathname','search','hash'].forEach(function(k) {
    console.log(k+':', a[k]);
});

/*//Output:
href: http://www.example.com:123/foo/bar.html?fox=trot#foo
protocol: http:
host: www.example.com:123
hostname: www.example.com
port: 123
pathname: /foo/bar.html
search: ?fox=trot
hash: #foo
*/

Saya terlambat beberapa tahun ke pesta, tetapi saya terkejut tidak ada yang menyebutkan spesifikasi Uniform Resource Identifier memiliki bagian tentang penguraian URI dengan ekspresi reguler . Ekspresi reguler, yang ditulis oleh Berners-Lee, et al., Adalah:

^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9

Angka-angka pada baris kedua di atas hanya untuk membantu keterbacaan; mereka menunjukkan titik referensi untuk setiap sub-ekspresi (yaitu, masing-masing tanda kurung dipasangkan). Kami merujuk pada nilai yang cocok untuk subekspresi sebagai $. Misalnya, mencocokkan ekspresi di atas dengan

http://www.ics.uci.edu/pub/ietf/uri/#Related

menghasilkan kecocokan subekspresi berikut:

$1 = http:
$2 = http
$3 = //www.ics.uci.edu
$4 = www.ics.uci.edu
$5 = /pub/ietf/uri/
$6 = <undefined>
$7 = <undefined>
$8 = #Related
$9 = Related

Untuk apa nilainya, saya menemukan bahwa saya harus melarikan diri dari garis miring di JavaScript:

^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?

Saya menemukan jawaban tertinggi (jawaban hometoast) tidak berfungsi dengan baik untuk saya. Dua masalah:

1. Itu tidak dapat menangani nomor port.
2. Bagian hash rusak.

Berikut ini adalah versi yang dimodifikasi:

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$

Posisi bagian adalah sebagai berikut:

int SCHEMA = 2, DOMAIN = 3, PORT = 5, PATH = 6, FILE = 8, QUERYSTRING = 9, HASH = 12

Edit yang diposting oleh pengguna lain:

function getFileName(path) {
    return path.match(/^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/[\w\/-]+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$/i)[8];
}

Saya membutuhkan Ekspresi reguler untuk mencocokkan semua url dan membuat yang ini:

/(?:([^\:]*)\:\/\/)?(?:([^\:\@]*)(?:\:([^\@]*))?\@)?(?:([^\/\:]*)\.(?=[^\.\/\:]*\.[^\.\/\:]*))?([^\.\/\:]*)(?:\.([^\/\.\:]*))?(?:\:([0-9]*))?(\/[^\?#]*(?=.*?\/)\/)?([^\?#]*)?(?:\?([^#]*))?(?:#(.*))?/

Ini cocok dengan semua url, protokol apa pun, bahkan seperti url

ftp://user:pass@www.cs.server.com:8080/dir1/dir2/file.php?param1=value1#hashtag

Hasilnya (dalam JavaScript) terlihat seperti ini:

["ftp", "user", "pass", "www.cs", "server", "com", "8080", "/dir1/dir2/", "file.php", "param1=value1", "hashtag"]

Seperti url

mailto://admin@www.cs.server.com

terlihat seperti ini:

["mailto", "admin", undefined, "www.cs", "server", "com", undefined, undefined, undefined, undefined, undefined] 

Saya mencoba menyelesaikan ini dalam javascript, yang harus ditangani oleh:

var url = new URL('http://a:b@example.com:890/path/wah@t/foo.js?foo=bar&bingobang=&king=kong@kong.com#foobar/bing/bo@ng?bang');

sejak (di Chrome, setidaknya) ia diuraikan menjadi:

{
  "hash": "#foobar/bing/bo@ng?bang",
  "search": "?foo=bar&bingobang=&king=kong@kong.com",
  "pathname": "/path/wah@t/foo.js",
  "port": "890",
  "hostname": "example.com",
  "host": "example.com:890",
  "password": "b",
  "username": "a",
  "protocol": "http:",
  "origin": "http://example.com:890",
  "href": "http://a:b@example.com:890/path/wah@t/foo.js?foo=bar&bingobang=&king=kong@kong.com#foobar/bing/bo@ng?bang"
}

Namun, ini bukan peramban silang ( https://developer.mozilla.org/en-US/docs/Web/API/URL ), jadi saya menggabungkan ini untuk menarik bagian yang sama seperti di atas:

^(?:(?:(([^:\/#\?]+:)?(?:(?:\/\/)(?:(?:(?:([^:@\/#\?]+)(?:\:([^:@\/#\?]*))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?

Kredit untuk regex ini diberikan kepada https://gist.github.com/rpflorence yang memposting jsperf http://jsperf.com/url-parsing (awalnya ditemukan di sini: https://gist.github.com/jlong/2428561 # comment-310066 ) yang membuat regex ini awalnya berdasarkan.

Bagian-bagian ini dalam urutan ini:

var keys = [
    "href",                    // http://user:pass@host.com:81/directory/file.ext?query=1#anchor
    "origin",                  // http://user:pass@host.com:81
    "protocol",                // http:
    "username",                // user
    "password",                // pass
    "host",                    // host.com:81
    "hostname",                // host.com
    "port",                    // 81
    "pathname",                // /directory/file.ext
    "search",                  // ?query=1
    "hash"                     // #anchor
];

Ada juga pustaka kecil yang membungkusnya dan menyediakan parameter permintaan:

https://github.com/sadams/lite-url (juga tersedia di bower)

Jika Anda memiliki peningkatan, harap buat permintaan tarik dengan lebih banyak tes dan saya akan menerima dan bergabung dengan terima kasih.

Usulkan solusi yang lebih mudah dibaca (dengan Python, tetapi berlaku untuk regex apa pun):

def url_path_to_dict(path):
    pattern = (r'^'
               r'((?P<schema>.+?)://)?'
               r'((?P<user>.+?)(:(?P<password>.*?))?@)?'
               r'(?P<host>.*?)'
               r'(:(?P<port>\d+?))?'
               r'(?P<path>/.*?)?'
               r'(?P<query>[?].*?)?'
               r'$'
               )
    regex = re.compile(pattern)
    m = regex.match(path)
    d = m.groupdict() if m is not None else None

    return d

def main():
    print url_path_to_dict('http://example.example.com/example/example/example.html')

Cetakan:

{
'host': 'example.example.com', 
'user': None, 
'path': '/example/example/example.html', 
'query': None, 
'password': None, 
'port': None, 
'schema': 'http'
}

subdomain dan domain sulit karena subdomain dapat memiliki beberapa bagian, seperti halnya domain tingkat atas, http://sub1.sub2.domain.co.uk/

 the path without the file : http://[^/]+/((?:[^/]+/)*(?:[^/]+$)?)  
 the file : http://[^/]+/(?:[^/]+/)*((?:[^/.]+\.)+[^/.]+)$  
 the path with the file : http://[^/]+/(.*)  
 the URL without the path : (http://[^/]+/)  

(Penurunan harga tidak sangat ramah untuk regex)

Versi yang ditingkatkan ini harus bekerja dengan andal sebagai pengurai.

   // Applies to URI, not just URL or URN:
   //    http://en.wikipedia.org/wiki/Uniform_Resource_Identifier#Relationship_to_URL_and_URN
   //
   // http://labs.apache.org/webarch/uri/rfc/rfc3986.html#regexp
   //
   // (?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?
   //
   // http://en.wikipedia.org/wiki/URI_scheme#Generic_syntax
   //
   // $@ matches the entire uri
   // $1 matches scheme (ftp, http, mailto, mshelp, ymsgr, etc)
   // $2 matches authority (host, user:pwd@host, etc)
   // $3 matches path
   // $4 matches query (http GET REST api, etc)
   // $5 matches fragment (html anchor, etc)
   //
   // Match specific schemes, non-optional authority, disallow white-space so can delimit in text, and allow 'www.' w/o scheme
   // Note the schemes must match ^[^\s|:/?#]+(?:\|[^\s|:/?#]+)*$
   //
   // (?:()(www\.[^\s/?#]+\.[^\s/?#]+)|(schemes)://([^\s/?#]*))([^\s?#]*)(?:\?([^\s#]*))?(#(\S*))?
   //
   // Validate the authority with an orthogonal RegExp, so the RegExp above won’t fail to match any valid urls.
   function uriRegExp( flags, schemes/* = null*/, noSubMatches/* = false*/ )
   {
      if( !schemes )
         schemes = '[^\\s:\/?#]+'
      else if( !RegExp( /^[^\s|:\/?#]+(?:\|[^\s|:\/?#]+)*$/ ).test( schemes ) )
         throw TypeError( 'expected URI schemes' )
      return noSubMatches ? new RegExp( '(?:www\\.[^\\s/?#]+\\.[^\\s/?#]+|' + schemes + '://[^\\s/?#]*)[^\\s?#]*(?:\\?[^\\s#]*)?(?:#\\S*)?', flags ) :
         new RegExp( '(?:()(www\\.[^\\s/?#]+\\.[^\\s/?#]+)|(' + schemes + ')://([^\\s/?#]*))([^\\s?#]*)(?:\\?([^\\s#]*))?(?:#(\\S*))?', flags )
   }

   // http://en.wikipedia.org/wiki/URI_scheme#Official_IANA-registered_schemes
   function uriSchemesRegExp()
   {
      return 'about|callto|ftp|gtalk|http|https|irc|ircs|javascript|mailto|mshelp|sftp|ssh|steam|tel|view-source|ymsgr'
   }

Coba yang berikut ini:

^((ht|f)tp(s?)\:\/\/|~/|/)?([\w]+:\w+@)?([a-zA-Z]{1}([\w\-]+\.)+([\w]{2,5}))(:[\d]{1,5})?((/?\w+/)+|/?)(\w+\.[\w]{3,4})?((\?\w+=\w+)?(&\w+=\w+)*)?

Ini mendukung HTTP / FTP, subdomain, folder, file dll.

Saya menemukannya dari pencarian google cepat:

http://geekswithblogs.net/casualjim/archive/2005/12/01/61722.aspx

/^((?P<scheme>https?|ftp):\/)?\/?((?P<username>.*?)(:(?P<password>.*?)|)@)?(?P<hostname>[^:\/\s]+)(?P<port>:([^\/]*))?(?P<path>(\/\w+)*\/)(?P<filename>[-\w.]+[^#?\s]*)?(?P<query>\?([^#]*))?(?P<fragment>#(.*))?$/

Dari jawaban saya pada pertanyaan serupa . Bekerja lebih baik daripada beberapa yang lain karena mereka memiliki beberapa bug (seperti tidak mendukung nama pengguna / kata sandi, tidak mendukung nama file karakter tunggal, pengidentifikasi fragmen sedang rusak).

Anda bisa mendapatkan semua http / https, host, port, path serta permintaan dengan menggunakan objek Uri di .NET. tugas yang sulit adalah memecah host menjadi sub domain, nama domain dan TLD.

Tidak ada standar untuk melakukannya dan tidak bisa hanya menggunakan penguraian string atau RegEx untuk menghasilkan hasil yang benar. Pada awalnya, saya menggunakan fungsi RegEx tetapi tidak semua URL dapat menguraikan subdomain dengan benar. Cara praktiknya adalah dengan menggunakan daftar TLD. Setelah TLD untuk URL ditentukan, bagian kiri adalah domain dan sisanya adalah sub domain.

Namun daftar ini perlu dipertahankan karena TLD baru dimungkinkan. Saat ini yang saya tahu adalah publicsuffix.org mempertahankan daftar terbaru dan Anda dapat menggunakan alat parser domainname dari kode google untuk mem-parsing daftar sufiks publik dan mendapatkan sub domain, domain dan TLD dengan mudah menggunakan objek DomainName: domainName.SubDomain, domainName .Domain dan domainName.TLD.

Jawaban ini juga membantu: Dapatkan subdomain dari URL

CaLLMeLaNN

Ini adalah salah satu yang lengkap, dan tidak bergantung pada protokol apa pun.

function getServerURL(url) {
        var m = url.match("(^(?:(?:.*?)?//)?[^/?#;]*)");
        console.log(m[1]) // Remove this
        return m[1];
    }

getServerURL("http://dev.test.se")
getServerURL("http://dev.test.se/")
getServerURL("//ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js")
getServerURL("//")
getServerURL("www.dev.test.se/sdas/dsads")
getServerURL("www.dev.test.se/")
getServerURL("www.dev.test.se?abc=32")
getServerURL("www.dev.test.se#abc")
getServerURL("//dev.test.se?sads")
getServerURL("http://www.dev.test.se#321")
getServerURL("http://localhost:8080/sads")
getServerURL("https://localhost:8080?sdsa")

Cetakan

http://dev.test.se

http://dev.test.se

//ajax.googleapis.com

//

www.dev.test.se

www.dev.test.se

www.dev.test.se

www.dev.test.se

//dev.test.se

http://www.dev.test.se

http://localhost:8080

https://localhost:8080

Tidak satu pun di atas bekerja untuk saya. Inilah yang akhirnya saya gunakan:

/^(?:((?:https?|s?ftp):)\/\/)([^:\/\s]+)(?::(\d*))?(?:\/([^\s?#]+)?([?][^?#]*)?(#.*)?)?/

Saya suka regex yang diterbitkan dalam "Javascript: The Good Parts". Tidak terlalu pendek dan tidak terlalu rumit. Halaman ini di github juga memiliki kode JavaScript yang menggunakannya. Tapi itu bisa diadaptasi untuk bahasa apa pun. https://gist.github.com/voodooGQ/4057330

Java menawarkan kelas URL yang akan melakukan ini. Objek URL Kueri.

Sebagai catatan, PHP menawarkan parse_url () .

Saya akan merekomendasikan tidak menggunakan regex. Panggilan API seperti WinHttpCrackUrl () kurang rentan kesalahan.

http://msdn.microsoft.com/en-us/library/aa384092%28VS.85%29.aspx

Saya mencoba beberapa di antaranya yang tidak memenuhi kebutuhan saya, terutama yang terpilih tertinggi yang tidak mendapatkan url tanpa jalur ( http://example.com/ )

juga kurangnya nama grup membuatnya tidak dapat digunakan (atau mungkin keterampilan jinja2 saya kurang).

jadi ini versi saya yang sedikit dimodifikasi dengan sumbernya menjadi versi pilihan tertinggi di sini:

^((?P<protocol>http[s]?|ftp):\/)?\/?(?P<host>[^:\/\s]+)(?P<path>((\/\w+)*\/)([\w\-\.]+[^#?\s]+))*(.*)?(#[\w\-]+)?$

Menggunakan http://www.fileformat.info/tool/regex.htm regex hometoast berfungsi dengan baik.

Tapi ini masalahnya, saya ingin menggunakan pola regex yang berbeda dalam situasi yang berbeda dalam program saya.

Misalnya, saya memiliki URL ini, dan saya memiliki enumerasi yang mencantumkan semua URL yang didukung dalam program saya. Setiap objek dalam enumerasi memiliki metode getRegexPattern yang mengembalikan pola regex yang kemudian akan digunakan untuk membandingkan dengan URL. Jika pola regex tertentu mengembalikan true, maka saya tahu bahwa URL ini didukung oleh program saya. Jadi, setiap enumerasi memiliki regex sendiri tergantung pada di mana seharusnya terlihat di dalam URL.

Saran Hometoast sangat bagus, tetapi dalam kasus saya, saya pikir itu tidak akan membantu (kecuali saya menyalin tempel regex yang sama di semua enumerasi).

Itu sebabnya saya ingin jawaban untuk memberikan regex untuk setiap situasi secara terpisah. Meskipun +1 untuk di rumah. ;)

Saya tahu Anda mengklaim agnostik bahasa untuk hal ini, tetapi dapatkah Anda memberi tahu kami apa yang Anda gunakan agar kami tahu kemampuan regex apa yang Anda miliki?

Jika Anda memiliki kemampuan untuk pertandingan yang tidak menangkap, Anda dapat mengubah ekspresi hometoast sehingga subekspresi yang tidak Anda minati diatur seperti ini:

(?:SOMESTUFF)

Anda masih harus menyalin dan menempel (dan sedikit memodifikasi) Regex ke banyak tempat, tetapi ini masuk akal - Anda tidak hanya memeriksa untuk melihat apakah subekspresi itu ada, tetapi jika ada sebagai bagian dari URL . Menggunakan pengubah non-menangkap untuk subekspresi dapat memberi Anda apa yang Anda butuhkan dan tidak lebih, yang, jika saya membaca Anda dengan benar, adalah apa yang Anda inginkan.

Sama seperti catatan kecil, ekspresi hometoast tidak perlu menempatkan tanda kurung di sekitar 'untuk' https ', karena ia hanya memiliki satu karakter di sana. Bilangan kuantitatif menghitung satu karakter (atau kelas karakter atau subekspresi) langsung sebelum mereka. Begitu:

https?

akan cocok dengan 'http' atau 'https' dengan baik.

regexp untuk mendapatkan jalur URL tanpa file.

url = ' http: // domain / dir1 / dir2 / somefile ' url.scan (/ ^ (http: // [^ /] +) ((?: / [^ /] +) +) + (? = /)) ? /? (?: [^ /] +)? $ / i) .to_s

Ini dapat berguna untuk menambahkan jalur relatif ke url ini.

Regex untuk melakukan parsing penuh cukup menghebohkan. Saya telah memasukkan referensi balik yang dinamai untuk keterbacaan, dan memecah setiap bagian menjadi baris yang berbeda, tetapi masih terlihat seperti ini:

^(?:(?P<protocol>\w+(?=:\/\/))(?::\/\/))?
(?:(?P<host>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^\/?#:]+)(?::(?P<port>[0-9]+))?)\/)?
(?:(?P<path>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)\/)?
(?P<file>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)
(?:\?(?P<querystring>(?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^#])+))?
(?:#(?P<fragment>.*))?$

Hal yang mengharuskannya begitu bertele-tele adalah bahwa kecuali untuk protokol atau port, setiap bagian dapat berisi entitas HTML, yang membuat penggambaran fragmen cukup rumit. Jadi dalam beberapa kasus terakhir - host, path, file, querystring, dan fragmen, kami mengizinkan entitas html atau karakter apa pun yang bukan a ?atau #. Regex untuk entitas html terlihat seperti ini:

$htmlentity = "&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);"

Ketika itu diekstraksi (saya menggunakan sintaksis kumis untuk mewakilinya), itu menjadi sedikit lebih terbaca:

^(?:(?P<protocol>(?:ht|f)tps?|\w+(?=:\/\/))(?::\/\/))?
(?:(?P<host>(?:{{htmlentity}}|[^\/?#:])+(?::(?P<port>[0-9]+))?)\/)?
(?:(?P<path>(?:{{htmlentity}}|[^?#])+)\/)?
(?P<file>(?:{{htmlentity}}|[^?#])+)
(?:\?(?P<querystring>(?:{{htmlentity}};|[^#])+))?
(?:#(?P<fragment>.*))?$

Dalam JavaScript, tentu saja, Anda tidak bisa menggunakan referensi bernama, jadi regex menjadi

^(?:(\w+(?=:\/\/))(?::\/\/))?(?:((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^\/?#:]+)(?::([0-9]+))?)\/)?(?:((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)\/)?((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^?#])+)(?:\?((?:(?:&(?:amp|apos|gt|lt|nbsp|quot|bull|hellip|[lr][ds]quo|[mn]dash|permil|\#[1-9][0-9]{1,3}|[A-Za-z][0-9A-Za-z]+);)|[^#])+))?(?:#(.*))?$

dan di setiap kecocokan, protokolnya adalah \1, host-nya \2, port-nya \3, path \4, file \5, querystring \6, dan fragmen \7.

//USING REGEX
/**
 * Parse URL to get information
 *
 * @param   url     the URL string to parse
 * @return  parsed  the URL parsed or null
 */
var UrlParser = function (url) {
    "use strict";

    var regx = /^(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/,
        matches = regx.exec(url),
        parser = null;

    if (null !== matches) {
        parser = {
            href              : matches[0],
            withoutHash       : matches[1],
            url               : matches[2],
            origin            : matches[3],
            protocol          : matches[4],
            protocolseparator : matches[5],
            credhost          : matches[6],
            cred              : matches[7],
            user              : matches[8],
            pass              : matches[9],
            host              : matches[10],
            hostname          : matches[11],
            port              : matches[12],
            pathname          : matches[13],
            segment1          : matches[14],
            segment2          : matches[15],
            search            : matches[16],
            hash              : matches[17]
        };
    }

    return parser;
};

var parsedURL=UrlParser(url);
console.log(parsedURL);

Saya mencoba regex ini untuk mem-parsing partisi url:

^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*))(\?([^#]*))?(#(.*))?$

URL: https://www.google.com/my/path/sample/asd-dsa/this?key1=value1&key2=value2

Cocok:

Group 1.    0-7 https:/
Group 2.    0-5 https
Group 3.    8-22    www.google.com
Group 6.    22-50   /my/path/sample/asd-dsa/this
Group 7.    22-46   /my/path/sample/asd-dsa/
Group 8.    46-50   this
Group 9.    50-74   ?key1=value1&key2=value2
Group 10.   51-74   key1=value1&key2=value2

String s = "https://www.thomas-bayer.com/axis2/services/BLZService?wsdl";

String regex = "(^http.?://)(.*?)([/\\?]{1,})(.*)";

System.out.println("1: " + s.replaceAll(regex, "$1"));
System.out.println("2: " + s.replaceAll(regex, "$2"));
System.out.println("3: " + s.replaceAll(regex, "$3"));
System.out.println("4: " + s.replaceAll(regex, "$4"));

Akan memberikan output berikut:
1: https: //
2: www.thomas-bayer.com
3: /
4: axis2 / services / BLZService? Wsdl

Jika Anda mengubah URL ke
String s = " https: //www.thomas -bayer.com?wsdl=qwerwer&ttt=888 "; hasilnya adalah sebagai berikut:
1: https: //
2: www.thomas-bayer.com
3 :?
4: wsdl = qwerwer & ttt = 888

selamat menikmati .. Yosi Lev