Obtener partes de una URL (Regex)

Dada la URL (línea única):
http://test.example.com/dir/subdir/file.html

¿Cómo puedo extraer las siguientes partes usando expresiones regulares?

  1. El subdominio (prueba)
  2. El dominio (example.com)
  3. La ruta sin el archivo (/ dir / subdir /)
  4. El archivo (archivo.html)
  5. La ruta con el archivo (/dir/subdir/file.html)
  6. La URL sin la ruta ( http://test.example.com )
  7. (agregue cualquier otro que crea que sería útil)

La expresión regular debería funcionar correctamente incluso si ingreso la siguiente URL:
http://example.example.com/example/example/example.html

Gracias.

Una sola expresión regular para analizar y dividir una URL completa, incluidos los parámetros de consulta y los anclajes, por ejemplo

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

Posiciones de RexEx:

url: RegExp [‘$ &’],

protocolo: RegExp. $ 2,

host: RegExp. $ 3,

ruta: RegExp. $ 4,

archivo: RegExp. $ 6,

consulta: RegExp. $ 7,

hash: RegExp. $ 8

luego podría analizar aún más el host (‘.’ delimitado) con bastante facilidad.

Lo que haría es usar algo como esto:

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

el análisis posterior ‘el rest’ es lo más específico posible. Hacerlo en una expresión regular es, bueno, un poco loco.

Me doy cuenta de que llego tarde a la fiesta, pero hay una manera simple de dejar que el navegador analice una url sin una expresión regular:

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

Llego unos años tarde a la fiesta, pero me sorprende que nadie haya mencionado que la especificación Uniform Resource Identifier tenga una sección sobre análisis de URI con una expresión regular . La expresión regular, escrita por Berners-Lee, et al., Es:

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

Los números en la segunda línea de arriba son solo para ayudar a la legibilidad; indican los puntos de referencia para cada subexpresión (es decir, cada paréntesis emparejado). Nos referimos al valor coincidente para la subexpresión como $. Por ejemplo, hacer coincidir la expresión anterior con

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

resultados en las siguientes coincidencias subexpression:

 $1 = http: $2 = http $3 = //www.ics.uci.edu $4 = www.ics.uci.edu $5 = /pub/ietf/uri/ $6 =  $7 =  $8 = #Related $9 = Related 

Por lo que vale, descubrí que tenía que escapar de las barras diagonales en JavaScript:

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

Encontré que la respuesta más votado (respuesta de hometoast) no funciona perfectamente para mí. Dos problemas:

  1. No puede manejar el número de puerto.
  2. La parte hash está rota.

La siguiente es una versión modificada:

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

La posición de las partes es la siguiente:

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

Editar publicado por el usuario anon:

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

Necesitaba una Expresión regular para que coincida con todas las URL e hice esta:

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

Coincide con todas las URL, cualquier protocolo, incluso las URL como

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

El resultado (en JavaScript) se ve así:

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

Una url como

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

Se ve como esto:

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

Estaba tratando de resolver esto en javascript, que debe ser manejado por:

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

desde (en Chrome, al menos) analiza a:

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

Sin embargo, esto no es un navegador cruzado ( https://developer.mozilla.org/en-US/docs/Web/API/URL ), así que preparé esto para sacar las mismas partes que antes:

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

El crédito por esta expresión regular va a https://gist.github.com/rpflorence quien publicó este jsperf http://jsperf.com/url-parsing (originalmente encontrado aquí: https://gist.github.com/jlong/2428561 # comment-310066 ) a quien se le ocurrió la expresión regular en la que se basaba originalmente.

Las partes están en este orden:

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

También hay una pequeña biblioteca que lo envuelve y proporciona parámetros de consulta:

https://github.com/sadams/lite-url (también disponible en bower)

Si tiene una mejora, cree una solicitud de extracción con más pruebas y la aceptaré y fusionaré con agradecimiento.

Esta no es una respuesta directa, pero la mayoría de las bibliotecas web tienen una función que cumple esta tarea. La función a menudo se llama algo similar a CrackUrl . Si tal función existe, úselo, casi se garantiza que será más confiable y más eficiente que cualquier código hecho a mano.

El subdominio y el dominio son difíciles porque el subdominio puede tener varias partes, al igual que el dominio de nivel superior, 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 no es muy amigable para las expresiones regulares)

Esta versión mejorada debería funcionar tan confiablemente como un analizador.

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

Pruebe lo siguiente:

 ^((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 compatible con HTTP / FTP, subdominios, carpetas, archivos, etc.

Lo encontré en una búsqueda rápida en Google:

http://geekswithblogs.net/casualjim/archive/2005/12/01/61722.aspx

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

De mi respuesta a una pregunta similar . Funciona mejor que algunos de los otros mencionados porque tenían algunos errores (como no admitir nombre de usuario / contraseña, no admitir nombres de archivo de un solo carácter, fragmentos de identificadores que se rompen).

Proponga una solución mucho más legible (en Python, pero se aplica a cualquier expresión regular):

 def url_path_to_dict(path): pattern = (r'^' r'((?P.+?)://)?' r'((?P.+?)(:(?P.*?))?@)?' r'(?P.*?)' r'(:(?P\d+?))?' r'(?P/.*?)?' r'(?P[?].*?)?' 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') 

Huellas dactilares:

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

Puede obtener todos los http / https, host, puerto, ruta de acceso y consulta utilizando el objeto URI en .NET. solo la tarea difícil es dividir el host en subdominio, nombre de dominio y TLD.

No hay un estándar para hacerlo y no se puede simplemente usar el análisis sintáctico de cadenas o RegEx para producir el resultado correcto. Al principio, estoy usando la función RegEx pero no todas las URL pueden analizar el subdominio correctamente. La forma de práctica es usar una lista de TLD. Después de definir un TLD para una URL, la parte izquierda es dominio y el rest es subdominio.

Sin embargo, la lista debe mantenerse, ya que es posible tener nuevos TLD. El momento actual que sé es publicsuffix.org mantener la última lista y puede usar las herramientas domainname-parser del código de google para analizar la lista de sufijos públicos y obtener el subdominio, dominio y TLD fácilmente mediante el uso del objeto DomainName: domainName.SubDomain, domainName .Domain y domainName.TLD.

Esta respuesta también es útil: obtener el subdominio de una URL

CaLLMeLaNN

Lamentablemente, esto no funciona con algunas URL. Tomemos, por ejemplo, este: http://www.example.org/&value=329

Tampoco lo hace & value = 329

¡O incluso sin parámetros en absoluto (una URL simple)!

Entiendo que la expresión regular está esperando una URL seriamente compleja / larga, pero también debería poder funcionar en las más simples, ¿no?

Aquí hay uno que está completo y no depende de ningún protocolo.

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

Huellas dactilares

 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 

Ninguno de los anteriores funcionó para mí. Esto es lo que terminé usando:

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

Me gusta la expresión regular que se publicó en “Javascript: The Good Parts”. No es demasiado corto y no es demasiado complejo. Esta página en github también tiene el código JavaScript que lo usa. Pero es una adaptación para cualquier idioma. https://gist.github.com/voodooGQ/4057330

Java ofrece una clase de URL que hará esto. Objetos de URL de consulta.

En una nota lateral, PHP ofrece parse_url () .

Yo recomendaría no usar Regex. Una llamada API como WinHttpCrackUrl () es menos propensa a errores.

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

Usando http://www.fileformat.info/tool/regex.htm homegeast’s regex funciona muy bien.

Pero aquí está el trato, quiero usar diferentes patrones de expresiones regulares en diferentes situaciones en mi progtwig.

Por ejemplo, tengo esta URL y tengo una enumeración que enumera todas las URL admitidas en mi progtwig. Cada objeto en la enumeración tiene un método getRegexPattern que devuelve el patrón de expresiones regulares que luego se usará para comparar con una URL. Si el patrón de expresiones regulares particular devuelve verdadero, entonces sé que este URL es compatible con mi progtwig. Entonces, cada enumeración tiene su propia expresión regular dependiendo de dónde debe verse dentro de la URL.

La sugerencia de Hometoast es genial, pero en mi caso, creo que no ayudaría (a menos que copie y pegue la misma expresión regular en todas las enumeraciones).

Es por eso que quería la respuesta para dar la expresión regular para cada situación por separado. Aunque +1 para hometoast. 😉

Sé que estás diciendo que no hablas del idioma, pero ¿puedes decirnos qué estás usando solo para que sepamos qué capacidades de expresiones regulares tienes?

Si tiene las capacidades para las coincidencias que no capturan, puede modificar la expresión de hometoast para que las subexpresiones que no está interesado en capturar estén configuradas de esta manera:

(?:SOMESTUFF)

Todavía tendría que copiar y pegar (y modificar ligeramente) la Regex en varios lugares, pero tiene sentido; no solo está comprobando si existe una subexpresión, sino si existe como parte de una URL . Usar el modificador que no captura para las subexpresiones puede darte lo que necesitas y nada más, lo que, si te leo correctamente, es lo que quieres.

Al igual que una nota pequeña y pequeña, la expresión de hometoast no necesita poner corchetes alrededor de la ‘s’ para ‘https’, ya que solo tiene un personaje allí. Los cuantificadores cuantifican el carácter (o clase de carácter o subexpresión) que los precede directamente. Asi que:

https?

emparejaría ‘http’ o ‘https’ bien.

regexp para obtener la ruta URL sin el archivo.

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

Puede ser útil para agregar una ruta relativa a esta 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")); 

Proporcionará el siguiente resultado:
1: https: //
2: http://www.thomas-bayer.com
3: /
4: axis2 / services / BLZService? Wsdl

Si cambia la URL a
String s = ” https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888 “; la salida será la siguiente:
1: https: //
2: http://www.thomas-bayer.com
3:?
4: wsdl = qwerwer y ttt = 888

disfrutar..
Yosi Lev

La expresión regular para hacer un análisis completo es bastante horrenda. He incluido las referencias a los nombres para su legibilidad y dividí cada parte en líneas separadas, pero todavía se ve así:

 ^(?:(?P\w+(?=:\/\/))(?::\/\/))? (?:(?P(?:(?:&(?: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[0-9]+))?)\/)? (?:(?P(?:(?:&(?: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(?:(?:&(?: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(?:(?:&(?: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.*))?$ 

Lo que requiere que sea tan detallado es que, a excepción del protocolo o el puerto, cualquiera de las partes puede contener entidades HTML, lo que hace que la delineación del fragmento sea bastante complicada. Entonces, en los últimos casos: el host, la ruta, el archivo, la cadena de consulta y el fragmento, ¿permitimos cualquier entidad html o cualquier carácter que no sea ? o # . La expresión regular para una entidad html se ve así:

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

Cuando se extrae eso (utilicé una syntax de bigote para representarlo), se vuelve un poco más legible:

 ^(?:(?P(?:ht|f)tps?|\w+(?=:\/\/))(?::\/\/))? (?:(?P(?:{{htmlentity}}|[^\/?#:])+(?::(?P[0-9]+))?)\/)? (?:(?P(?:{{htmlentity}}|[^?#])+)\/)? (?P(?:{{htmlentity}}|[^?#])+) (?:\?(?P(?:{{htmlentity}};|[^#])+))? (?:#(?P.*))?$ 

En JavaScript, por supuesto, no puede usar referencias a los nombres, por lo que la expresión regular se convierte en

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

y en cada coincidencia, el protocolo es \1 , el host es \2 , el puerto es \3 , la ruta \4 , el archivo \5 , la cadena de consulta \6 y el fragmento \7 .

Probé algunos de estos que no cubren mis necesidades, especialmente las más votadas que no captaron una URL sin una ruta ( http://example.com/ )

también la falta de nombres de grupo lo hizo inutilizable en ansible (o quizás mis habilidades de jinja2 no existen).

así que esta es mi versión ligeramente modificada, siendo la fuente la versión más votada aquí:

 ^((?Phttp[s]?|ftp):\/)?\/?(?P[^:\/\s]+)(?P((\/\w+)*\/)([\w\-\.]+[^#?\s]+))*(.*)?(#[\w\-]+)?$ 
 //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);