Check if a JavaScript string is a URL

Question

Is there a way in JavaScript to check if a string is a URL   RegExes are excluded because the URL is most likely written like stackoverflow  that is to say that it might not have a  com  www or http

User · Answer

function isURL str      var pattern   new RegExp    https                protocol        a-z  d   a-z  d-   a-z  d           a-z  2         domain name        d 1 3      3   d 1 3         OR ip  v4  address          d        -a-z  d               port and path           amp a-z  d      -          query string         -a-z  d         i       fragment locator   return pattern test str

User · Answer

I change the function to Match   make a change here with the slashes and its work   http    and https  both  function isValidUrl userInput        var res   userInput match   http s           www     -a-zA-Z0-9            2 256    a-z  2 6  b  -a-zA-Z0-9           amp        g       if res    null         return false      else        return true

User · Answer

Mathias Bynens has compiled a list of well-known URL regexes with test URLs   There is little reason to write a new regular expression  just pick an existing one that suits you best   But the comparison table for those regexes also shows that it is next to impossible to do URL validation with a single regular expression   All of the regexes in Bynens  list produce false positives and false negatives   I suggest that you use an existing URL parser  for example new URL  http   www example com    in JavaScript  and then apply the checks you want to perform against the parsed and normalized form of the URL resp  its components   Using the JavaScript URL interface has the additional benefit that it will only accept such URLs that are really accepted by the browser   You should also keep in mind that technically incorrect URLs may still work  For example http   w w w example com   http   www  example com   http   123 example com  all have an invalid hostname part but every browser I know will try to open them without complaints  and when you specify IP addresses for those invalid names in  etc hosts  such URLs will even work but only on your computer   The question is  therefore  not so much whether a URL is valid  but rather which URLs work and should be allowed in a particular context   If you want to do URL validation there are a lot of details and edge cases that are easy to overlook    URLs may contain credentials as in http   user password www example com   Port numbers must be in the range of 0-65535  but you may still want to exclude the wildcard port 0  Port numbers may have leading zeros as in http   www example com 000080   IPv4 addresses are by no means restricted to 4 decimal integers in the range of 0-255   You can use one to four integers  and they can be decimal  octal or hexadecimal  The URLs https   010 010 000010 010   https   0x8 0x8 0x0008 0x8   https   8 8 2056   https   8 526344   https   134744072  are all valid and just creative ways of writing https   8 8 8 8   Allowing loopback addresses  http   127 0 0 1    private IP addresses  http   192 168 1 1   link-local addresses  http   169 254 100 200  and so on may have an impact on security or privacy  If  for instance  you allow them as the address of user avatars in a forum  you cause the users  browsers to send unsolicited network requests in their local network and in the internet of things such requests may cause funny and not so funny things to happen in your home  For the same reasons  you may want to discard links to not fully qualified hostnames  in other words hostnames without a dot  But hostnames may always have a trailing dot  like in http   www stackoverflow com     The hostname portion of a link may contain angle brackets for IPv6 addresses as in http      1   IPv6 addresses also have ranges for private networks or link-local addresses etc  If you block certain IPv4 addresses  keep in mind that for example https   127 0 0 1 and https      ffff 127 0 0 1  point to the same resource  if the loopback device of your machine is IPv6 ready   The hostname portion of URLs may now contain Unicode  so that the character range  -0-9a-zA-z  is definitely no longer sufficient  Many registries for top-level domains define specific restrictions  for example on the allowed set of Unicode characters  Or they subdivide their namespace  like co uk and many others   Top-level domains must not contain decimal digits  and the hyphen is not allowed unless for the IDN A-label prefix  xn--   Unicode top-level domains  and their punycode encoding with  xn--   must still contain only letters but who wants to check that in a regex    Which of these limitations and rules apply is a question of project requirements and taste   I have recently written a URL validator for a web app that is suitable for user-supplied URLs in forums  social networks  or the like   Feel free to use it as a base for your own one    JavaScript Typescript version for the  Angular  frontend Perl version for the backend   I have also written a blog post The Gory Details of URL Validation with more in-depth information

User · Answer

This seems to be one of the hardest problems in CS     Here s another incomplete solution that works well enough for me and better than the others I ve seen here  I m using a input type url  for this in order to support IE11  otherwise it would be much simpler using window URL to perform the validation instead    x000D   x000D  const ipv4Regex       d 1 3     3  d 1 3     x000D  function isValidIpv4 ip    x000D    if   ipv4Regex test ip   return false  x000D    return  ip split      find n   gt  n  gt  255   x000D    x000D   x000D  const domainRegex        a-z0-9-  1 63     1 125  a-z  2 63   i  x000D  function isValidDomain domain    x000D    return isValidIpv4 domain     domainRegex test domain   x000D    x000D   x000D  let input  x000D  function validateUrl url    x000D    if      https        test url   url    http     url       assuming Babel is used x000D       to support IE11 we ll resort to input type url  instead of window URL  x000D       try   return isValidDomain new URL url  host   amp  amp  url    catch e    return false    x000D    if   input    input   document createElement  input    input type    url     x000D    input value   url  x000D    if    input validity valid  return false  x000D    const domain   url split   https         1  split      0  split      pop    x000D    return isValidDomain domain   amp  amp  url  x000D    x000D   x000D  console log validateUrl  google       false x000D    validateUrl  user pw mydomain com    x000D    validateUrl  https   google com    x000D    validateUrl  100 100 100 100 abc    x000D    validateUrl  100 100 100 256 abc        false x000D   x000D   x000D    In order to accept incomplete inputs such as  www mydomain com  it will also make it valid assuming the protocol is  http  in those cases and returning the valid URL if the address is valid  It returns false when invalid   It also supports IPv4 domains  but not IPv6

User · Answer

Here s just a very simple check to make sure there s a valid protocol  and the domain extension must be two or more characters   is valid url      url     gt         let  url object   null       try            url object   new URL   url          catch    error             return false             const  protocol    url object protocol      const  protocol position    url lastIndexOf   protocol        const  domain extension position    url lastIndexOf              return            protocol position     0  amp  amp             http     https     indexOf   protocol       - 1  amp  amp           domain extension position  gt  2  amp  amp   url length -  domain extension position  gt  2

User · Answer

If you need to also support https   localhost 3000 then use this modified version of  Devshed s regex       function isURL url            if  url  return false          var pattern   new RegExp    https                protocol                  a-z  d   a-z  d-   a-z  d          a-z  2         domain name                  d 1 3      3   d 1 3           OR ip  v4  address              localhost       OR localhost                    d        -a-z  d               port and path                     amp a-z  d      -          query string                   -a-z  d          i       fragment locator         return pattern test url

User · Answer

Rely on a library  https   www npmjs com package valid-url  import   isWebUri   from  valid-url          if   isWebUri url         return  Not a valid url

User · Answer

Rather than using a regular expression  I would recommend making use of an anchor element    when you set the href property of an anchor  various other properties are set    var parser   document createElement  a    parser href    http   example com 3000 pathname  search test hash    parser protocol       gt   http   parser hostname       gt   example com  parser port           gt   3000  parser pathname       gt    pathname   parser search         gt    search test  parser hash           gt    hash  parser host           gt   example com 3000    source  However  if the value href is bound to is not a valid url  then the value of those auxiliary properties will be the empty string   Edit  as pointed out in the comments  if an invalid url is used  the properties of the current URL may be substituted   So  as long as you re not passing in the URL of the current page  you can do something like   function isValidURL str       var a    document createElement  a       a href   str     return  a host  amp  amp  a host    window location host

User · Answer

I don t have reps to comment on ValidURL example  hence post this as an answer    While use of protocol relative URLs is not encouraged  The Protocol-relative URL   they do get employed sometimes  To validate such an URL with a regular expression the protocol part could be optional  e g    function isValidURL str        var pattern   new RegExp     https                  protocol               S       S             authentication              a-z  d   a-z  d-   a-z  d          a-z  2         domain name              d 1 3      3   d 1 3         OR ip  v4  address                d        -a-z  d               port and path                 amp a-z  d      -          query string               -a-z  d         i       fragment locater     if   pattern test str             return false        else           return true            As others noted  regular expression does not seem to be the best suited approach for validating URLs  though

User · Answer

There s a lot of answers already  but here s another contribution  Taken directly from the URL polyfill validity check  use an input element with type  url  to take advantage of the browser s built-in validity check   var inputElement   doc createElement  input    inputElement type    url   inputElement value   url   if   inputElement checkValidity          throw new TypeError  Invalid URL        Source

User · Answer

If you want to check whether a string is valid HTTP URL  you can use URL constructor  it will throw on malformed string   function isValidHttpUrl string      let url       try       url   new URL string       catch           return false           return url protocol      quot http  quot     url protocol      quot https  quot      Note that per RFC 3886  URL must begin with a scheme  not limited to http https   e  g    www example com is not valid URL  missing scheme  javascript void 0  is valid URL  although not an HTTP one http      is valid URL with the host being     whether it resolves depends on your DNS  https   example  com is valid URL  same as above

User · Answer

You can use the URL native API     const isUrl   string   gt          try   return Boolean new URL string            catch e   return false

User · Answer

In my case my only requirement is that the user input won t be interpreted as a relative link when placed in the href of an a tag and the answers here were either a bit OTT for that or allowed URLs not meeting my requirements  so this is what I m going with    https          The same thing could be achieved pretty easily without regex

User · Answer

2020 Update  To expand on both excellent answerd from  iamnewton and  Fernando Chavez Herrera I ve started to see   being used in the path of URLs   So the updated regex is   RegExp   https              a-z  d   a-z  d-   a-z  d          a-z  2       d 1 3      3   d 1 3         d        -a-z  d                 amp a-z  d      -         -a-z  d          i      If you want to allow it in the query string and hash  use   RegExp   https              a-z  d   a-z  d-   a-z  d          a-z  2       d 1 3      3   d 1 3         d        -a-z  d                 amp a-z  d      -          -a-z  d           i      That being said  I m not sure if there s a whitepaper rule disallowing   in the query string or hash

User · Answer

this working with me  function isURL str      var regex     http https        w   0 1  w     S     0-9             w        amp    -           var pattern   new RegExp regex    return pattern test str

User · Answer

Use validator js  ES6  import isURL from  validator lib isURL   isURL string    No ES6  var validator   require  validator     validator isURL string    You can also fine tune this function s behavior by passing optional options object as the second argument of isURL  Here is the default options object   let options         protocols             http            https            ftp             require tld  true      require protocol  false      require host  true      require valid protocol  true      allow underscores  false      host whitelist  false      host blacklist  false      allow trailing dot  false      allow protocol relative urls  false      disallow auth  false    isURL string  options    host whitelist and host blacklist can be arrays of hosts  They also support regular expressions   let options         host blacklist    foo com    bar com       isURL  http   foobar com   options       gt  true isURL  http   foo bar com    options       gt  true isURL  http   qux com   options       gt  true  isURL  http   bar com    options       gt  false isURL  http   foo com    options       gt  false   options         host blacklist    bar com    foo com      foo  com        isURL  http   foobar com   options       gt  true isURL  http   foo bar com    options       gt  true isURL  http   qux com   options       gt  true  isURL  http   bar com    options       gt  false isURL  http   foo com    options       gt  false isURL  http   images foo com    options       gt  false isURL  http   cdn foo com    options       gt  false isURL  http   a b c foo com    options       gt  false

User · Answer

This is defiantly not the most effective approach  but it is readable and easy to form to whatever you need  And it s easier to add regex complexity from here  So here is a very pragmatic approach  const validFirstBits     ftp       http       https       www     const invalidPatterns                        export function isUrl word       less than www 1 dk if   word    word length  lt  8  return false      Let s check and see  if our candidate starts with some of our valid first bits const firstBitIsValid   validFirstBits some bit   gt  word indexOf bit      0   if   firstBitIsValid  return false   const hasInvalidPatterns   invalidPatterns some      pattern   gt  word indexOf pattern      -1      if  hasInvalidPatterns  return false   const dotSplit   word split       if  dotSplit length  gt  1        const lastBit   dotSplit pop       string or undefined     if   lastBit  return false      const length   lastBit length      const lastBitIsValid           length  gt  1     length     1  amp  amp   isNaN parseInt lastBit         return   lastBitIsValid         return false      TEST   import   isUrl   from    foo    describe  Foo        gt        test  should validate correct urls correctly   function             const validUrls                  http   example com                http   example com blah                http   127 0 0 1                http   127 0 0 1 wow                https   example com                https   example com blah                https   127 0 0 1 1234                ftp   example com                ftp   example com blah                ftp   127 0 0 1                www example com                www example com blah                       validUrls forEach url   gt                expect isUrl url   amp  amp  url  toEqual url                            test  should validate invalid urls correctly   function             const inValidUrls                  http    foo com                http  foo com                http    foo com                http   foo  com                http    com                http   foo                http   foo c                       inValidUrls forEach url   gt                expect  isUrl url   amp  amp  url  toEqual url

User · Answer

Here is yet another method    x000D   x000D  var elm  x000D  function isValidURL u   x000D    if  elm   x000D      elm   document createElement  input    x000D      elm setAttribute  type    url    x000D      x000D    elm value   u  x000D    return elm validity valid  x000D    x000D   x000D  console log isValidURL  http   www google com      x000D  console log isValidURL    google com     x000D  console log isValidURL  google com     x000D  console log isValidURL  localhost 8000     x000D   x000D   x000D

User · Answer

One function that I have been using to validate a URL  string  is   var matcher         w            s       S 2  localhost     d    S      function isUrl string     return matcher test string       This function will return a boolean whether the string is a URL   Examples   isUrl  https   google com           true isUrl  http   google com            true isUrl  http   google de             true isUrl    google de                  true isUrl  google de                    false isUrl  http   google com            true isUrl  http   localhost             true isUrl  https   sdfasd               false

User · Answer

There are a couple of tests using the URL constructor which do not delineate whether the input is a string or URL object      Testing whether something is a URL function isURL url        return toString call url        object URL          Testing whether the input is both a string and valid url  function isUrl url        try           return toString call url        object String    amp  amp     new URL url          catch               return false

User · Answer

This is quite difficult to do with pure regex because URLs have many  inconveniences     For example domain names have complicated restrictions on hyphens   a  It is allowed to have many consecutive hyphens in the middle   b  but the first character and last character of the domain name cannot be a hyphen  c  The 3rd and 4th character cannot be both hyphen  Similarly port number can only be in the range 1-65535  This is easy to check if you extract the port part and convert to int but quite difficult to check with a regular expression  There is also no easy way to check valid domain extensions  Some countries have second-level domains such as  co uk    or the extension can be a long word such as   international   And new TLDs are added regularly  This type of things can only be checked against a hard-coded list   see https   en wikipedia org wiki Top-level domain  Then there are magnet urls  ftp addresses etc  These all have different requirements    Nevertheless  here is a function that handles pretty much everything except    Case 1  c Accepts any 1-5 digit port number Accepts any extension 2-13 chars Does not accept ftp  magnet  etc       x000D   x000D  function isValidURL input    x000D      pattern      https                 protocol x000D               a-zA-Z  d   a-zA-Z  d-  0 61  a-zA-Z  d               sub-domain   domain name x000D            a-zA-Z  2 13         extension x000D                d 1 3      3   d 1 3         OR ip  v4  address x000D            localhost        OR localhost x000D                 d 1 5          port x000D                a-zA-Z   amp   d     -             path x000D                a-zA-Z   amp   d      -     amp            query string x000D                -a-zA-Z amp   d            fragment locator x000D      regex   new RegExp pattern   x000D      return regex test input   x000D    x000D   x000D  let tests       x000D  tests push      false    x000D  tests push   http   en wikipedia org wiki Procter  amp  Gamble   true    x000D  tests push   https   sdfasd   false    x000D  tests push   http   www google com url sa i amp rct j amp q  amp esrc s amp source images amp cd  amp docid nIv5rk2GyP3hXM amp tbnid isiOkMe3nCtexM  amp ved 0CAUQjRw amp url http 3A 2F 2Fanimalcrossing wikia com 2Fwiki 2FLion amp ei ygZXU 2fGKbMsQTf4YLgAQ amp bvm bv 65177938 d aWc amp psig AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g amp ust 1398298682009707   true    x000D  tests push   https   stackoverflow com    true    x000D  tests push   https   w   false    x000D  tests push   aaa   false    x000D  tests push   aaaa   false    x000D  tests push   oh my   true    x000D  tests push   dfdsfdsfdfdsfsdfs   false    x000D  tests push   google co uk   true    x000D  tests push   test-domain MUSEUM   true    x000D  tests push   -hyphen-start gov tr   false    x000D  tests push   hyphen-end- com   false    x000D  tests push   https   sdfasdp international   true    x000D  tests push   https   sdfasdp pppppppp   false    x000D  tests push   https   sdfasdp ppppppppppppppppppp   false    x000D  tests push   https   sdfasd   false    x000D  tests push   https   sub1 1234 sub3 sub4 sub5 co uk     true    x000D  tests push   http   www google-com 123   false    x000D  tests push   http   my--testdomain com   false    x000D  tests push   http   my2nd--testdomain com   true    x000D  tests push   http   thingiverse com download 1894343   true    x000D  tests push   https   medium com  techytimo   true    x000D  tests push   http   localhost   true    x000D  tests push   localhost   true    x000D  tests push   localhost 8080   true    x000D  tests push   localhost 65536   true    x000D  tests push   localhost 80000   false    x000D  tests push   magnet  xt urn btih 123   true    x000D   x000D  for  let i   0  i  lt  tests length  i      x000D      console log  Test      i    isValidURL tests i  0      tests i  1      passed      failed       on       tests i  0            tests i  1          x000D    x000D   x000D   x000D

User · Answer

To Validate Url using javascript is shown below  function ValidURL str      var regex     http https        w   0 1  w     S     0-9             w        amp    -           if  regex  test str         alert  Please enter valid URL         return false      else       return true

User · Answer

This function disallows localhost and only allows URLs for web pages  ie  only allows http or https protocol   It also only allows safe characters as defined here  https   www urlencoder io learn  function isValidWebUrl url       let regEx     https         www     -a-zA-Z0-9            1 256    a-zA-Z0-9    1 6  b  -a-zA-Z0-9             amp         gm     return regEx test url

User · Answer

A related question with an answer   Javascript regex URL matching  Or this Regexp from Devshed   function validURL str      var pattern   new RegExp    https                protocol          a-z  d   a-z  d-   a-z  d          a-z  2         domain name          d 1 3      3   d 1 3         OR ip  v4  address            d        -a-z  d               port and path             amp a-z  d      -          query string           -a-z  d         i       fragment locator   return   pattern test str

User · Answer

I think using the native URL API is better than a complex regex patterns as  pavlo suggested  It has some drawbacks though which we can fix by some extra code  This approach fails for the following valid url     cdn google com script js   We can add the missing protocol beforehand to avoid that  It also fails to detect following invalid url   http   w http        So why check the whole url  we can just check the domain  I borrowed the regex to verify domain from here    function isValidUrl string        if  string  amp  amp  string length  gt  1  amp  amp  string slice 0  2                     string    http     string    dummy protocol so that URL works           try           var url   new URL string           return url hostname  amp  amp  url hostname match     a-z0-9     a-z0-9-  1 61    a-z0-9  1       a-z0-9    a-z0-9-  1 61    a-z0-9  1         a-zA-Z  2 4         true   false        catch               return false            The hostname attribute is empty string for javascript void 0   so it works for that too  and you can also add IP address verifier too  I d like to stick to native API s most  and hope it starts to support everything in near future

User · Answer

I am using below function to validate URL with or without http https    x000D   x000D  function isValidURL string    x000D    var res   string match   http s           www     -a-zA-Z0-9            2 256    a-z  2 6  b  -a-zA-Z0-9           amp        g   x000D    return  res     null  x000D     x000D   x000D  var testCase1    http   en wikipedia org wiki Procter  amp  Gamble   x000D  console log isValidURL testCase1       return true x000D   x000D  var testCase2    http   www google com url sa i amp rct j amp q  amp esrc s amp source images amp cd  amp docid nIv5rk2GyP3hXM amp tbnid isiOkMe3nCtexM  amp ved 0CAUQjRw amp url http 3A 2F 2Fanimalcrossing wikia com 2Fwiki 2FLion amp ei ygZXU 2fGKbMsQTf4YLgAQ amp bvm bv 65177938 d aWc amp psig AFQjCNEpBfKnal9kU7Zu4n7RnEt2nerN4g amp ust 1398298682009707   x000D  console log isValidURL testCase2       return true x000D   x000D  var testCase3    https   sdfasd   x000D  console log isValidURL testCase3       return false x000D   x000D  var testCase4    dfdsfdsfdfdsfsdfs   x000D  console log isValidURL testCase4       return false x000D   x000D  var testCase5    magnet  xt urn btih 123   x000D  console log isValidURL testCase5       return false x000D   x000D  var testCase6    https   stackoverflow com    x000D  console log isValidURL testCase6       return true x000D   x000D  var testCase7    https   w   x000D  console log isValidURL testCase7       return false x000D   x000D  var testCase8    https   sdfasdp ppppppppppp   x000D  console log isValidURL testCase8       return false x000D   x000D   x000D

User · Answer

Improvement on the accepted answer      Check for ftp ftps as protocol Has double escaping for backslashes      Ensures that domains have a dot and an extension   com  io  xyz  Allows full colon     in the path e g  http   thingiverse com download 1894343 Allows ampersand   amp   in path e g http   en wikipedia org wiki Procter  amp  Gamble Allows   symbol in path e g  https   medium com  techytimo  isURL str      var pattern   new RegExp     ft htt ps                protocol        a-z  d   a-z  d-   a-z  d          a-z  2         domain name and extension        d 1 3      3   d 1 3         OR ip  v4  address          d         port         -a-z  d       amp            path           amp a-z  d        amp   -          query string         -a-z  d         i       fragment locator   return pattern test str

User · Answer

As has been noted the perfect regex is elusive but still seems to be a reasonable approach  alternatives are server side tests or the new experimental URL API   However the high ranking answers are often returning false for common URLs but even worse will freeze your app page for minutes on even as simple a string as isURL  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa    It s been pointed out in some of the comments  but most probably haven t entered a bad value to see it  Hanging like that makes that code unusable in any serious application  I think it s due to the repeated case insensitive sets in code like     a-z  d   a-z  d-   a-z  d           a-z  2          Take out the  i  and it doesn t hang but will of course not work as desired  But even with the ignore case flag those tests reject high unicode values that are allowed   The best already mentioned is   function isURL str      return       w            s       S 2  localhost     d    S    test str        That comes from Github segmentio is-url  The good thing about a code repository is you can see the testing and any issues and also the test strings run through it  There s a branch that would allow strings missing protocol like google com  though you re probably making too many assumptions then  The repository has been updated and I m not planning on trying to keep up a mirror here  It s been broken up into separate tests to avoid RegEx redos which can be exploited for DOS attacks  I don t think you have to worry about that with client side js  but you do have to worry about your page hanging for so long that your visitor leaves your site    There is one other repository I ve seen that may even be better for isURL at dperini regex-weburl js  but it is highly complex  It has a bigger test list of valid and invalid URLs  The simple one above still passes all the positives and only fails to block a few odd negatives like http   a b--c de  as well as the special ips   Whichever you choose  run it through this function which I ve adapted from the tests on dperini regex-weburl js  while using your browser s Developer Tools inpector   function testIsURL       should match console assert isURL  http   foo com blah blah     console assert isURL  http   foo com blah blah      console assert isURL  http   foo com blah blah  wikipedia      console assert isURL  http   foo com blah blah  wikipedia   again      console assert isURL  http   www example com wpstyle  p 364     console assert isURL  https   www example com foo  bar baz amp inga 42 amp quux     console assert isURL  http    df ws 123     console assert isURL  http   userid password example com 8080     console assert isURL  http   userid password example com 8080      console assert isURL  http   userid example com     console assert isURL  http   userid example com      console assert isURL  http   userid example com 8080     console assert isURL  http   userid example com 8080      console assert isURL  http   userid password example com     console assert isURL  http   userid password example com      console assert isURL  http   142 42 1 1      console assert isURL  http   142 42 1 1 8080      console assert isURL  http     ws       console assert isURL  http     ws     console assert isURL  http     ws      console assert isURL  http   foo com blah  wikipedia  cite-1     console assert isURL  http   foo com blah  wikipedia  blah cite-1     console assert isURL  http   foo com unicode     in parens     console assert isURL  http   foo com  something  after parens     console assert isURL  http     damowmow com      console assert isURL  http   code google com events   amp product browser     console assert isURL  http   j mp     console assert isURL  ftp   foo bar baz     console assert isURL  http   foo bar  q Test 20URL-encoded 20stuff     console assert isURL  http                   console assert isURL  http             console assert isURL  http                      console assert isURL  http   -      amp           40 80 2f       example com     console assert isURL  http   1337 net     console assert isURL  http   a b-c de     console assert isURL  http   223 255 255 254     console assert isURL  postgres   u p example com 5702 db     console assert isURL  https   d1f4470da51b49289906b3d6cbd65074 app getsentry com 13176        SHOULD NOT MATCH  console assert  isURL  http        console assert  isURL  http         console assert  isURL  http          console assert  isURL  http           console assert  isURL  http         console assert  isURL  http          console assert  isURL  http           console assert  isURL  http         console assert  isURL  http          console assert  isURL  http           console assert  isURL  http   foo bar q Spaces should be encoded     console assert  isURL         console assert  isURL    a     console assert  isURL     a     console assert  isURL          console assert  isURL  http    a     console assert  isURL  foo com     console assert  isURL  rdar   1234     console assert  isURL  h   test     console assert  isURL  http    shouldfail com     console assert  isURL      should fail     console assert  isURL  http   foo bar foo bar baz quux     console assert  isURL  ftps   foo bar      console assert  isURL  http   -error- invalid      console assert  isURL  http   a b--c de      console assert  isURL  http   -a b co     console assert  isURL  http   a b- co     console assert  isURL  http   0 0 0 0     console assert  isURL  http   10 1 1 0     console assert  isURL  http   10 1 1 255     console assert  isURL  http   224 1 1 1     console assert  isURL  http   1 1 1 1 1     console assert  isURL  http   123 123 123     console assert  isURL  http   3628126748     console assert  isURL  http    www foo bar      console assert  isURL  http   www foo bar       console assert  isURL  http    www foo bar       console assert  isURL  http   10 1 1 1        And then test that string of  a s   See this comparison of isURL regex by Mathias Bynens for more info before you post a seemingly great regex

User · Answer

I can t comment on the post that is the closest  5717133  but below is the way I figured out how to get  tom-gullen regex working      https            a-z d   a-z d-   a-z d         a-z  2      d 1 3     3  d 1 3       d       -a-z d               amp a-z d      -        -a-z d       i

User · Answer

The question asks a validation method for an url such as stackoverflow  without the protocol or any dot in the hostname  So  it s not a matter of validating url sintax  but checking if it s a valid url  by actually calling it   I tried several methods for knowing if the url true exists and is callable from within the browser  but did not find any way to test with javascript the response header of the call    adding an anchor element is fine for firing the click   method   making ajax call to the challenging url with  GET  is fine  but has it s various limitations due to CORS policies and it is not the case of using ajax  for as the url maybe any outside my server s domain  using the fetch API has a workaround similar to ajax  other problem is that I have my server under https protocol and throws an exception when calling non secure urls    So  the best solution I can think of is getting some tool to perform CURL using javascript trying something like curl -I  lt url gt   Unfortunately I did not find any and in appereance it s not possible  I will appreciate any comments on this   But  in the end  I have a server running PHP and as I use Ajax for almost all my requests  I wrote a function on the server side to perform the curl request there and return to the browser    Regarding the single word url on the question  stackoverflow  it will lead me to https   daniserver com ar stackoverflow  where daniserver com ar is my own domain

User · Answer

If you can change the input type  I think this solution would be much easier   You can simple use type  url  in your input and the check it with checkValidity   in js  E g   your html   lt input id  foo  type  url  gt    your js     The selector is JQuery  but the function is plain JS     foo   on  keyup   function         if  this checkValidity                 The url is valid       else              The url is invalid

[javascript] Check if a JavaScript string is a URL

Examples related to javascript

Examples related to string

Examples related to url