Correspondance d'expression rationnelle d'URL la plus courte en JavaScript

Créez l'expression régulière la plus courte qui correspondra approximativement à une URL dans le texte lorsqu'elle est exécutée en JavaScript

Exemple:

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

L'expression régulière doit

• capturez toutes les URL valides pour http et https.
• ne vous inquiétez pas de ne pas faire correspondre les chaînes de recherche d'URL qui ne sont pas réellement des URL valides comme super.awesome/cool
• être valide lorsqu'il est exécuté en tant que regex JavaScript

Critères de test:

Rencontre:

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

Ne pas correspondre:

• exemple
• super cool
• Bonjour
• je peux
• Bonjour.

Voici un test qui pourrait aider à clarifier un peu http://jsfiddle.net/MikeGrace/gsJyr/

Je m'excuse pour le manque de clarté, je n'avais pas réalisé à quel point les URL correspondantes étaient affreuses.

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

ne correspond pas à 3 chaînes qu'il ne devrait pas, correspond à presque tout le reste;)
upd: il ne correspond toujours pas aux 5

Celui-ci fonctionne:

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

Réussit les tests sur http://jsfiddle.net/9BYdp/1/

Correspond également à:

• example.com. (point de fin)
• example.com:8080 (port)

Cela ne fait évidemment pas ce que vous avez l'intention, mais cela répond à vos critères:

 /.*/

• "correspond à toutes les URL valides pour http et https."

  oui, correspondra certainement.

• "ne vous inquiétez pas de ne pas faire correspondre les chaînes de recherche d'URL qui ne sont pas réellement des URL valides comme 'super.awesome / cool'"

  oui, bien sûr, il y aura beaucoup de faux positifs, mais vous avez dit que cela n'avait pas d'importance.

• être valide lorsqu'il est exécuté en tant que regex JavaScript

  bien sûr que les œufs fonctionnent comme vous le dites.

Si ce résultat n'est PAS une bonne réponse, alors vous devez être plus sélectif avec vos critères.

Pour être une règle qui fonctionne comme vous le souhaitez, vous devez faire besoin de mettre en œuvre un matcher conforme à la RFC complète et un adaptateur compatible RFC complet sera « souci de ne pas correspondre ».

Donc, en termes de "permis ne correspondant pas", vous devez spécifier exactement quels écarts par rapport au RFC sont autorisés.

Tout le reste, et tout cet exercice est une imposture, parce que les gens vont simplement écrire tout ce qui fonctionne pour eux, ou comment ils l'aiment, et sacrifier "avoir un sens" au profit d'être court (comme je l'ai fait).

Sur votre mise à jour

Le regex le plus naïf que je puisse trouver qui correspond (et capture) tous vos exemples collés jusqu'à présent est:

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

Sa nature est assez simple et suppose que seules 3 formes de base sont possibles.

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

zpeut être quelque chose et non des espaces. xpeut être autre chose qu'un espace. ypeut être tout ce qui n'est ni un espace ni un caractère '/'.

Il y a beaucoup de choses qui seront valables pour cette règle, beaucoup, mais elles ressembleront au moins à un URI valide pour un humain, elles ne seront tout simplement pas compatibles avec les spécifications.

par exemple:

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

Je pense que l'approche sensée consiste à extraire les éléments susceptibles d'être des URI, puis à les valider avec quelque chose de plus strict, j'essaie de trouver comment utiliser la classe URI des navigateurs pour les valider =).

Mais vous pouvez voir le raisonnement ci-dessus travailler sur cet exemple ici: http://jsfiddle.net/mHbXx/

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

Essayez ça.

J'inclus les barres obliques de début et de fin qui délimitent l'expression régulière, donc j'espère que cela ne nuit pas au nombre de mes personnages!

Ce modèle limite le protocole à http ou https, autorise un numéro de port facultatif, puis autorise tout caractère à l'exception des espaces.