Obtener partes de una URL (Regex)
https://stackoverflow.com/questions/27745
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Dada la URL (una sola línea):
http://test.example.com/dir/subdir/file.html
¿Cómo puedo extraer las siguientes partes usando expresiones regulares?
- El subdominio (prueba)
- El dominio (ejemplo.com)
- La ruta sin el archivo (/dir/subdir/)
- El archivo (archivo.html)
- La ruta con el archivo (/dir/subdir/file.html)
- La URL sin la ruta (http://prueba.ejemplo.com)
- (añade cualquier otro que creas que podría ser útil)
La expresión regular debería funcionar correctamente incluso si ingreso la siguiente URL:
http://example.example.com/example/example/example.html
Solución
Una sola regex para analizar y romper una URL completa que incluye parámetros de consulta y 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 RexEx:
URL:ExpReg['$&'],
protocolo: RegExp.$2,
anfitrión:Exp.Reg.$3,
ruta:RegExp.$4,
archivo:ExpReg.$6,
consulta:Exp.Reg.$7,
hash:ExpReg.$8
Luego podría analizar aún más el host ('.' delimitado) con bastante facilidad.
Qué I 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 de 'el resto' debe ser lo más específico posible.Hacerlo en una sola expresión regular es, bueno, un poco loco.
Otros consejos
Me doy cuenta de que llego tarde a la fiesta, pero hay una forma sencilla de permitir 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
*/
Llegué unos años tarde a la fiesta, pero me sorprende que nadie haya mencionado que la especificación del Identificador Uniforme de Recursos tiene una sección sobre cómo analizar URI con una expresión regular.La expresión regular, escrita por Berners-Lee y otros, es:
^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))? 12 3 4 5 6 7 8 9Los números en la segunda línea de arriba son sólo para facilitar 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, haciendo coincidir la expresión anterior con
http://www.ics.uci.edu/pub/ietf/uri/#Relatedda como resultado las siguientes coincidencias de subexpresiones:
$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
Por si sirve de algo, descubrí que tenía que escapar de las barras diagonales en JavaScript:
^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
Descubrí que la respuesta más votada (la respuesta de hometoast) no funciona perfectamente para mí.Dos problemas:
- No puede manejar el número de puerto.
- La parte del hash está rota.
La siguiente es una versión modificada:
^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$
La posición de las piezas es la siguiente:
int SCHEMA = 2, DOMAIN = 3, PORT = 5, PATH = 6, FILE = 8, QUERYSTRING = 9, HASH = 12
Editar publicado por un usuario anónimo:
function getFileName(path) {
return path.match(/^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/[\w\/-]+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$/i)[8];
}
Necesitaba una expresión regular para que coincidiera con todas las URL e hice esta:
/(?:([^\:]*)\:\/\/)?(?:([^\:\@]*)(?:\:([^\@]*))?\@)?(?:([^\/\:]*)\.(?=[^\.\/\:]*\.[^\.\/\:]*))?([^\.\/\:]*)(?:\.([^\/\.\:]*))?(?:\:([0-9]*))?(\/[^\?#]*(?=.*?\/)\/)?([^\?#]*)?(?:\?([^#]*))?(?:#(.*))?/
Coincide con todas las URL, cualquier protocolo, incluso 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 intentando resolver esto en javascript, que debería 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');
ya que (al menos en Chrome) se analiza como:
{
"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 improvisé esto para sacar las mismas partes que arriba:
^(?:(?:(([^:\/#\?]+:)?(?:(?:\/\/)(?:(?:(?:([^:@\/#\?]+)(?:\:([^:@\/#\?]*))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?
El crédito por esta expresión regular es para https://gist.github.com/rpflorence ¿Quién 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 basó originalmente.
Las piezas 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 glorieta)
Si tiene una mejora, cree una solicitud de extracción con más pruebas y la aceptaré y la fusionaré con agradecimiento.
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<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')
Huellas dactilares:
{
'host': 'example.example.com',
'user': None,
'path': '/example/example/example.html',
'query': None,
'password': None,
'port': None,
'schema': 'http'
}
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.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 no es muy amigable con 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+)*)?
Admite HTTP/FTP, subdominios, carpetas, archivos, etc.
Lo encontré haciendo una búsqueda rápida en 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>#(.*))?$/
De mi respuesta en un 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, identificadores de fragmentos rotos).
Puede obtener todos los http/https, host, puerto, ruta y consultas utilizando el objeto Uri en .NET.Sólo la tarea difícil es dividir el host en subdominio, nombre de dominio y TLD.
No existe un estándar para hacerlo y no se puede simplemente usar el análisis de cadenas o RegEx para producir el resultado correcto.Al principio, estoy usando la función RegEx pero no todas las URL se pueden analizar correctamente en el subdominio.La forma práctica es utilizar una lista de TLD.Después de definir un TLD para una URL, la parte izquierda es el dominio y el resto es el subdominio.
Sin embargo, es necesario mantener la lista ya que es posible crear nuevos TLD.El momento actual que sé es que publicsuffix.org mantiene la lista más reciente y puede usar las herramientas de análisis de nombres de dominio del código de Google para analizar la lista de sufijos públicos y obtener el subdominio, el dominio y el TLD fácilmente usando el objeto DomainName:NombreDominio.SubDominio, NombreDominio.Dominio y NombreDominio.TLD.
Esta respuesta también es útil:Obtener el subdominio de una URL
LlamameLaNN
Aquí hay uno que es 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
Nada de lo anterior 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:Las partes buenas".No es demasiado corto ni demasiado complejo.Esta página en github también tiene el código JavaScript que la utiliza.Pero se puede adaptar a cualquier idioma.https://gist.github.com/voodooGQ/4057330
Java ofrece una clase de URL que hará esto. Consultar objetos de URL.
Como nota al margen, PHP ofrece parse_url().
Recomendaría no usar expresiones regulares.Una llamada API como WinHttpCrackUrl() es menos propenso a errores.
http://msdn.microsoft.com/en-us/library/aa384092%28VS.85%29.aspx
Probé algunos de estos que no cubrían mis necesidades, especialmente el más votado que no captó una URL sin una ruta (http://ejemplo.com/)
Además, la falta de nombres de grupos lo hizo inutilizable en ansible (o tal vez me faltan habilidades de jinja2).
así que esta es mi versión ligeramente modificada siendo la fuente la versión más votada aquí:
^((?P<protocol>http[s]?|ftp):\/)?\/?(?P<host>[^:\/\s]+)(?P<path>((\/\w+)*\/)([\w\-\.]+[^#?\s]+))*(.*)?(#[\w\-]+)?$
Usando http://www.fileformat.info/tool/regex.htm La expresión regular de Hometoast funciona muy bien.
Pero aquí está el trato: quiero usar diferentes patrones de expresiones regulares en diferentes situaciones en mi programa.
Por ejemplo, tengo esta URL y tengo una enumeración que enumera todas las URL admitidas en mi programa.Cada objeto en la enumeración tiene un método getRegexPattern que devuelve el patrón de expresión regular que luego se usará para comparar con una URL.Si el patrón de expresión regular particular devuelve verdadero, entonces sé que mi programa admite esta URL.Entonces, cada enumeración tiene su propia expresión regular dependiendo de dónde debe buscar dentro de la URL.
La sugerencia de Hometoast es excelente, pero en mi caso, creo que no ayudaría (a menos que copie y pegue la misma expresión regular en todas las enumeraciones).
Por eso quería que la respuesta diera la expresión regular para cada situación por separado.Aunque +1 para tostadas caseras.;)
Sé que afirmas que esto es independiente del idioma, pero ¿puedes decirnos qué estás usando para que sepamos qué capacidades de expresiones regulares tienes?
Si tiene la capacidad de no capturar coincidencias, puede modificar la expresión de hometoast para que las subexpresiones que no le interesan capturar se configuren así:
(?:SOMESTUFF)
Aún tendrías que copiar y pegar (y modificar ligeramente) la expresión regular en varios lugares, pero esto tiene sentido: no solo estás verificando si la subexpresión existe, sino si existe. como parte de una URL.Usar el modificador de no captura para subexpresiones puede brindarte lo que necesitas y nada más, que, si te estoy leyendo correctamente, es lo que deseas.
Solo como una pequeña nota, la expresión de hometoast no necesita poner corchetes alrededor de la 's' para 'https', ya que solo tiene un carácter allí.Los cuantificadores cuantifican el carácter (o clase de carácter o subexpresión) que los precede directamente.Entonces:
https?
coincidiría perfectamente con 'http' o 'https'.
regexp para obtener la ruta URL sin el archivo.
URL = 'http://dominio/dir1/dir2/algún archivo'url.scan (/^(http: // [^/]+) ((?:/[^/]+)+(? =/))?/? (?: [^/]+)? $ /i).to_s
Puede resultar útil 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:www.thomas-bayer.com
3: /
4:eje2/servicios/BLZService?wsdl
Si cambia la URL a
Cadena s = "https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888";la salida será la siguiente:
1:https://
2:www.thomas-bayer.com
3: ?
4:wsdl=qwerwer&ttt=888
disfrutar..
Yosi Lev
La expresión regular para realizar un análisis completo es bastante horrenda.Incluí referencias anteriores nombradas para mayor legibilidad y dividí cada parte en líneas separadas, pero todavía se ve así:
^(?:(?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>.*))?$
Lo que requiere que sea tan detallado es que, excepto el 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 un ? 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 (usé una sintaxis de bigote para representarlo), se vuelve un poco más legible:
^(?:(?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, por supuesto, no puedes usar referencias inversas con nombre, 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 partido, el protocolo es \1, el anfitrión es \2, el puerto es \3, el camino \4, el archivo \5, la cadena de consulta \6, y el fragmento \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);
