La coincidencia de expresiones regulares de URL más corta en JavaScript

Cree la expresión regular más corta que coincida aproximadamente con una URL en el texto cuando se ejecuta en JavaScript

Ejemplo:

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

La expresión regular necesita

• captura todas las URL válidas que son para http y https.
• no se preocupe por no coincidir con las cadenas de búsqueda de URL que no son URL válidas super.awesome/cool
• ser válido cuando se ejecuta como una expresión regular de JavaScript

Criterio de prueba:

Partido:

• http://ejemplo.com
• http://example.com/
• http://example.com/super
• https://example.com/super
• ejemplo.com/super
• ejemplo.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
• ejemplo-ejemplo.com
• ejemplo1.com

No coincide:

• ejemplo
• Super guay
• Buenos días
• yo puedo
• Hola.

Aquí hay una prueba que podría ayudar a aclarar un poco http://jsfiddle.net/MikeGrace/gsJyr/

Pido disculpas por la falta de claridad, no me había dado cuenta de lo horrible que era la coincidencia de URL.

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

no coincide con 3 cadenas que no debería, coincide con casi cualquier otra cosa;)
upd: todavía no coincide con los 5

Este funciona:

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

Pasa las pruebas en http://jsfiddle.net/9BYdp/1/

También coincide con:

• ejemplo.com. (punto final)
• ejemplo.com:8080 (puerto)

Obviamente, esto no hace lo que pretendes, pero cumple con tus criterios:

 /.*/

• "coincide con todas las URL válidas que son para http y https".

  Sí, definitivamente coincidirá.

• "no se preocupe por no coincidir con las cadenas de búsqueda de URL que no son URL válidas como 'super.awesome / cool'"

  sí, claro, habrá muchos falsos positivos, pero dijiste que eso no importa.

• ser válido cuando se ejecuta como una expresión regular de JavaScript

  Seguro que los huevos funcionan como dices.

Si este resultado NO es una respuesta correcta, entonces debe ser más selectivo con sus criterios.

Para ser una regla que funcione como pretendes, en realidad es necesario implementar un emparejador compatible con RFC completo, y un emparejador compatible con RFC completo "se preocupará por no coincidir".

Entonces, en términos de "permiso no coincidente", debe especificar exactamente qué desviaciones de RFC son permisibles.

Cualquier otra cosa, y todo este ejercicio es una farsa, porque la gente simplemente escribirá lo que sea que les funcione, o cómo les guste, y sacrificará "tener sentido" en favor de ser breve (como lo hice yo).

En su actualización

La expresión regular más ingenua que se me ocurre que coincide (y captura) con todos sus ejemplos pegados hasta ahora es:

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

Es bastante simple en naturaleza, y asume que solo son posibles 3 formas básicas.

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

zpuede ser anthing no espacio en blanco. xpuede ser cualquier cosa, no espacios en blanco. ypuede ser cualquier cosa que no sea un espacio en blanco o un carácter '/'.

Hay muchas cosas que serán válidas para esta regla, muchas, pero al menos se verán como un URI válido para un humano, simplemente no serán compatibles con las especificaciones.

p.ej:

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

Creo que el enfoque sensato es extraer cosas que probablemente sean URI, luego validarlas con algo más estricto, estoy buscando resolver cómo usar la clase URI de los navegadores para validarlas =).

Pero puede ver el razonamiento anterior trabajando en este ejemplo aquí: http://jsfiddle.net/mHbXx/

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

Trata eso.

Incluyo las barras inclinadas iniciales y finales que delimitan la expresión regular, ¡así que espero que eso no perjudique mi recuento de caracteres!

Este patrón limita el protocolo a http o https, permite un número de puerto opcional y luego permite cualquier carácter excepto los espacios en blanco.