Om dele van'n URL (Regex)

StackOverflow https://stackoverflow.com/questions/27745

  •  09-06-2019
  •  | 
  •  

Vra

Gegewe die URL (enkele lyn):
http://test.example.com/dir/subdir/file.html

Hoe kan ek haal die volgende dele met behulp van gereelde uitdrukkings:

  1. Die Subdomein (toets)
  2. Die Domein (example.com)
  3. Die pad sonder die lêer (/dir/subdir/)
  4. Die lêer (file.html)
  5. Die pad met die lêer (/dir/subdir/file.html)
  6. Die URL sonder die pad (http://test.example.com)
  7. (voeg enige ander wat jy dink sou nuttig wees)

Die regex moet korrek werk selfs as ek tik die volgende URL: 

http://example.example.com/example/example/example.html
Was dit nuttig?

Oplossing

  

'n enkel regex te ontleed en ontbinding 'n   volle URL insluitend navraag parameters   en ankers Bv.

     

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 posisies:

     

url: regexp [ '$ &'],

     

protokol. Regexp $ 2

     

leër. Regexp $ 3,

     

pad. Regexp $ 4

     

lêer:. Regexp $ 6

     

navraag:. Regexp $ 7,

     

hash:. Regexp $ 8

jy kan dan verder ontleed die gasheer ( '. "Afgebaken) redelik maklik.

Wat I sal doen, is iets soos hierdie gebruik: 

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

die verdere parse 'die res' tot so spesifiek as moontlik wees. dit doen in een regex is, wel, 'n bietjie mal.

Ander wenke

Ek besef ek is laat om die party, maar daar is 'n eenvoudige manier om jou te laat die leser ontleed 'n url vir jou sonder 'n 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
*/

Ek is 'n paar jaar laat om die party, maar ek is verbaas niemand het melding gemaak van die Uniform Resource Identifier spesifikasie het 'n artikel op die ontleding van URIs met 'n gewone uitdrukking . . Die gewone uitdrukking, geskryf deur Berners-Lee, et al, is: 

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

Die getalle in die tweede reël hierbo is net om leesbaarheid te help;   hulle dui die verwysing punte vir elke subexpression (dit wil sê, elke   saam hakies). Ons verwys na die waarde wat ooreenstem vir subexpression    as $. Byvoorbeeld, wat ooreenstem met die bogenoemde uitdrukking

     

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

     

resultate in die volgende subexpression wedstryde: 

$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

Vir wat dit werd is, het ek gevind dat ek moes ontsnap die vorentoe houe in JavaScript:

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

Ek het die hoogste gestem antwoord (antwoord Home Toast se) nie goed werk vir my. Twee probleme:

  1. Dit kan nie hanteer poort nommer.
  2. Die hash deel is gebreek.

Die volgende is 'n aangepaste weergawe: 

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

Posisie van dele is soos volg: 

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

Edit opgelaai deur anon gebruiker: 

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

Ek benodig 'n gewone uitdrukking aan alle URL's aan te pas en het hierdie een: 

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

Dit pas by alle URL's, enige protokol, selfs urls soos 

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

Die resultaat (in JavaScript) lyk soos volg: 

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

'n url soos 

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

lyk soos volg: 

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

Ek het probeer om hierdie op te los in JavaScript, wat deur hanteer moet word: 

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

sedert (in Chrome, ten minste) is dit ontleed om: 

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

Dit is egter nie kruis leser ( https: // ontwikkelaar .mozilla.org / nl-nL / docs / Web / API / URL ), so ek geplaveide hierdie saam na dieselfde gedeeltes uit soos hierbo trek: 

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

Krediet vir hierdie regex gaan na https://gist.github.com/rpflorence wat hierdie gepos jsperf http://jsperf.com/url-parsing (oorspronklik hier gevind: https://gist.github.com/jlong/2428561#comment-310066 ) wat saam met die regex hierdie is oorspronklik gebaseer op.

Die dele is in hierdie volgorde: 

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

Daar is ook 'n klein biblioteek wat dit vou en bied navraag params:

https://github.com/sadams/lite-url (ook beskikbaar op Bower )

As jy 'n verbetering, stuur skep 'n trek versoek met meer toetse en Ek sal aanvaar en saam te smelt met dank.

Stel 'n baie meer leesbare oplossing (in Python, maar is van toepassing op enige regex): 

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

Afdrukke: 

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

subdomein en domein is moeilik, want die subdomein verskeie dele kan hê, as kan die boonste vlak domein 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://[^/]+/)

(Afprijzingsmanager is nie baie vriendelik om regexes)

Dit verbeterde weergawe moet as betroubaar werk as 'n ontleder. 

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

Probeer die volgende: 

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

Dit ondersteun HTTP / FTP, subdomeinen, dopgehou, lêers, ens.

Ek het gevind dat dit uit 'n vinnige Google-soektog:

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

Van my antwoord op 'n soortgelyke vraag . Werk beter as 'n paar van die genoemde want hulle het 'n paar foute (soos nie ondersteun gebruikersnaam / wagwoord, nie ondersteun enkel-karakter lêername, fragment identifiseerders gebreek) ander.

Jy kan kry al die http / https, gasheer, port, pad asook navraag deur gebruik te maak van Uri voorwerp in NET. net die moeilike taak is om die gasheer te breek in sub domein domein naam en TLD.

Daar is geen standaard om dit te doen en kan nie net gebruik string parsing of RegEx om die korrekte resultaat te produseer. Op die eerste, gebruik ek RegEx funksie, maar nie almal URL kan wees ontleed die subdomein korrek. Die praktyk manier is om 'n lys van TLDs gebruik. Na 'n TLD vir 'n URL word gedefinieer links deel is domein en die oorblywende is sub domein.

Maar die lys moet dit in stand te hou, aangesien nuwe TLDs is moontlik. Die huidige oomblik wat ek weet is publicsuffix.org handhaaf die nuutste lys en jy kan domein-parser gereedskap gebruik van Google-kode vir die publiek agtervoegsel lys ontleed en kry die sub-domein, domein en TLD maklik deur die gebruik van Domeinnaam voorwerp: domainName.SubDomain, domein .Domain en domainName.TLD.

Dit antwoord ook nuttig: Kry die subdomein van 'n URL

CaLLMeLaNN

Hier is een wat voltooi is, en nie die geval staatmaak op enige protokol. 

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

Afdrukke 

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

Nie een van die opsies nie vir my gewerk het. Hier is wat ek beland met behulp: 

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

Ek hou van die regex wat in gepubliseer "JavaScript: The Good Parts". Dit is nie te kort en nie te ingewikkeld. Hierdie bladsy op GitHub het ook die JavaScript-kode wat dit gebruik. Maar dit 'n aangepas word vir enige taal. https://gist.github.com/voodooGQ/4057330

Java bied 'n URL klas dat dit sal doen. Query URL voorwerpe.

Op 'n kant nota, PHP bied parse_url () .

Ek sou aanbeveel nie die gebruik van regex. 'N API oproep soos WinHttpCrackUrl () is minder gevoelig vir foute.

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

Ek het probeer om 'n paar van hierdie wat nie bedek my behoeftes, veral die hoogste gestem wat nie 'n url het vang sonder 'n pad ( http://example.com/ )

ook 'n gebrek aan name groep het dit onbruikbaar in ansible (of miskien my jinja2 vaardighede ontbreek).

so hierdie is my weergawe effens aangepaste met die bron synde die hoogste gestem weergawe hier: 

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

Die gebruik van http://www.fileformat.info/tool/regex.htm regex Home Toast se werk baie goed.

Maar hier is die deal, ek wil verskillende regex patrone in verskillende situasies te gebruik in my program.

Byvoorbeeld, ek het hierdie URL, en ek het 'n opsomming wat al ondersteun URLs lys in my program. Elke voorwerp in die opsomming het 'n metode getRegexPattern dat die regex patroon wat dan gebruik sal word om te vergelyk met 'n URL terugkeer. As die besonder regex patroon ware terugkeer, dan weet ek dat hierdie URL word ondersteun deur my program. So, elke opsomming het sy eie regex afhangende van waar dit moet lyk binne-in die URL.

Home Toast se voorstel is 'n groot, maar in my geval, ek dink dit sal nie help nie (tensy ek kopieer plak dieselfde regex in al keuse lys).

Dit is hoekom ek die antwoord wou die regex vir elke situasie afsonderlik gee. Alhoewel 1 vir Home Toast. ;)

Ek weet jy beweer taal-agnostikus op hierdie, maar kan jy ons vertel wat jy gebruik net sodat ons weet wat regex vermoëns wat jy het?

As jy het die vermoëns vir nie-die opneem van die wedstryde, kan jy verander hometoast se uitdrukking sodat subexpressions dat jy nie belangstel in die bewaring is opgestel soos hierdie:

(?:SOMESTUFF)

Jy wil nog steeds om te kopieer en plak (en effens verander) die Regex in verskeie plekke, maar dit maak sin-jy is nie net die nagaan om te sien of die subexpression bestaan nie, maar eerder as dit bestaan as deel van'n URL.Die gebruik van die nie-vaslegging wysiger vir subexpressions kan gee wat jy nodig het en niks meer nie, wat, as ek lees jou reg, is wat jy wil hê.

Net soos'n klein, klein noot, hometoast se uitdrukking nie nodig het om te sit tussen hakies rondom die " s " vir "https" nie, aangesien hy net een karakter in daar.Quantifiers kwantifiseer die een karakter (of karakter klas of subexpression) direk voor hulle.So:

https?

sou pas "http of https" net'n boete.

regexp om die URL pad kry sonder die lêer.

url = ' http: // domein / map1 / map2 / somefile ' url.scan (/ ^ (http: // [^ /] +) ((:? / [^ /] +) + (= /)) / (:????? [^ /] +) $ / i) .to_s

Dit kan nuttig wees vir die toevoeging van 'n relatiewe pad na hierdie url wees. 

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

Sal voorsien die volgende afvoer:
    1: https: //
    2: www.thomas-bayer.com
    3: /
    4:? Axis2 / dienste / BLZService WSDL

As jy die URL verander na
    String s = " https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888 "; die uitset sal as volg wees:
    1: https: //
    2: www.thomas-bayer.com
    3:?
    4: WSDL = qwerwer & TTT = 888

geniet ..
Yosi Lev

Die regex volle ontleding doen is nogal vreeslik. Ek het ingesluit die naam backreferences vir leesbaarheid, en verbreek elke deel in afsonderlike lyne, maar dit lyk nog soos volg: 

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

Die ding wat dit verg so verbose te wees, is dat behalwe vir die protokol of die hawe, enige van die dele kan HTML entiteite bevat, wat afbakening van die fragment nogal lastig maak. So in die laaste paar gevalle - die gasheer, pad, lêer, soektog string, en fragment, laat ons óf enige html entiteit of enige karakter wat nie 'n ? of #. Die regex vir 'n html entiteit lyk soos volg: 

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

As dit is 'n uittreksel (Ek gebruik 'n snor sintaksis om dit voor te stel), word dit 'n bietjie meer leesbaar: 

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

In JavaScript, natuurlik, jy kan dit nie gebruik vernoem backreferences, so die regex word 

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

en in elke wedstryd, die protokol is \1, die gasheer is \2, die hawe is \3, die pad \4, die lêer \5, die soektog string \6, en die fragment \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);
Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top