Teile einer URL abrufen (Regex)

https://stackoverflow.com/questions/27745

09-06-2019
|

Frage

Gegeben sei die URL (einzelne Zeile):
http://test.example.com/dir/subdir/file.html

Wie kann ich die folgenden Teile mithilfe regulärer Ausdrücke extrahieren:

Die Subdomain (Test)
Die Domain (example.com)
Der Pfad ohne die Datei (/dir/subdir/)
Die Datei (file.html)
Der Pfad mit der Datei (/dir/subdir/file.html)
Die URL ohne Pfad (http://test.example.com)
(fügen Sie alle anderen hinzu, die Ihrer Meinung nach nützlich wären)

Der reguläre Ausdruck sollte auch dann korrekt funktionieren, wenn ich die folgende URL eingebe:

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

Lösung

Ein einzelner Regex zum Analysieren und Aufbrechen einer vollständigen URL, einschließlich Abfrageparametern und Anker zB, z.

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

URL:RegExp['$&'],

Protokoll:RegExp.$2,

host:RegExp.$3,

path:RegExp.$4,

Datei:RegExp.$6,

query:RegExp.$7,

hash:RegExp.$8

Sie könnten den Host dann ganz einfach weiter analysieren ('.' getrennt).

Was ICH würde tun, wäre so etwas zu verwenden:

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

Analysieren Sie „den Rest“ weiter, um so spezifisch wie möglich zu sein.Es in einem regulären Ausdruck zu tun, ist, nun ja, ein bisschen verrückt.

Andere Tipps

Mir ist klar, dass ich zu spät zur Party komme, aber es gibt eine einfache Möglichkeit, den Browser eine URL ohne Regex für Sie analysieren zu lassen:

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

Ich bin ein paar Jahre zu spät dran, aber ich bin überrascht, dass niemand erwähnt hat, dass die Uniform Resource Identifier-Spezifikation eine hat Abschnitt zum Parsen von URIs mit einem regulären Ausdruck.Der von Berners-Lee et al. geschriebene reguläre Ausdruck lautet:

^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9
Die Zahlen in der zweiten Zeile oben dienen lediglich der besseren Lesbarkeit;Sie geben die Referenzpunkte für jede Unterexpression an (dh jede gepaarte Klammern).Wir bezeichnen den Wert, der für die Unterexpression als $ übereinstimmt.Passen Sie beispielsweise den obigen Ausdruck an an

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

führt zu den folgenden Unterausdrucksübereinstimmungen:
$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

Ich habe festgestellt, dass ich den Schrägstrichen in JavaScript entkommen muss:

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

Ich habe festgestellt, dass die Antwort mit der höchsten Bewertung (die Antwort von Hometoast) für mich nicht perfekt funktioniert.Zwei Probleme:

Es kann keine Portnummer verarbeiten.
Der Hash-Teil ist kaputt.

Das Folgende ist eine modifizierte Version:

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

Die Position der Teile ist wie folgt:

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

Von einem anonymen Benutzer gepostete Bearbeitung:

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

Ich brauchte einen regulären Ausdruck, der mit allen URLs übereinstimmt, und habe diesen erstellt:

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

Es stimmt mit allen URLs, jedem Protokoll und sogar mit ähnlichen URLs überein

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

Das Ergebnis (in JavaScript) sieht so aus:

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

Eine URL wie

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

sieht aus wie das:

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

Ich habe versucht, dies in Javascript zu lösen, was erledigt werden sollte von:

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

da es (zumindest in Chrome) analysiert wird zu:

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

Dies ist jedoch nicht browserübergreifend (https://developer.mozilla.org/en-US/docs/Web/API/URL), also habe ich das zusammengeschustert, um die gleichen Teile wie oben herauszuholen:

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

Der Dank für diesen regulären Ausdruck geht an https://gist.github.com/rpflorence wer hat diesen jsperf gepostet? http://jsperf.com/url-parsing (ursprünglich hier zu finden: https://gist.github.com/jlong/2428561#comment-310066), der den regulären Ausdruck entwickelt hat, auf dem dies ursprünglich basierte.

Die Teile sind in dieser Reihenfolge:

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

Es gibt auch eine kleine Bibliothek, die es umschließt und Abfrageparameter bereitstellt:

https://github.com/sadams/lite-url (auch auf Laube erhältlich)

Wenn Sie eine Verbesserung haben, erstellen Sie bitte eine Pull-Anfrage mit weiteren Tests. Ich werde diese akzeptieren und mit Dank zusammenführen.

Schlagen Sie eine viel besser lesbare Lösung vor (in Python, gilt aber für jeden regulären Ausdruck):

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

Drucke:

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

Subdomain und Domain sind schwierig, da die Subdomain aus mehreren Teilen bestehen kann, ebenso wie die Top-Level-Domain. 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://[^/]+/)

(Markdown ist nicht sehr freundlich zu regulären Ausdrücken)

Diese verbesserte Version sollte genauso zuverlässig funktionieren wie ein Parser.

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

Versuche Folgendes:

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

Es unterstützt HTTP/FTP, Subdomains, Ordner, Dateien usw.

Ich habe es über eine schnelle Google-Suche gefunden:

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

Von meiner Antwort auf a ähnliche Frage.Funktioniert besser als einige der anderen genannten, da sie einige Fehler hatten (z. B. keine Unterstützung von Benutzername/Passwort, keine Unterstützung von Dateinamen mit einem Zeichen, fehlerhafte Fragment-IDs).

Mithilfe des Uri-Objekts in .NET können Sie alle http/https-Daten, Hosts, Ports, Pfade und Abfragen abrufen.Die schwierige Aufgabe besteht lediglich darin, den Host in Subdomain, Domainname und TLD zu unterteilen.

Dafür gibt es keinen Standard und es kann nicht einfach String-Parsing oder RegEx verwendet werden, um das richtige Ergebnis zu erzielen.Zuerst verwende ich die RegEx-Funktion, aber nicht alle URLs können die Subdomain korrekt analysieren.Die Praxis besteht darin, eine Liste von TLDs zu verwenden.Nachdem eine TLD für eine URL definiert wurde, ist der linke Teil die Domain und der verbleibende Teil die Subdomain.

Die Liste muss jedoch gepflegt werden, da neue TLDs möglich sind.Der aktuelle Moment, den ich kenne, ist, dass publicsuffix.org die neueste Liste verwaltet und Sie Domainnamen-Parser-Tools aus dem Google-Code verwenden können, um die öffentliche Suffixliste zu analysieren und die Subdomain, Domain und TLD einfach abzurufen, indem Sie das DomainName-Objekt verwenden:domainName.SubDomain, domainName.Domain und domainName.TLD.

Diese Antworten sind auch hilfreich:Holen Sie sich die Subdomain von einer URL

CallMeLaNN

Hier ist eine vollständige Version, die auf keinem Protokoll basiert.

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

Drucke

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

Keines der oben genannten Dinge hat bei mir funktioniert.Folgendes habe ich letztendlich verwendet:

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

Mir gefällt der Regex, der in „Javascript“ veröffentlicht wurde:Die guten Teile“.Es ist nicht zu kurz und nicht zu komplex.Diese Seite auf Github enthält auch den JavaScript-Code, der sie verwendet.Aber es kann für jede Sprache angepasst werden.https://gist.github.com/voodooGQ/4057330

Java bietet eine URL-Klasse, die dies erledigt. URL-Objekte abfragen.

Nebenbei bemerkt bietet PHP parse_url().

Ich würde empfehlen, keinen regulären Ausdruck zu verwenden.Ein API-Aufruf wie WinHttpCrackUrl() ist weniger fehleranfällig.

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

Ich habe einige davon ausprobiert, die meinen Anforderungen nicht entsprachen, insbesondere die mit der höchsten Bewertung, die keine URL ohne Pfad abfing (http://example.com/)

Auch das Fehlen von Gruppennamen machte es in Ansible unbrauchbar (oder vielleicht fehlen mir meine Jinja2-Kenntnisse).

Dies ist also meine leicht modifizierte Version, wobei die Quelle hier die am höchsten bewertete Version ist:

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

Benutzen http://www.fileformat.info/tool/regex.htm Der reguläre Ausdruck von Hometoast funktioniert großartig.

Aber hier ist der Deal: Ich möchte in verschiedenen Situationen in meinem Programm unterschiedliche Regex-Muster verwenden.

Ich habe zum Beispiel diese URL und eine Aufzählung, die alle unterstützten URLs in meinem Programm auflistet.Jedes Objekt in der Aufzählung verfügt über eine Methode getRegexPattern, die das Regex-Muster zurückgibt, das dann zum Vergleich mit einer URL verwendet wird.Wenn das bestimmte Regex-Muster „true“ zurückgibt, weiß ich, dass diese URL von meinem Programm unterstützt wird.Jede Aufzählung hat also ihren eigenen regulären Ausdruck, je nachdem, wo sie in der URL aussehen soll.

Der Vorschlag von Hometoast ist großartig, aber in meinem Fall würde er meiner Meinung nach nicht helfen (es sei denn, ich kopiere und füge in allen Aufzählungen denselben regulären Ausdruck ein).

Deshalb wollte ich, dass die Antwort den regulären Ausdruck für jede Situation separat angibt.Obwohl +1 für Hometoast.;)

Ich weiß, dass Sie in dieser Hinsicht behaupten, sprachunabhängig zu sein, aber können Sie uns sagen, was Sie verwenden, damit wir wissen, über welche Regex-Fähigkeiten Sie verfügen?

Wenn Sie über die Möglichkeit verfügen, Übereinstimmungen nicht zu erfassen, können Sie den Ausdruck von hometoast so ändern, dass Unterausdrücke, die Sie nicht erfassen möchten, wie folgt eingerichtet werden:

(?:SOMESTUFF)

Sie müssten den Regex immer noch kopieren und an mehreren Stellen einfügen (und leicht ändern), aber das macht Sinn – Sie überprüfen nicht nur, ob der Unterausdruck existiert, sondern vielmehr, ob er existiert als Teil einer URL.Die Verwendung des nicht einfangenden Modifikators für Unterausdrücke kann Ihnen das geben, was Sie brauchen, und nicht mehr, was, wenn ich Sie richtig verstehe, genau das ist, was Sie wollen.

Nur als kleine, kleine Anmerkung: Hometoasts Ausdruck muss nicht in Klammern um das „s“ für „https“ gesetzt werden, da er dort nur ein Zeichen enthält.Quantifizierer quantifizieren das eine Zeichen (oder die Zeichenklasse oder den Unterausdruck), das ihnen direkt vorangeht.Also:

https?

würde gut mit „http“ oder „https“ übereinstimmen.

regexp, um den URL-Pfad ohne die Datei zu erhalten.

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

Dies kann nützlich sein, um dieser URL einen relativen Pfad hinzuzufügen.

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

Liefert die folgende Ausgabe:
1:https://
2:www.thomas-bayer.com
3: /
4:axis2/services/BLZService?wsdl

Wenn Sie die URL ändern in
Zeichenfolge s = "https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888";Die Ausgabe wird wie folgt sein:
1:https://
2:www.thomas-bayer.com
3: ?
4:wsdl=qwerwer&ttt=888

genießen..
Yosi Lev

Der reguläre Ausdruck zum vollständigen Parsen ist ziemlich schrecklich.Ich habe zur besseren Lesbarkeit benannte Rückverweise eingefügt und jeden Teil in separate Zeilen unterteilt, aber es sieht immer noch so aus:

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

Der Grund dafür, dass es so ausführlich sein muss, besteht darin, dass alle Teile außer dem Protokoll oder dem Port HTML-Entitäten enthalten können, was die Abgrenzung des Fragments ziemlich schwierig macht.In den letzten Fällen – Host, Pfad, Datei, Abfragezeichenfolge und Fragment – erlauben wir also entweder jede HTML-Entität oder jedes Zeichen, das kein ist ? oder #.Der reguläre Ausdruck für eine HTML-Entität sieht folgendermaßen aus:

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

Wenn das extrahiert wird (ich habe zur Darstellung eine Schnurrbart-Syntax verwendet), wird es etwas besser lesbar:

^(?:(?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 können Sie natürlich keine benannten Rückverweise verwenden, daher wird der reguläre Ausdruck

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

und in jedem Spiel ist das Protokoll \1, der Gastgeber ist \2, der Hafen ist \3, der Weg \4, die Datei \5, der Abfragestring \6, und das 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);

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow