Corrispondenza regex URL più breve in JavaScript

Crea l'espressione regolare più breve che corrisponderà approssimativamente a un URL nel testo quando viene eseguita in JavaScript

Esempio:

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

L'espressione regolare deve

• cattura tutti gli URL validi che sono per http e https.
• non preoccuparti di non trovare corrispondenze per stringhe che sembrano URL che non sono in realtà URL validi come super.awesome/cool
• essere valido quando eseguito come regex JavaScript

Criteri di prova:

Incontro:

• 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

Non corrisponde:

• esempio
• eccellente / freddo
• Buongiorno
• io posso
• Ciao.

Ecco un test che potrebbe aiutare a chiarire un po ' http://jsfiddle.net/MikeGrace/gsJyr/

Mi scuso per la mancanza di chiarezza, non mi ero reso conto di quanto fossero spaventosi gli URL di corrispondenza.

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

non corrisponde a 3 stringhe che non dovrebbe, corrisponde quasi a qualsiasi altra cosa;)
upd: non corrisponde ancora a tutte e 5 le stringhe

Questo funziona:

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

Supera i test su http://jsfiddle.net/9BYdp/1/

Corrisponde anche a:

• example.com. (punto finale)
• esempio.com:8080 (porta)

Questo ovviamente non fa ciò che intendi, ma soddisfa i tuoi criteri:

 /.*/

• "corrisponde a tutti gli URL validi che sono per http e https."

  sì, sicuramente corrisponderà.

• "non preoccuparti di non corrispondere per stringhe che sembrano URL che non sono in realtà URL validi come" super.awesome / cool ""

  sì, certo, ci saranno molti falsi positivi, ma hai detto che non importa.

• essere valido quando eseguito come regex JavaScript

  certo che le uova funzionano come dici tu.

Se questo risultato NON è una risposta giusta, allora devi essere più selettivo con i tuoi criteri.

Al fine di essere una regola che funziona come si intendono, in realtà si fa necessità di attuare una piena RFC matcher compliant, e un completo RFC matcher compliant volontà "preoccuparsi di non corrispondenti".

Pertanto, in termini di "permesso non corrispondente", è necessario specificare esattamente quali deviazioni dalla RFC sono consentite.

Qualsiasi altra cosa, e questo intero esercizio è un falso, perché le persone scriveranno semplicemente tutto ciò che funziona per loro, o come piace a loro, e sacrificheranno "ogni senso" a favore di essere brevi (come ho fatto io).

Al tuo aggiornamento

Il regex più ingenuo che riesco a inventare che combina (e cattura) tutti i tuoi esempi incollati finora è:

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

È abbastanza semplice in natura e presuppone che siano possibili solo 3 forme di base.

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

zpuò essere qualcosa di non bianco. xpuò essere qualsiasi cosa non bianca. ypuò essere qualsiasi cosa che non sia né spazi bianchi né un carattere '/'.

Ci sono molte cose che saranno valide per questa regola, molte, ma almeno sembreranno un URI valido a un essere umano, semplicemente non saranno compatibili con le specifiche.

per esempio:

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

Penso che l'approccio sano sia quello di estrarre cose che potrebbero essere URI, quindi di validarle con qualcosa di più rigoroso, sto cercando di capire come usare la classe URI del browser per validarle =).

Ma puoi vedere il ragionamento sopra lavorando su questo esempio qui: http://jsfiddle.net/mHbXx/

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

Prova questo.

Sto includendo le barre iniziali e finali che delimitano l'espressione regolare, quindi spero che ciò non danneggi il mio conteggio dei personaggi!

Questo modello limita il protocollo a http o https, consente un numero di porta opzionale e quindi consente qualsiasi carattere tranne gli spazi.