Obtenir des parties d'une URL (Regex)

https://stackoverflow.com/questions/27745

09-06-2019
|

Question

Compte tenu de l'URL (une seule ligne) :
http://test.example.com/dir/subdir/file.html

Comment puis-je extraire les parties suivantes à l'aide d'expressions régulières :

Le sous-domaine (test)
Le domaine (exemple.com)
Le chemin sans le fichier (/dir/subdir/)
Le fichier (fichier.html)
Le chemin avec le fichier (/dir/subdir/file.html)
L'URL sans le chemin (http://test.example.com)
(ajoutez tout autre que vous jugez utile)

L'expression régulière devrait fonctionner correctement même si je saisis l'URL suivante :

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

La solution

Une seule expression régulière pour analyser et décomposer un objet URL complète, y compris les paramètres de requête et des ancres, p. ex.

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

Postes RexEx :

URL :RegExp['$&'],

protocole :RegExp.$2,

hôte : RegExp. 3 $,

chemin :RegExp.$4,

fichier:RegExp.$6,

requête : RegExp.$7,

hachage : RegExp. 8 $

vous pouvez ensuite analyser davantage l'hôte (délimité par '.') assez facilement.

Quoi je ce que je ferais, c'est d'utiliser quelque chose comme ceci :

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

Ensuite, analysez «le reste» pour être aussi précis que possible.Le faire dans une seule expression régulière est, eh bien, un peu fou.

Autres conseils

Je me rends compte que je suis en retard à la fête, mais il existe un moyen simple de laisser le navigateur analyser une URL pour vous sans expression régulière :

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

J'arrive avec quelques années de retard à la fête, mais je suis surpris que personne n'ait mentionné que la spécification Uniform Resource Identifier a un section sur l'analyse des URI avec une expression régulière.L'expression régulière, écrite par Berners-Lee et al., est :

^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9
Les chiffres de la deuxième ligne ci-dessus servent uniquement à faciliter la lisibilité ;ils indiquent les points de référence pour chaque sous-expression (c’est-à-dire chaque parenthèses appariées).Nous nous référons à la valeur correspondante pour la sous-expression en $.Par exemple, faire correspondre l'expression ci-dessus à

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

donne les correspondances de sous-expressions suivantes :
$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

Pour ce que ça vaut, j'ai découvert que je devais échapper aux barres obliques en JavaScript :

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

J'ai trouvé que la réponse la plus votée (réponse de hometoast) ne fonctionnait pas parfaitement pour moi.Deux problèmes :

Il ne peut pas gérer le numéro de port.
La partie hachage est cassée.

Ce qui suit est une version modifiée :

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

La position des pièces est la suivante :

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

Modification publiée par un utilisateur anonyme :

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

J'avais besoin d'une expression régulière pour correspondre à toutes les URL et j'ai créé celle-ci :

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

Il correspond à toutes les URL, à n'importe quel protocole, même aux URL comme

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

Le résultat (en JavaScript) ressemble à ceci :

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

Une URL comme

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

ressemble à ça:

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

J'essayais de résoudre ce problème en javascript, qui devrait être géré par :

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

puisque (dans Chrome, au moins) il analyse :

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

Cependant, ce n'est pas multi-navigateur (https://developer.mozilla.org/en-US/docs/Web/API/URL), j'ai donc bricolé cela pour extraire les mêmes pièces que ci-dessus :

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

Le mérite de cette expression régulière revient à https://gist.github.com/rpflorence qui a posté ce jsperf http://jsperf.com/url-parsing (à l'origine trouvé ici : https://gist.github.com/jlong/2428561#comment-310066) qui a proposé l'expression régulière sur laquelle elle était initialement basée.

Les pièces sont dans cet ordre :

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

Il existe également une petite bibliothèque qui l'encapsule et fournit des paramètres de requête :

https://github.com/sadams/lite-url (également disponible sur bower)

Si vous avez une amélioration, veuillez créer une pull request avec plus de tests et j'accepterai et fusionnerai avec merci.

Proposer une solution beaucoup plus lisible (en Python, mais s'applique à n'importe quelle 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')

Impressions :

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

le sous-domaine et le domaine sont difficiles car le sous-domaine peut comporter plusieurs parties, tout comme le domaine de premier niveau, 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 n'est pas très convivial pour les expressions rationnelles)

Cette version améliorée devrait fonctionner de manière aussi fiable qu'un analyseur.

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

Essayez ce qui suit :

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

Il prend en charge HTTP/FTP, les sous-domaines, les dossiers, les fichiers, etc.

Je l'ai trouvé en effectuant une recherche rapide sur Google :

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

D'après ma réponse sur un question similaire.Fonctionne mieux que certains des autres mentionnés car ils présentaient quelques bugs (comme ne pas prendre en charge le nom d'utilisateur/mot de passe, ne pas prendre en charge les noms de fichiers à un seul caractère, les identifiants de fragments étant cassés).

Vous pouvez obtenir tous les http/https, hôtes, ports, chemins ainsi que requêtes en utilisant l'objet Uri dans .NET.la tâche difficile consiste simplement à diviser l'hôte en sous-domaine, nom de domaine et TLD.

Il n'y a pas de norme pour le faire et on ne peut pas simplement utiliser l'analyse de chaînes ou RegEx pour produire le résultat correct.Au début, j'utilise la fonction RegEx mais toutes les URL ne peuvent pas analyser correctement le sous-domaine.La méthode pratique consiste à utiliser une liste de TLD.Une fois qu'un TLD pour une URL est défini, la partie gauche est un domaine et le reste est un sous-domaine.

Cependant, la liste doit être maintenue puisque de nouveaux TLD sont possibles.Pour le moment, je sais que publicsuffix.org maintient la dernière liste et vous pouvez utiliser les outils d'analyse de noms de domaine du code Google pour analyser la liste des suffixes publics et obtenir facilement le sous-domaine, le domaine et le TLD en utilisant l'objet DomainName :domainName.SubDomain, domainName.Domain et domainName.TLD.

Cette réponse est également utile :Récupérer le sous-domaine à partir d'une URL

CaLLMeLaNN

En voici un qui est complet et ne repose sur aucun protocole.

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

Impressions

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

Aucune des solutions ci-dessus n'a fonctionné pour moi.Voici ce que j'ai fini par utiliser :

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

J'aime l'expression régulière publiée en "Javascript :Les bonnes pièces".Ce n'est ni trop court ni trop complexe.Cette page sur github contient également le code JavaScript qui l'utilise.Mais il peut être adapté à n'importe quelle langue.https://gist.github.com/voodooGQ/4057330

Java propose une classe d'URL qui fera cela. Interrogez les objets URL.

En passant, PHP propose analyser_url().

Je recommanderais de ne pas utiliser de regex.Un appel API comme WinHttpCrackUrl() est moins sujet aux erreurs.

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

J'en ai essayé quelques-uns qui ne répondaient pas à mes besoins, en particulier le plus voté qui n'a pas capté d'URL sans chemin (http://exemple.com/)

le manque de noms de groupe l'a également rendu inutilisable dans ansible (ou peut-être que mes compétences en jinja2 font défaut).

voici donc ma version légèrement modifiée, la source étant la version la plus votée ici :

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

En utilisant http://www.fileformat.info/tool/regex.htm L'expression régulière de hometoast fonctionne très bien.

Mais voici le problème, je souhaite utiliser différents modèles d'expressions régulières dans différentes situations de mon programme.

Par exemple, j'ai cette URL et une énumération qui répertorie toutes les URL prises en charge dans mon programme.Chaque objet de l'énumération possède une méthode getRegexPattern qui renvoie le modèle d'expression régulière qui sera ensuite utilisé pour comparer avec une URL.Si le modèle d'expression régulière particulier renvoie vrai, alors je sais que cette URL est prise en charge par mon programme.Ainsi, chaque énumération a sa propre expression régulière en fonction de l'endroit où elle doit apparaître dans l'URL.

La suggestion de Hometoast est excellente, mais dans mon cas, je pense que cela n'aiderait pas (à moins que je ne copie et colle la même expression régulière dans toutes les énumérations).

C'est pourquoi je voulais que la réponse donne l'expression régulière pour chaque situation séparément.Bien que +1 pour hometoast.;)

Je sais que vous prétendez être indépendant de la langue à ce sujet, mais pouvez-vous nous dire ce que vous utilisez juste pour que nous sachions de quelles capacités d'expression régulière vous disposez ?

Si vous disposez des fonctionnalités nécessaires pour les correspondances sans capture, vous pouvez modifier l'expression de hometoast afin que les sous-expressions que vous ne souhaitez pas capturer soient configurées comme ceci :

(?:SOMESTUFF)

Vous devrez toujours copier et coller (et légèrement modifier) l'expression régulière à plusieurs endroits, mais cela a du sens : vous ne vérifiez pas seulement si la sous-expression existe, mais plutôt si elle existe. dans le cadre d'une URL.L'utilisation du modificateur de non-capture pour les sous-expressions peut vous donner ce dont vous avez besoin et rien de plus, ce qui, si je vous ai bien lu, est ce que vous voulez.

Juste une toute petite note : l'expression de hometoast n'a pas besoin de mettre entre parenthèses le « s » pour « https », puisqu'il ne contient qu'un seul caractère.Les quantificateurs quantifient le caractère (ou la classe de caractères ou la sous-expression) qui les précède directement.Donc:

https?

correspondrait très bien à « http » ou « https ».

regexp pour obtenir le chemin de l'URL sans le fichier.

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

Cela peut être utile pour ajouter un chemin relatif à cette URL.

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

Fournit le résultat suivant :
1:https://
2 :www.thomas-bayer.com
3: /
4 :axis2/services/BLZService?wsdl

Si vous modifiez l'URL en
Chaîne s = "https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888" ;le résultat sera le suivant :
1:https://
2 :www.thomas-bayer.com
3: ?
4 :wsdl=qwerwer&ttt=888

apprécier..
Yosi Lev

L'expression régulière pour effectuer une analyse complète est assez horrible.J'ai inclus des références arrière nommées pour plus de lisibilité et j'ai divisé chaque partie en lignes distinctes, mais cela ressemble toujours à ceci :

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

Ce qui nécessite qu'il soit si verbeux, c'est qu'à l'exception du protocole ou du port, n'importe laquelle des parties peut contenir des entités HTML, ce qui rend la délimitation du fragment assez délicate.Ainsi, dans les derniers cas (l'hôte, le chemin, le fichier, la chaîne de requête et le fragment), nous autorisons soit toute entité HTML, soit tout caractère qui n'est pas un ? ou #.L'expression régulière pour une entité HTML ressemble à ceci :

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

Lorsque cela est extrait (j'ai utilisé une syntaxe moustache pour le représenter), cela devient un peu plus lisible :

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

En JavaScript, bien sûr, vous ne pouvez pas utiliser de références arrière nommées, donc l'expression régulière devient

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

et à chaque match, le protocole est \1, l'hôte est \2, le port est \3, le chemin \4, le fichier \5, la chaîne de requête \6, et le 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);

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow