Shortest URL regex match in JavaScript

Question

Create the shortest regular expression that will roughly match a URL in text when run in JavaScript

Example:

"some text exampley.com".match(/your regular expression goes here/);

The regular expression needs to

• capture all valid URLS that are for http and https.
• not worry about not matching for URL looking strings that aren't actually valid URLS like super.awesome/cool
• be valid when run as a JavaScript regex

Test criteria:

Match:

• http://example.com
• http://example.com/
• http://example.com/super
• https://example.com/super
• example.com/super
• example.com
• example.com/su-per_duper/?add=yes&subtract=no
• example.com/archive/index.html
• twitter.com/#!/reply
• example.com/234ret2398oent/234nth
• codegolf.stackexchange.com/questions/464
• crazy.wow.really.example.com/?cat=nth%3E
• example-example.com
• example1.com

Not Match:

• example
• super/cool
• Good Morning
• i:can
• hello.

Here is a test that might help clarify a bit http://jsfiddle.net/MikeGrace/gsJyr/

I apologize for the lack of clarity, I hadn't realized how awful matching URLs was.

Answer 1

/.+\.\w\w.*/

doesn't match 3 strings that it shouldn't, matches almost anything else ;)
upd: it still doesn't match all 5

Answer 2

This one works:

var re = /(^|\s)((https?:\/\/)?[\w-]+(\.[\w-]+)+\.?(:\d+)?(\/\S*)?)/gi;

/*
(^|\s)                            : ensure that we are not matching an url 
                                    embeded in an other string
(https?:\/\/)?                    : the http or https schemes (optional)
[\w-]+(\.[\w-]+)+\.?              : domain name with at least two components;
                                    allows a trailing dot
(:\d+)?                           : the port (optional)
(\/\S*)?                          : the path (optional)
*/

Passes the tests at http://jsfiddle.net/9BYdp/1/

Also matches:

• example.com. (trailing dot)
• example.com:8080 (port)

Answer 3

This obviously doesn't do what you intend, but it meets your criteria:

 /.*/

• "match all valid URLS that are for http and https."

  yep, definately will match.

• "not worry about not matching for URL looking strings that aren't actually valid URLS like 'super.awesome/cool'"

  yeah, sure, there will be lots of false positives, but you said that doesn't matter.

• be valid when run as a JavaScript regex

  sure as eggs works as you say it should.

If this result is NOT a right answer, then you need to be more selective with your criteria.

In order to be a rule that works as you intend, you actually do need to implement a full RFC compliant matcher, and a full RFC compliant matcher will "worry about not matching".

So, in terms of "permit not matching", you need to specify exactly which deviations from RFC are permissible.

Anything else, and this whole exercise is a sham, because people will just write whatever works for them, or how they like it, and sacrifice "making any sense" in favour of being short ( like I did ).

On your update

The most Naïve regex I can come up with that matches (and captures) all your pasted examples so far is:

/(\S+\.[^/\s]+(\/\S+|\/|))/g;

Its quite simple in nature, and assumes only 3 basic forms are possible.

x.y
x.y/
x.y/z 

z can be anthing not whitespace. x can be anything not whitespace. y can be anything that is neither whitespace or a '/' character.

There are a lot of things that will be valid to this rule, lots, but they'll at least look like a valid URI to a human, they just won't be specifications compatible.

eg:

hello.0/1  # valid 
1.2/1 # valid 
muffins://¥.µ/€  # probably valid

I think the sane approach is to extract things that are likely to be URI's, then validate them with something stricter, I'm looking at working out how to use the browsers URI class to validate them =).

But you can see the above reasoning working on this sample here: http://jsfiddle.net/mHbXx/

Answer 4

/https?\:\/\/\w+((\:\d+)?\/\S*)?/

Try that.

I'm including the leading and trailing slashes that delimit the regular expression, so hopefully that doesn't hurt my character count!

This pattern limits the protocol to either http or https, allows for an optional port number, and then allows any character except whitespace.