Bir URL'nin bölümlerini alma (Regex)

URL (tek satır) verildiğinde:
http://test.example.com/dir/subdir/file.html

Normal ifadeleri kullanarak aşağıdaki parçaları nasıl çıkarabilirim:

1. Alt alan (test)
2. Alan (example.com)
3. Dosyasız yol (/ dir / subdir /)
4. Dosya (file.html)
5. Dosyanın bulunduğu yol (/dir/subdir/file.html)
6. Yol olmadan URL ( http://test.example.com )
7. (yararlı olacağını düşündüğünüz diğerlerini ekleyin)

Aşağıdaki URL'yi girsem bile normal ifade düzgün çalışmalıdır:

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

Tam bir URL'yi ayrıştırmak ve parçalamak için tek bir normal ifade, örneğin, sorgu parametreleri ve çapalar dahil

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\-]+)?$

RexEx pozisyonları:

url: RegExp ['$ &'],

protokolü:. RegExp 2 $,

konak:. RegExp 3 $,

yol:. RegExp $ 4,

Dosya:. RegExp 6 $,

Sorgu:. RegExp 7 $,

karma:. RegExp 8 $

daha sonra ana bilgisayarı ('.' ile sınırlandırılmış) kolayca ayrıştırabilirsiniz.

Ne ben yapardım böyle kullanılması şeydir:

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

'geri kalanı' olabildiğince spesifik olacak şekilde daha da ayrıştırın. Bunu tek bir düzenli ifadede yapmak biraz çılgınca.

Partiye geciktiğimin farkındayım, ancak tarayıcının sizin için bir normal ifade olmadan bir url'yi ayrıştırmasına izin vermenin basit bir yolu var:

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
*/

Partiye birkaç yıl geç kaldım, ancak hiç kimsenin Tekdüzen Kaynak Tanımlayıcısı spesifikasyonunun URI'leri normal bir ifadeyle ayrıştırmayla ilgili bir bölümü olduğundan bahsetmediğine şaşırdım . Berners-Lee ve diğerleri tarafından yazılan normal ifade şöyledir:

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

Yukarıdaki ikinci satırdaki sayılar yalnızca okunabilirliğe yardımcı olmak içindir; her bir alt ifade için referans noktalarını gösterirler (yani, her bir çift parantez). Alt ifade için eşleşen değeri $ olarak adlandırıyoruz. Örneğin, yukarıdaki ifadeyle eşleştirme

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

aşağıdaki alt ifade eşleşmeleriyle sonuçlanır:

$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

Ne olursa olsun, JavaScript'teki eğik çizgilerden kaçmam gerektiğini anladım:

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

En yüksek oyu alan cevabın (hometoast cevabı) benim için mükemmel çalışmadığını buldum. İki sorun:

1. Port numarasını işleyemez.
2. Hash kısmı bozuldu.

Aşağıdakiler değiştirilmiş bir versiyondur:

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

Parçaların konumu aşağıdaki gibidir:

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

Anon kullanıcısı tarafından yayınlanan düzenleme:

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

Tüm url'lerle eşleşecek normal bir İfadeye ihtiyacım vardı ve bunu yaptım:

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

Tüm url'lerle, herhangi bir protokolle, hatta gibi url'lerle eşleşir

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

Sonuç (JavaScript'te) şöyle görünür:

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

Gibi bir url

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

buna benzer:

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

Bunu javascript ile çözmeye çalışıyordum ki bu şu şekilde ele alınmalıdır:

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

çünkü (en azından Chrome'da) şu şekilde ayrıştırılır:

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

Ancak, bu çapraz tarayıcı değil ( https://developer.mozilla.org/en-US/docs/Web/API/URL ), bu yüzden yukarıdaki ile aynı parçaları çıkarmak için bunu bir araya getirdim:

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

Bu regex için kredi, bu jsperf'i yayınlayan https://gist.github.com/rpflorence adresine gider http://jsperf.com/url-parsing (orijinal olarak burada bulunur: https://gist.github.com/jlong/2428561 # comment-310066 ) bunun temelini oluşturan normal ifadeyi kim buldu?

Parçalar şu sıradadır:

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

Ayrıca, onu saran ve sorgu parametreleri sağlayan küçük bir kitaplık vardır:

https://github.com/sadams/lite-url (bower'da da mevcuttur)

Bir iyileştirmeniz varsa, lütfen daha fazla test içeren bir çekme isteği oluşturun, ben de kabul edip teşekkürle birleşeceğim.

Çok daha okunaklı bir çözüm önerin (Python'da, ancak herhangi bir normal ifade için geçerlidir):

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

Baskılar:

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

alt etki alanı ve etki alanı zordur çünkü alt etki alanı, üst düzey etki alanı http://sub1.sub2.domain.co.uk/ gibi birkaç parçaya sahip olabilir.

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

(Markdown normal ifadelere pek uygun değildir)

Bu geliştirilmiş sürüm, bir ayrıştırıcı kadar güvenilir çalışmalıdır.

   // 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'
   }

Takip etmeyi dene:

^((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+)*)?

HTTP / FTP'yi, alt alanları, klasörleri, dosyaları vb. Destekler.

Hızlı bir google aramasından buldum:

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>#(.*))?$/

Benzer bir soruya verdiğim cevaptan . Bazı hataları olduğu için (kullanıcı adı / parolayı desteklememesi, tek karakterli dosya adlarını desteklememesi, parça tanımlayıcılarının kırılması gibi) belirtilen diğerlerinden daha iyi çalışır.

NET'te Uri nesnesini kullanarak tüm http / https, ana bilgisayar, bağlantı noktası, yol ve sorguları alabilirsiniz. sadece zor olan görev, ana bilgisayarı alt etki alanına, etki alanına ve TLD'ye bölmektir.

Bunu yapmak için bir standart yoktur ve doğru sonucu üretmek için dize ayrıştırması veya Normal İfade kullanılamaz. İlk başta, RegEx işlevini kullanıyorum, ancak tüm URL'ler alt alan adını doğru şekilde ayrıştıramıyor. Uygulama yolu, TLD'lerin bir listesini kullanmaktır. Bir URL için TLD tanımlandıktan sonra, sol kısım alan ve kalan kısım alt alandır.

Ancak, yeni TLD'ler mümkün olduğundan listenin sürdürülmesi gerekir. Şu an bildiğim şu an publicsuffix.org'un en son listeyi koruduğu ve genel son ek listesini ayrıştırmak ve DomainName nesnesini kullanarak alt etki alanını, etki alanını ve TLD'yi kolayca almak için google kodundan alan adı ayrıştırıcı araçlarını kullanabilirsiniz: domainName.SubDomain, domainName .Domain ve domainName.TLD.

Bu yanıtlar ayrıca yardımcı olur: Alt etki alanını bir URL'den alın

CaLLMeLaNN

İşte tam olan ve herhangi bir protokole dayanmayan bir tane.

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

Baskılar

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

Yukarıdakilerin hiçbiri benim için işe yaramadı. İşte kullandığım şey:

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

"Javascript: The Good Parts" da yayınlanan normal ifadeyi beğendim. Ne çok kısa ne de çok karmaşık. Github'daki bu sayfada, onu kullanan JavaScript kodu da vardır. Ancak herhangi bir dile uyarlanabilir. https://gist.github.com/voodooGQ/4057330

Java, bunu yapacak bir URL sınıfı sunar. URL Nesnelerini Sorgula.

Bir yan not olarak, PHP parse_url () sunar .

Normal ifadeyi kullanmamanızı tavsiye ederim. WinHttpCrackUrl () gibi bir API çağrısı daha az hataya meyillidir.

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

Bunlardan ihtiyaçlarımı karşılamayan birkaçını denedim, özellikle de yolu olmayan bir url'yi yakalamayan en yüksek oyu ( http://example.com/ )

ayrıca grup isimlerinin olmaması onu yanıtlanamaz hale getirdi (veya belki de jinja2 becerilerim eksiktir).

bu yüzden bu benim versiyonum biraz değiştirilmiş, kaynak buradaki en yüksek oyu alan versiyon:

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

Http://www.fileformat.info/tool/regex.htm hometoast'ın normal ifadesini kullanmak harika çalışıyor.

Ama anlaşma şu, programımda farklı durumlarda farklı normal ifade kalıpları kullanmak istiyorum.

Örneğin, bu URL’ye sahibim ve programımda desteklenen tüm URL’leri listeleyen bir numaram var. Numaralandırmadaki her nesnenin, daha sonra bir URL ile karşılaştırmak için kullanılacak normal ifade modelini döndüren bir getRegexPattern yöntemi vardır. Belirli normal ifade kalıbı true değerini döndürürse, bu URL'nin programım tarafından desteklendiğini biliyorum. Bu nedenle, her numaralandırmanın, URL'nin içinde nereye bakması gerektiğine bağlı olarak kendi normal ifadesi vardır.

Hometoast'ın önerisi harika, ancak benim durumumda yardımcı olmayacağını düşünüyorum (aynı normal ifadeyi tüm numaralandırmalarda kopyalayıp yapıştırmadığım sürece).

Bu yüzden cevabın her durum için ayrı ayrı normal ifadeyi vermesini istedim. Hometoast için +1 olmasına rağmen. ;)

Bu konuda dilden bağımsız olduğunu iddia ettiğinizi biliyorum, ancak bize ne kullandığınızı söyleyebilir misiniz, böylece hangi normal ifade yeteneklerine sahip olduğunuzu öğrenebilir miyiz?

Eşleşmeleri yakalamayan yetenekleriniz varsa, hometoast'ın ifadesini, yakalamakla ilgilenmediğiniz alt ifadelerin şu şekilde ayarlanmasını sağlayacak şekilde değiştirebilirsiniz:

(?:SOMESTUFF)

Yine de Regex'i birden çok yere kopyalayıp yapıştırmanız (ve biraz değiştirmeniz) gerekir, ancak bu mantıklıdır - yalnızca alt ifadenin var olup olmadığını değil, bunun yerine bir URL'nin parçası olarak var olup olmadığını kontrol edersiniz . Alt ifadeler için yakalamayan değiştiriciyi kullanmak size ihtiyacınız olanı verebilir ve daha fazlasını verebilir, eğer sizi doğru okuyorsam, istediğiniz şey budur.

Tıpkı küçük, küçük bir not gibi, hometoast ifadesinin "https" için "s" nin etrafına parantez koyması gerekmez, çünkü orada yalnızca bir karakter vardır. Nicelik belirteçleri, doğrudan onlardan önce gelen bir karakteri (veya karakter sınıfını veya alt ifadeyi) nicelendirir. Yani:

https?

"http" veya "https" ile tam olarak eşleşir.

URL yolunu dosya olmadan almak için regexp.

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

Bu url'ye göreceli bir yol eklemek için faydalı olabilir.

Tam ayrıştırma yapmak için normal ifade oldukça korkunçtur. Okunaklılık için adlandırılmış geri referansları ekledim ve her bölümü ayrı satırlara böldüm, ancak yine de şöyle görünüyor:

^(?:(?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>.*))?$

Bu kadar ayrıntılı olmasını gerektiren şey, protokol veya bağlantı noktası dışında parçalardan herhangi birinin HTML öğeleri içerebilmesidir, bu da parçanın tasvirini oldukça zor hale getirir. Yani son birkaç durumda - konak, yol dosyaya, querystring ve fragmanı, herhangi bir html varlık ya da olmasın herhangi bir karakter ya izin ?veya #. Bir html varlığının normal ifadesi şuna benzer:

$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]+);"

Bu çıkarıldığında (onu temsil etmek için bir bıyık sözdizimi kullandım), biraz daha okunaklı hale geliyor:

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

Elbette JavaScript'te adlandırılmış geri referansları kullanamazsınız, bu nedenle normal ifade

^(?:(\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]+);)|[^#])+))?(?:#(.*))?$

ve her eşleşmede protokol, \1ana bilgisayar, \2bağlantı noktası, \3yol \4, dosya \5, sorgu dizesi \6ve parçadır \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);

Bu regex'i url bölümlerini ayrıştırmak için denedim:

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

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

Maçlar:

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

Aşağıdaki çıktıyı sağlayacaktır:
1: https: //
2: www.thomas-bayer.com
3: /
4: axis2 / services / BLZService? Wsdl

URL'yi
String s = " https: //www.thomas olarak değiştirirseniz -bayer.com?wsdl=qwerwer&ttt=888 "; çıktı şu şekilde olacaktır:
1: https: //
2: www.thomas-bayer.com
3 :?
4: wsdl = qwerwer & ttt = 888

keyfini çıkarın ..
Yosi Lev