Ottenere parti di un URL (Regex)

https://stackoverflow.com/questions/27745

09-06-2019
|

Domanda

Dato l'URL (riga singola):
http://test.example.com/dir/subdir/file.html

Come posso estrarre le seguenti parti utilizzando le espressioni regolari:

Il sottodominio (test)
Il dominio (esempio.com)
Il percorso senza il file (/dir/subdir/)
Il file (file.html)
Il percorso con il file (/dir/subdir/file.html)
L'URL senza il percorso (http://test.esempio.com)
(aggiungi qualsiasi altro che ritieni possa essere utile)

La regex dovrebbe funzionare correttamente anche se inserisco il seguente URL:

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

Soluzione

Un singolo regex per analizzare e rompere un URL completo che include parametri di query e ancore ad es.

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

Posizioni RexEx:

URL:RegExp['$&'],

protocollo:RegExp.$2,

host:RegExp.$3,

percorso:RegExp.$4,

file:RegExp.$6,

query:RegExp.$7,

hash:RegExp.$8

potresti quindi analizzare ulteriormente l'host (delimitato da '.') abbastanza facilmente.

Che cosa IO farei è usare qualcosa del genere:

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

l'ulteriore analisi del "resto" sarà il più specifica possibile.Farlo in una regex è, beh, un po' folle.

Altri suggerimenti

Mi rendo conto di essere in ritardo per la festa, ma esiste un modo semplice per consentire al browser di analizzare un URL per te senza una 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
*/

Sono in ritardo di qualche anno per la festa, ma sono sorpreso che nessuno abbia menzionato che la specifica Uniform Resource Identifier ha un sezione sull'analisi degli URI con un'espressione regolare.L'espressione regolare, scritta da Berners-Lee, et al., è:

^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
 12            3  4          5       6  7        8 9
I numeri nella seconda riga sopra servono solo per facilitare la leggibilità;Indicano i punti di riferimento per ciascuna sottoespressione (cioè, ciascuna parentesi accoppiata).Ci riferiamo al valore abbinato per la sottoespressione come $.Ad esempio, facendo corrispondere l'espressione precedente a

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

restituisce le seguenti corrispondenze di sottoespressioni:
$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

Per quello che vale, ho scoperto che dovevo evitare le barre in JavaScript:

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

Ho scoperto che la risposta più votata (risposta di Hometoast) non funziona perfettamente per me.Due problemi:

Non può gestire il numero di porta.
La parte hash è rotta.

Quella che segue è una versione modificata:

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

La posizione delle parti è la seguente:

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

Modifica pubblicata da un utente diverso:

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

Avevo bisogno di un'espressione regolare per abbinare tutti gli URL e ho creato questa:

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

Corrisponde a tutti gli URL, a qualsiasi protocollo, anche agli URL like

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

Il risultato (in JavaScript) è simile al seguente:

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

Un URL come

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

Somiglia a questo:

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

Stavo cercando di risolvere questo problema in JavaScript, che dovrebbe essere gestito da:

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

poiché (in Chrome, almeno) viene analizzato in:

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

Tuttavia, questo non è cross browser (https://developer.mozilla.org/en-US/docs/Web/API/URL), quindi l'ho messo insieme per estrarre le stesse parti di cui sopra:

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

Il merito di questa espressione regolare va a https://gist.github.com/rpflorence chi ha pubblicato questo jsperf http://jsperf.com/url-parsing (originariamente trovato qui: https://gist.github.com/jlong/2428561#comment-310066) che ha inventato la regex su cui era originariamente basata.

Le parti sono in questo ordine:

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

C'è anche una piccola libreria che lo racchiude e fornisce i parametri di query:

https://github.com/sadams/lite-url (disponibile anche su pergolato)

Se riscontri un miglioramento, crea una richiesta pull con più test e accetterò e unirò i ringraziamenti.

Proponi una soluzione molto più leggibile (in Python, ma si applica a qualsiasi 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')

Stampe:

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

sottodominio e dominio sono difficili perché il sottodominio può avere più parti, così come il dominio di primo livello, http://sub1.sub2.dominio.co.uk/

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

(Markdown non è molto amichevole con le espressioni regolari)

Questa versione migliorata dovrebbe funzionare in modo affidabile come un 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'
   }

Prova quanto segue:

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

Supporta HTTP/FTP, sottodomini, cartelle, file ecc.

L'ho trovato facendo una rapida ricerca su 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>#(.*))?$/

Dalla mia risposta su a domanda simile.Funziona meglio di alcuni degli altri menzionati perché presentavano alcuni bug (come il mancato supporto di nome utente/password, il mancato supporto di nomi di file a carattere singolo, identificatori di frammenti danneggiati).

È possibile ottenere tutti i dati http/https, host, porta, percorso e query utilizzando l'oggetto Uri in .NET.solo il compito difficile è suddividere l'host in sottodominio, nome di dominio e TLD.

Non esiste uno standard per farlo e non è possibile utilizzare semplicemente l'analisi delle stringhe o le RegEx per produrre il risultato corretto.Inizialmente utilizzo la funzione RegEx ma non tutti gli URL possono essere analizzati correttamente dal sottodominio.Il modo pratico è utilizzare un elenco di TLD.Dopo aver definito un TLD per un URL, la parte sinistra è il dominio e la parte rimanente è il sottodominio.

Tuttavia l'elenco deve essere mantenuto poiché sono possibili nuovi TLD.Al momento so che publicsuffix.org mantiene l'elenco più recente e puoi utilizzare gli strumenti di analisi dei nomi di dominio da Google Code per analizzare l'elenco dei suffissi pubblici e ottenere facilmente il sottodominio, il dominio e il TLD utilizzando l'oggetto DomainName:nomedominio.Sottodominio, nomedominio.Dominio e nomedominio.TLD.

Anche questa risposta è utile:Ottieni il sottodominio da un URL

ChiamaMeLaNN

Eccone uno completo e non si basa su alcun protocollo.

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

Stampe

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

Nessuno dei precedenti ha funzionato per me.Ecco cosa ho finito per usare:

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

Mi piace la regex pubblicata in "Javascript:Le parti buone".Non è né troppo breve né troppo complesso.Questa pagina su github ha anche il codice JavaScript che la utilizza.Ma può essere adattato a qualsiasi lingua.https://gist.github.com/voodooGQ/4057330

Java offre una classe URL che farà questo. Interrogare gli oggetti URL.

Una nota a margine, PHP offre analizza_url().

Consiglierei di non usare regex.Una chiamata API come WinHttpCrackUrl() è meno soggetto a errori.

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

Ne ho provati alcuni che non coprivano le mie esigenze, in particolare il più votato che non catturava un URL senza un percorso (http://esempio.com/)

inoltre la mancanza di nomi di gruppo lo ha reso inutilizzabile in Ansible (o forse mancano le mie capacità di jinja2).

quindi questa è la mia versione leggermente modificata con la fonte che è la versione più votata qui:

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

Utilizzando http://www.fileformat.info/tool/regex.htm l'espressione regolare di hometoast funziona alla grande.

Ma ecco il punto, voglio utilizzare diversi modelli regex in diverse situazioni nel mio programma.

Ad esempio, ho questo URL e un'enumerazione che elenca tutti gli URL supportati nel mio programma.Ogni oggetto nell'enumerazione ha un metodo getRegexPattern che restituisce il modello regex che verrà quindi utilizzato per il confronto con un URL.Se il particolare modello regex restituisce true, allora so che questo URL è supportato dal mio programma.Quindi, ogni enumerazione ha la propria regex a seconda di dove dovrebbe cercare all'interno dell'URL.

Il suggerimento di Hometoast è ottimo, ma nel mio caso penso che non sarebbe d'aiuto (a meno che non copi e incolli la stessa espressione regolare in tutte le enumerazioni).

Questo è il motivo per cui volevo che la risposta fornisse la regex per ciascuna situazione separatamente.Anche se +1 per il pane tostato.;)

So che ti stai dichiarando indipendente dal linguaggio, ma puoi dirci cosa stai usando solo così sappiamo quali capacità regex hai?

Se disponi delle funzionalità per non acquisire corrispondenze, puoi modificare l'espressione di hometoast in modo che le sottoespressioni che non ti interessa acquisire siano impostate in questo modo:

(?:SOMESTUFF)

Dovresti comunque copiare e incollare (e modificare leggermente) il Regex in più punti, ma questo ha senso: non stai solo controllando per vedere se la sottoespressione esiste, ma piuttosto se esiste come parte di un URL.Usare il modificatore non-capturing per le sottoespressioni può darti ciò di cui hai bisogno e niente di più, il che, se ho capito bene, è quello che vuoi.

Proprio come una piccola, piccola nota, l'espressione di hometoast non ha bisogno di mettere tra parentesi la 's' per 'https', poiché contiene solo un carattere.I quantificatori quantificano l'unico carattere (o classe di caratteri o sottoespressione) che li precede direttamente.COSÌ:

https?

corrisponderebbe perfettamente a "http" o "https".

regexp per ottenere il percorso dell'URL senza il file.

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

Può essere utile per aggiungere un percorso relativo a questo 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"));

Fornirà il seguente output:
1:https://
2:www.thomas-bayer.com
3: /
4:asse2/services/BLZService?wsdl

Se cambi l'URL in
Stringa s = "https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888";l'output sarà il seguente:
1:https://
2:www.thomas-bayer.com
3: ?
4:wsdl=qwerwer&ttt=888

Godere..
Yosi Lev

La regex per eseguire l'analisi completa è piuttosto orrenda.Ho incluso riferimenti all'indietro con nome per motivi di leggibilità e ho suddiviso ciascuna parte in righe separate, ma appare ancora così:

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

Ciò che lo rende così dettagliato è che, ad eccezione del protocollo o della porta, qualsiasi parte può contenere entità HTML, il che rende la delineazione del frammento piuttosto complicata.Quindi negli ultimi casi (host, percorso, file, querystring e frammento) consentiamo qualsiasi entità html o qualsiasi carattere che non sia un ? O #.La regex per un'entità html è simile alla seguente:

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

Una volta estratto (ho usato la sintassi dei baffi per rappresentarlo), diventa un po' più leggibile:

^(?:(?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, ovviamente, non è possibile utilizzare backreference denominati, quindi la regex diventa

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

e in ogni partita il protocollo lo è \1, l'ospite è \2, il porto è \3, il sentiero \4, il file \5, la stringa di query \6, e il frammento \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);

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow