Учитывая URL (одна строка):
http://test.example.com/dir/subdir/file.html
Как я могу извлечь следующие части, используя регулярные выражения:
Регулярное выражение должно работать правильно, даже если я введу следующий URL:
http://example.example.com/example/example/example.html
Одно регулярное выражение для разбора и разбиения a полный URL, включая параметры запроса и якоря, например,
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:
url: RegExp ['$ &'],
Протокол:. RegExp $2,
host: RegExp. $3,
путь:. RegExp $4,
file: RegExp. $6,
запрос:. RegExp $7,
Хэш:. RegExp $8
вы могли бы более подробно проанализировать хост ('.' delimited).
Что может сделать I - это что-то вроде этого:
/*
^(.*:)//([A-Za-z0-9\-\.]+)(:[0-9]+)?(.*)$
*/
proto $1
host $2
port $3
the-rest $4
дальнейший синтаксический анализ "остальное" должен быть как можно более конкретным. Выполнение этого в одном регулярном выражении, ну, немного сумасшедшее.
Я понимаю, что опаздываю на вечеринку, но есть простой способ разрешить браузеру анализировать URL-адрес для вас без регулярного выражения:
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
*/
Я опаздываю на вечеринку на несколько лет, но я удивлен, что никто не упомянул, что спецификация Uniform Resource Identifier содержит раздел для разбора URI с помощью регулярное выражение. Регулярное выражение, написанное Бернерсом-Ли и др., Представляет собой:
^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))? 12 3 4 5 6 7 8 9Цифры во второй строке выше предназначены только для удобства чтения; они указывают контрольные точки для каждого подвыражения (то есть каждый парные скобки). Мы ссылаемся на значение, соответствующее подвыражению как $. Например, сопоставление указанного выражения с
http://www.ics.uci.edu/pub/ietf/uri/#Relatedприводит к следующим подвыражениям:
$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
Для чего это стоит, я обнаружил, что мне пришлось скрывать косые черты в JavaScript:
^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
Я нашел, что самый высокий голосовой ответ (hometoast answer) не работает отлично для меня. Две проблемы:
Ниже приведена модифицированная версия:
^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/\w+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$
Положение частей выглядит следующим образом:
int SCHEMA = 2, DOMAIN = 3, PORT = 5, PATH = 6, FILE = 8, QUERYSTRING = 9, HASH = 12
Редактировать сообщение пользователем anon:
function getFileName(path) {
return path.match(/^((http[s]?|ftp):\/)?\/?([^:\/\s]+)(:([^\/]*))?((\/[\w\/-]+)*\/)([\w\-\.]+[^#?\s]+)(\?([^#]*))?(#(.*))?$/i)[8];
}
Мне нужно регулярное выражение для соответствия всем URL-адресам и сделало это:
/(?:([^\:]*)\:\/\/)?(?:([^\:\@]*)(?:\:([^\@]*))?\@)?(?:([^\/\:]*)\.(?=[^\.\/\:]*\.[^\.\/\:]*))?([^\.\/\:]*)(?:\.([^\/\.\:]*))?(?:\:([0-9]*))?(\/[^\?#]*(?=.*?\/)\/)?([^\?#]*)?(?:\?([^#]*))?(?:#(.*))?/
Он соответствует всем URL-адресам, любому протоколу, даже URL-адресам, например
ftp://user:[email protected]:8080/dir1/dir2/file.php?param1=value1#hashtag
Результат (в JavaScript) выглядит следующим образом:
["ftp", "user", "pass", "www.cs", "server", "com", "8080", "/dir1/dir2/", "file.php", "param1=value1", "hashtag"]
URL-адрес, например
mailto://[email protected]
выглядит так:
["mailto", "admin", undefined, "www.cs", "server", "com", undefined, undefined, undefined, undefined, undefined]
Я пытался решить это в javascript, с которым следует обращаться:
var url = new URL('http://a:[email protected]:890/path/[email protected]/foo.js?foo=bar&bingobang=&[email protected]#foobar/bing/[email protected]?bang');
поскольку (в Chrome, по крайней мере) он анализирует:
{
"hash": "#foobar/bing/[email protected]?bang",
"search": "?foo=bar&bingobang=&[email protected]",
"pathname": "/path/[email protected]/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:[email protected]:890/path/[email protected]/foo.js?foo=bar&bingobang=&[email protected]#foobar/bing/[email protected]?bang"
}
Однако это не перекрестный браузер (https://developer.mozilla.org/en-US/docs/Web/API/URL), поэтому я собрал это вместе, чтобы вытащить те же части, что и выше:
^(?:(?:(([^:\/#\?]+:)?(?:(?:\/\/)(?:(?:(?:([^:@\/#\?]+)(?:\:([^:@\/#\?]*))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((?:\/?(?:[^\/\?#]+\/+)*)(?:[^\?#]*)))?(\?[^#]+)?)(#.*)?
Кредит для этого регулярного выражения отправляется в https://gist.github.com/rpflorence, который разместил этот jsperf http://jsperf.com/url-parsing (изначально найденный здесь: https://gist.github.com/jlong/2428561#comment-310066), который придумал регулярное выражение, изначально основанное на.
Детали находятся в следующем порядке:
var keys = [
"href", // http://user:[email protected]:81/directory/file.ext?query=1#anchor
"origin", // http://user:[email protected]: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
];
Существует также небольшая библиотека, которая обертывает ее и предоставляет параметры запроса:
https://github.com/sadams/lite-url (также доступно на bower)
Если у вас есть улучшения, пожалуйста, создайте запрос на растяжение с большим количеством тестов, и я соглашусь и объединиться с благодарностью.
Это не прямой ответ, но большинство веб-библиотек имеют функцию, которая выполняет эту задачу. Функция часто называется чем-то похожей на CrackUrl. Если такая функция существует, используйте ее, она почти гарантированно будет более надежной и эффективной, чем любой ручной код.
Попробуйте следующее:
^((ht|f)tp(s?)\:\/\/|~/|/)?([\w]+:\[email protected])?([a-zA-Z]{1}([\w\-]+\.)+([\w]{2,5}))(:[\d]{1,5})?((/?\w+/)+|/?)(\w+\.[\w]{3,4})?((\?\w+=\w+)?(&\w+=\w+)*)?
Он поддерживает HTTP/FTP, субдомены, папки, файлы и т.д.
Я нашел его из быстрого поиска google:
http://geekswithblogs.net/casualjim/archive/2005/12/01/61722.aspx
субдомен и домен сложны, поскольку субдомен может иметь несколько частей, а также домен верхнего уровня, 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 не очень дружит с регулярными выражениями)
Эта улучшенная версия должна работать надежно, как синтаксический анализатор.
// 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
//
// [email protected] matches the entire uri
// $1 matches scheme (ftp, http, mailto, mshelp, ymsgr, etc)
// $2 matches authority (host, user:[email protected], 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'
}
Предложите гораздо более читаемое решение (в Python, но применимо к любому регулярному выражению):
def url_path_to_dict(path):
pattern = (r'^'
r'((?P<schema>.+?)://)?'
r'((?P<user>.+?)(:(?P<password>.*?))[email protected])?'
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')
Отпечатки:
{
'host': 'example.example.com',
'user': None,
'path': '/example/example/example.html',
'query': None,
'password': None,
'port': None,
'schema': 'http'
}
/^((?P<scheme>https?|ftp):\/)?\/?((?P<username>.*?)(:(?P<password>.*?)|)@)?(?P<hostname>[^:\/\s]+)(?P<port>:([^\/]*))?(?P<path>(\/\w+)*\/)(?P<filename>[-\w.]+[^#?\s]*)?(?P<query>\?([^#]*))?(?P<fragment>#(.*))?$/
Из моего ответа на аналогичный вопрос. Работает лучше, чем некоторые из упомянутых других, потому что у них были некоторые ошибки (например, не поддерживающие имя пользователя/пароль, не поддерживающие односимвольные имена файлов, сломанные идентификаторы).
Вы можете получить все http/https, хост, порт, путь, а также запрос, используя объект Uri в .NET. просто сложная задача - разбить хост на субдомен, доменное имя и TLD.
Нет никакого стандарта для этого и не может просто использовать синтаксический анализ строк или RegEx для получения правильного результата. Во-первых, я использую функцию RegEx, но не все URL-адреса могут правильно разбирать субдомен. Практический путь - использовать список TLD. После определения TLD для URL-адреса левая часть является доменом, а остальные - поддоменью.
Однако список должен поддерживать его, поскольку возможны новые TLD. В настоящий момент я знаю, что publicsuffix.org поддерживает последний список, и вы можете использовать инструменты domainname-parser из кода google для анализа открытого списка суффикса и получения поддомена, домена и TLD с помощью объекта DomainName: domainName.SubDomain, domainName.Domain и domainName.TLD.
Это также полезно: Получите субдомен с URL-адреса
CaLLMeLaNN
К сожалению, это не работает с некоторыми URL-адресами. Возьмем, к примеру, этот: http://www.example.org/&value=329
Также значение & value = 329
Или даже без каких-либо параметров (простой URL-адрес)!
Я понимаю, что регулярное выражение ожидает некоторый серьезный сложный/длинный URL-адрес, но он также должен работать на простых, верно?
Вот один из них, который является полным и не полагается на какой-либо протокол.
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")
Печать
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
Ничто из этого не помогло мне. Вот что я в итоге использовал:
/^(?:((?:https?|s?ftp):)\/\/)([^:\/\s]+)(?::(\d*))?(?:\/([^\s?#]+)?([?][^?#]*)?(#.*)?)?/
Мне нравится регулярное выражение, которое было опубликовано в "Javascript: The Good Parts". Он не слишком короткий и не слишком сложный. Эта страница на github также имеет код JavaScript, который ее использует. Но это адаптировано для любого языка. https://gist.github.com/voodooGQ/4057330
Java предлагает класс URL, который сделает это. Объекты URL запроса.
С одной стороны PHP предлагает parse_url().
Я бы рекомендовал не использовать regex. Вызов API, такой как WinHttpCrackUrl(), менее подвержен ошибкам.
http://msdn.microsoft.com/en-us/library/aa384092%28VS.85%29.aspx
Использование http://www.fileformat.info/tool/regex.htm hometoast regex отлично работает.
Но вот сделка, я хочу использовать разные шаблоны регулярных выражений в разных ситуациях в моей программе.
Например, у меня есть этот URL, и у меня есть перечисление, в котором перечислены все поддерживаемые URL-адреса в моей программе. Каждый объект в перечислении имеет метод getRegexPattern, который возвращает шаблон регулярного выражения, который затем будет использоваться для сравнения с URL-адресом. Если конкретный шаблон регулярного выражения возвращает true, то я знаю, что этот URL-адрес поддерживается моей программой. Таким образом, каждое перечисление имеет собственное регулярное выражение в зависимости от того, где он должен выглядеть внутри URL.
Предложение Hometoast замечательно, но в моем случае, я думаю, что это не помогло бы (если только я не скопирую одно и то же регулярное выражение во всех перечислениях).
Вот почему я хотел получить ответ, чтобы дать регулярное выражение для каждой ситуации отдельно. Хотя +1 для hometoast.;)
Я знаю, что вы претендуете на язык-агностик на этом, но можете ли вы рассказать нам, что используете, чтобы мы знали, какие у вас есть возможности регулярного выражения?
Если у вас есть возможности для неадаптирующих совпадений, вы можете изменить выражение hometoast, чтобы подвыражения, которые вы не заинтересованы в захвате, настроены следующим образом:
(?:SOMESTUFF)
Вам все равно придется копировать и вставлять (и слегка модифицировать) Regex на несколько мест, но это имеет смысл - вы не просто проверяете, существует ли подвыражение, а скорее, если оно существует как часть URL. Использование модификатора non-capture для подвыражений может дать вам то, что вам нужно, и не более того, что, если я правильно вас читаю, - это то, что вы хотите.
Как маленькая, маленькая заметка, выражение hometoast не нужно помещать скобки вокруг 's' для 'https', так как у него только один символ. Квантеры определяют количественно один символ (или класс символов или подвыражение), непосредственно предшествующий им. Итак:
https?
будет соответствовать "http" или "https" просто отлично.
regexp, чтобы получить URL-путь без файла.
url = 'http://domain/dir1/dir2/somefile' url.scan(/^ (HTTP://[^/] +) ((?:/[^/] +) + (=/))/(????? [^/] +) $/я).to_s
Это может быть полезно для добавления относительного пути к этому 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"));
Будет представлен следующий результат:
1: https://
2: www.thomas-bayer.com
3:/
4: axis2/services/BLZService? Wsdl
Если вы измените URL-адрес на Строка s = " https://www.thomas-bayer.com?wsdl=qwerwer&ttt=888";
вывод будет следующим:
1: https://
2: www.thomas-bayer.com
3:?
4: wsdl = qwerwer & ttt = 888
наслаждаться..
Йоси Лев
Регулярное выражение для полного разбора довольно ужасает. Я включил названные обратные ссылки для удобочитаемости и разбил каждую часть на отдельные строки, но все равно выглядит следующим образом:
^(?:(?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>.*))?$
Вещью, требующей, чтобы она была настолько подробной, заключается в том, что, за исключением протокола или порта, любая из частей может содержать объекты HTML, что делает очерчивание фрагмента довольно сложным. Таким образом, в последних нескольких случаях - хост, путь, файл, запрос и фрагмент, мы разрешаем любой объект html или любой символ, который не является ? или #. Регулярное выражение для объекта html выглядит следующим образом:
$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]+);"
Когда это извлечено (я использовал синтаксис уса для его представления), он становится немного более разборчивым:
^(?:(?P<protocol>(?:ht|f)tps?|\w+(?=:\/\/))(?::\/\/))?
(?:(?P<host>(?:{{htmlentity}}|[^\/?#:])+(?::(?P<port>[0-9]+))?)\/)?
(?:(?P<path>(?:{{htmlentity}}|[^?#])+)\/)?
(?P<file>(?:{{htmlentity}}|[^?#])+)
(?:\?(?P<querystring>(?:{{htmlentity}};|[^#])+))?
(?:#(?P<fragment>.*))?$
В JavaScript, конечно, вы не можете использовать именованные обратные ссылки, поэтому регулярное выражение становится
^(?:(\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]+);)|[^#])+))?(?:#(.*))?$
и в каждом совпадении протокол \1, хост \2, порт \3, путь \4, файл \5, строка запроса \6 и фрагмент \7.
Я попробовал несколько из них, которые не покрывали моих потребностей, особенно самые высокие, проголосовавшие, которые не улавливали URL-адрес без пути (http://example.com/)
также отсутствие названий групп сделало его непригодным в недоступном (или, возможно, умениях jinja2 отсутствуют).
так что это моя версия, слегка измененная с тем, что источник является самой высокой проголосовавшей версией здесь:
^((?P<protocol>http[s]?|ftp):\/)?\/?(?P<host>[^:\/\s]+)(?P<path>((\/\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);