Regulärer Ausdruck zum Suchen von URLs innerhalb einer Zeichenfolge

Kennt jemand einen regulären Ausdruck, mit dem ich URLs in einer Zeichenfolge finden könnte? Ich habe bei Google viele reguläre Ausdrücke gefunden, um festzustellen, ob eine ganze Zeichenfolge eine URL ist, aber ich muss in der Lage sein, eine ganze Zeichenfolge nach URLs zu durchsuchen. Zum Beispiel möchte ich in der Lage sein, www.google.comund http://yahoo.comin der folgenden Zeichenfolge zu finden:

Hello www.google.com World http://yahoo.com

Ich suche nicht nach bestimmten URLs in der Zeichenfolge. Ich suche nach ALLEN URLs in der Zeichenfolge, weshalb ich einen regulären Ausdruck benötige.

Dies ist die, die ich benutze

(http|ftp|https)://([\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?

Funktioniert für mich, sollte auch für Sie arbeiten.

Vermutlich ist kein Regex perfekt für diese Verwendung. Ich habe hier einen ziemlich soliden gefunden

/(?:(?:https?|ftp|file):\/\/|www\.|ftp\.)(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[-A-Z0-9+&@#\/%=~_|$?!:,.])*(?:\([-A-Z0-9+&@#\/%=~_|$?!:,.]*\)|[A-Z0-9+&@#\/%=~_|$])/igm

Einige Unterschiede / Vorteile gegenüber den anderen hier veröffentlichten:

• Es stimmt nicht mit E-Mail-Adressen überein
• Es stimmt mit localhost überein: 12345
• Es wird so etwas wie moo.comohne httpoder nicht erkennenwww

Beispiele finden Sie hier

text = """The link of this question: /programming/6038061/regular-expression-to-find-urls-within-a-string
Also there are some urls: www.google.com, facebook.com, http://test.com/method?param=wasd
The code below catches all urls in text and returns urls in list."""

urls = re.findall('(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-?=%.]+', text)
print(urls)

Ausgabe:

[
    '/programming/6038061/regular-expression-to-find-urls-within-a-string', 
    'www.google.com', 
    'facebook.com',
    'http://test.com/method?param=wasd'
]

Keine der hier angebotenen Lösungen löste die Probleme / Anwendungsfälle, die ich hatte.

Was ich hier zur Verfügung gestellt habe, ist das Beste, was ich bisher gefunden / gemacht habe. Ich werde es aktualisieren, wenn ich neue Randfälle finde, die es nicht behandelt.

\b
  #Word cannot begin with special characters
  (?<![@.,%&#-])
  #Protocols are optional, but take them with us if they are present
  (?<protocol>\w{2,10}:\/\/)?
  #Domains have to be of a length of 1 chars or greater
  ((?:\w|\&\#\d{1,5};)[.-]?)+
  #The domain ending has to be between 2 to 15 characters
  (\.([a-z]{2,15})
       #If no domain ending we want a port, only if a protocol is specified
       |(?(protocol)(?:\:\d{1,6})|(?!)))
\b
#Word cannot end with @ (made to catch emails)
(?![@])
#We accept any number of slugs, given we have a char after the slash
(\/)?
#If we have endings like ?=fds include the ending
(?:([\w\d\?\-=#:%@&.;])+(?:\/(?:([\w\d\?\-=#:%@&;.])+))*)?
#The last char cannot be one of these symbols .,?!,- exclude these
(?<![.,?!-])

Ich denke, dieses Regex-Muster verarbeitet genau das, was Sie wollen

/(http|https|ftp|ftps)\:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?/

und dies ist ein Snippet-Beispiel zum Extrahieren von Urls:

// The Regular Expression filter
$reg_exUrl = "/(http|https|ftp|ftps)\:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?/";

// The Text you want to filter for urls
$text = "The text you want  /programming/6038061/regular-expression-to-find-urls-within-a-string to filter goes here.";

// Check if there is a url in the text
preg_match_all($reg_exUrl, $text, $url,$matches);
var_dump($matches);

Alle oben genannten Antworten stimmen nicht mit Unicode-Zeichen in der URL überein, z. B.: Http://google.com?query=đức+filan+đã+search

Für die Lösung sollte diese funktionieren:

(ftp:\/\/|www\.|https?:\/\/){1}[a-zA-Z0-9u00a1-\uffff0-]{2,}\.[a-zA-Z0-9u00a1-\uffff0-]{2,}(\S*)

Ich habe dies gefunden, das die meisten Beispiellinks abdeckt, einschließlich Unterverzeichnisteilen.

Regex ist:

(?:(?:https?|ftp):\/\/|\b(?:[a-z\d]+\.))(?:(?:[^\s()<>]+|\((?:[^\s()<>]+|(?:\([^\s()<>]+\)))?\))+(?:\((?:[^\s()<>]+|(?:\(?:[^\s()<>]+\)))?\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))?

Wenn Sie bei der Auswahl von Links streng sein müssen, würde ich mich für Folgendes entscheiden:

(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'".,<>?«»“”‘’]))

Weitere Informationen finden Sie hier:

Ein verbessertes liberales, genaues Regex-Muster für übereinstimmende URLs

Hier etwas optimierterer regulärer Ausdruck:

(?:(?:(https?|ftp|file):\/\/|www\.|ftp\.)|([\w\-_]+(?:\.|\s*\[dot\]\s*[A-Z\-_]+)+))([A-Z\-\.,@?^=%&:\/~\+#]*[A-Z\-\@?^=%&\/~\+#]){2,6}?

Hier ist ein Test mit Daten: https://regex101.com/r/sFzzpY/6

Wenn Sie das URL-Muster haben, sollten Sie in der Lage sein, es in Ihrer Zeichenfolge zu suchen. Stellen Sie einfach sicher, dass das Muster keinen Anfang und kein Ende der URL-Zeichenfolge hat ^und $markiert. Wenn also P das Muster für die URL ist, suchen Sie nach Übereinstimmungen für P.

Ich habe den folgenden regulären Ausdruck verwendet, um die URL in einer Zeichenfolge zu finden:

/(http|https)\:\/\/[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(\/\S*)?/

Ich benutze diesen Regex:

/((\w+:\/\/\S+)|(\w+[\.:]\w+\S+))[^\s,\.]/ig

Es funktioniert gut für viele URLs wie: http://google.com , https://dev-site.io:8080/home?val=1&count=100 , www.regexr.com, localhost: 8080 / path ,. ..

Kurz und einfach. Ich habe noch keinen Javascript-Code getestet, aber es sieht so aus, als würde es funktionieren:

((http|ftp|https):\/\/)?(([\w.-]*)\.([\w]*))

Code auf regex101.com

Eine wahrscheinlich zu vereinfachte, aber funktionierende Methode könnte sein:

[localhost|http|https|ftp|file]+://[\w\S(\.|:|/)]+

Ich habe es auf Python getestet und solange das String-Parsing ein Leerzeichen davor und danach und keines in der URL enthält (was ich noch nie gesehen habe), sollte es in Ordnung sein.

Hier ist eine Online-Idee, die dies demonstriert

Hier sind jedoch einige Vorteile der Verwendung:

• Es erkennt file:undlocalhost sowie IP-Adressen
• Es wird niemalsOhne sie passen
• Es macht nichts aus ungewöhnlichen Zeichen wie #oder -(siehe URL dieses Beitrags)

Die Verwendung des von @JustinLevene bereitgestellten regulären Ausdrucks hatte nicht die richtigen Escape-Sequenzen für die Schrägstriche. Aktualisiert, um jetzt korrekt zu sein, und unter der Bedingung hinzugefügt, dass es auch dem FTP-Protokoll entspricht: Stimmt mit allen URLs mit oder ohne Protokolle und ohne "www" überein.

Code: ^((http|ftp|https):\/\/)?([\w_-]+(?:(?:\.[\w_-]+)+))([\w.,@?^=%&:\/~+#-]*[\w@?^=%&\/~+#-])?

Beispiel: https://regex101.com/r/uQ9aL4/65

VERBESSERT

Erkennt solche URLs:

• https://www.example.pl
• http://www.example.com
• www.example.pl
• example.com
• http://blog.example.com
• http://www.example.com/product
• http://www.example.com/products?id=1&page=2
• http: //www.example.com#up
• http://255.255.255.255
• 255.255.255.255
• http: // www.site.com:8008

Regex:

/^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+$/gm

Schrieb selbst einen auf:

let regex = /([\w+]+\:\/\/)?([\w\d-]+\.)*[\w-]+[\.\:]\w+([\/\?\=\&\#]?[\w-]+)*\/?/gm

Es funktioniert in ALLEN der folgenden Domänen:

https://www.facebook.com
https://app-1.number123.com
http://facebook.com
ftp://facebook.com
http://localhost:3000
localhost:3000/
unitedkingdomurl.co.uk
this.is.a.url.com/its/still=going?wow
shop.facebook.org
app.number123.com
app1.number123.com
app-1.numbEr123.com
app.dashes-dash.com
www.facebook.com
facebook.com
fb.com/hello_123
fb.com/hel-lo
fb.com/hello/goodbye
fb.com/hello/goodbye?okay
fb.com/hello/goodbye?okay=alright
Hello www.google.com World http://yahoo.com
https://www.google.com.tr/admin/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
https://google.com.tr/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
http://google.com/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
ftp://google.com/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
www.google.com.tr/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
www.google.com/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
drive.google.com/test/subPage?qs1=sss1&qs2=sss2&qs3=sss3#Services
https://www.example.pl
http://www.example.com
www.example.pl
example.com
http://blog.example.com
http://www.example.com/product
http://www.example.com/products?id=1&page=2
http://www.example.com#up
http://255.255.255.255
255.255.255.255

Sie können sehen, wie es hier auf regex101 funktioniert, und nach Bedarf anpassen

Dies ist eine leichte Verbesserung / Anpassung an (je nachdem, was Sie brauchen) Rajeevs Antwort:

([\w\-_]+(?:(?:\.|\s*\[dot\]\s*[A-Z\-_]+)+))([A-Z\-\.,@?^=%&:/~\+#]*[A-Z\-\@?^=%&/~\+#]){2,6}?

Siehe hier für ein Beispiel von dem, was es tut und nicht übereinstimmt.

Ich habe den Scheck für "http" usw. losgeworden, da ich URLs ohne diesen abfangen wollte. Ich habe den regulären Ausdruck leicht hinzugefügt, um einige verschleierte URLs abzufangen (dh wo der Benutzer [Punkt] anstelle eines "." Verwendet). Schließlich habe ich "\ w" durch "AZ" bis "{2,3}" ersetzt, um Fehlalarme wie v2.0 und "moo.0dd" zu reduzieren.

Alle Verbesserungen an diesem Willkommen.

Ich habe das benutzt

^(https?:\\/\\/([a-zA-z0-9]+)(\\.[a-zA-z0-9]+)(\\.[a-zA-z0-9\\/\\=\\-\\_\\?]+)?)$

(?:vnc|s3|ssh|scp|sftp|ftp|http|https)\:\/\/[\w\.]+(?:\:?\d{0,5})|(?:mailto|)\:[\w\.]+\@[\w\.]+

Wenn Sie eine Erklärung für jeden Teil wünschen, versuchen Sie es in regexr [.] Com, wo Sie eine großartige Erklärung für jedes Zeichen erhalten.

Dies wird durch ein "|" oder "ODER", da nicht alle verwendbaren URIs "//" haben. Hier können Sie eine Liste von Schemata als oder Bedingungen erstellen, an denen Sie interessiert sind.

Ich habe die c # Uri-Klasse verwendet und sie funktioniert gut mit der IP-Adresse localhost

 public static bool CheckURLIsValid(string url)
    {
        Uri returnURL;

       return (Uri.TryCreate(url, UriKind.Absolute, out returnURL)
           && (returnURL.Scheme == Uri.UriSchemeHttp || returnURL.Scheme == Uri.UriSchemeHttps));


    }

Ich mochte die Lösung von Stefan Henze, aber sie würde 34,56 erreichen. Es ist zu allgemein und ich habe HTML nicht analysiert. Es gibt 4 Anker für eine URL;

www,

http: \ (und co),

. gefolgt von Buchstaben und dann /,

oder Briefe. und eine davon: https://ftp.isc.org/www/survey/reports/current/bynum.txt .

Ich habe viele Informationen aus diesem Thread verwendet. Danke euch allen.

"(((((http|ftp|https|gopher|telnet|file|localhost):\\/\\/)|(www\\.)|(xn--)){1}([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?)|(([\\w_-]{2,200}(?:(?:\\.[\\w_-]+)*))((\\.[\\w_-]+\\/([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?)|(\\.((org|com|net|edu|gov|mil|int|arpa|biz|info|unknown|one|ninja|network|host|coop|tech)|(jp|br|it|cn|mx|ar|nl|pl|ru|tr|tw|za|be|uk|eg|es|fi|pt|th|nz|cz|hu|gr|dk|il|sg|uy|lt|ua|ie|ir|ve|kz|ec|rs|sk|py|bg|hk|eu|ee|md|is|my|lv|gt|pk|ni|by|ae|kr|su|vn|cy|am|ke))))))(?!(((ttp|tp|ttps):\\/\\/)|(ww\\.)|(n--)))"

Oben wird fast alles gelöst, außer einer Zeichenfolge wie "eurls: www.google.com, facebook.com, http: //test.com/", die als einzelne Zeichenfolge zurückgegeben wird. Tbh idk, warum ich Gopher usw. hinzugefügt habe. Beweis R-Code

if(T){
  wierdurl<-vector()
  wierdurl[1]<-"https://JP納豆.例.jp/dir1/納豆 "
  wierdurl[2]<-"xn--jp-cd2fp15c.xn--fsq.jp "
  wierdurl[3]<-"http://52.221.161.242/2018/11/23/biofourmis-collab"
  wierdurl[4]<-"https://12000.org/ "
  wierdurl[5]<-"  https://vg-1.com/?page_id=1002 "
  wierdurl[6]<-"https://3dnews.ru/822878"
  wierdurl[7]<-"The link of this question: /programming/6038061/regular-expression-to-find-urls-within-a-string
  Also there are some urls: www.google.com, facebook.com, http://test.com/method?param=wasd
  The code below catches all urls in text and returns urls in list. "
  wierdurl[8]<-"Thelinkofthisquestion:/programming/6038061/regular-expression-to-find-urls-within-a-string
  Alsotherearesomeurls:www.google.com,facebook.com,http://test.com/method?param=wasd
  Thecodebelowcatchesallurlsintextandreturnsurlsinlist. "
  wierdurl[9]<-"Thelinkofthisquestion:/programming/6038061/regular-expression-to-find-urls-within-a-stringAlsotherearesomeurlsZwww.google.com,facebook.com,http://test.com/method?param=wasdThecodebelowcatchesallurlsintextandreturnsurlsinlist."
  wierdurl[10]<-"1facebook.com/1res"
  wierdurl[11]<-"1facebook.com/1res/wat.txt"
  wierdurl[12]<-"www.e "
  wierdurl[13]<-"is this the file.txt i need"
  wierdurl[14]<-"xn--jp-cd2fp15c.xn--fsq.jpinspiredby "
  wierdurl[15]<-"[xn--jp-cd2fp15c.xn--fsq.jp/inspiredby "
  wierdurl[16]<-"xnto--jpto-cd2fp15c.xnto--fsq.jpinspiredby "
  wierdurl[17]<-"fsety--fwdvg-gertu56.ffuoiw--ffwsx.3dinspiredby "
  wierdurl[18]<-"://3dnews.ru/822878 "
  wierdurl[19]<-" http://mywebsite.com/msn.co.uk "
  wierdurl[20]<-" 2.0http://www.abe.hip "
  wierdurl[21]<-"www.abe.hip"
  wierdurl[22]<-"hardware/software/data"
  regexstring<-vector()
  regexstring[2]<-"(http|ftp|https)://([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?"
  regexstring[3]<-"/(?:(?:https?|ftp|file):\\/\\/|www\\.|ftp\\.)(?:\\([-A-Z0-9+&@#\\/%=~_|$?!:,.]*\\)|[-A-Z0-9+&@#\\/%=~_|$?!:,.])*(?:\\([-A-Z0-9+&@#\\/%=~_|$?!:,.]*\\)|[A-Z0-9+&@#\\/%=~_|$])/igm"
  regexstring[4]<-"[a-zA-Z0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]?"
  regexstring[5]<-"((http|ftp|https)\\:\\/\\/)?([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?"
  regexstring[6]<-"((http|ftp|https):\\/\\/)?([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?"
  regexstring[7]<-"(http|ftp|https)(:\\/\\/)([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?"
  regexstring[8]<-"(?:(?:https?|ftp|file):\\/\\/|www\\.|ftp\\.)(?:\\([-A-Z0-9+&@#/%=~_|$?!:,.]*\\)|[-A-Z0-9+&@#/%=~_|$?!:,.])*(?:\\([-A-Z0-9+&@#/%=~_|$?!:,.]*\\)|[A-Z0-9+&@#/%=~_|$])"
  regexstring[10]<-"((http[s]?|ftp):\\/)?\\/?([^:\\/\\s]+)((\\/\\w+)*\\/)([\\w\\-\\.]+[^#?\\s]+)(.*)?(#[\\w\\-]+)?"
  regexstring[12]<-"http[s:/]+[[:alnum:]./]+"
  regexstring[9]<-"http[s:/]+[[:alnum:]./]+" #in DLpages 230
  regexstring[1]<-"[[:alnum:]-]+?[.][:alnum:]+?(?=[/ :])" #in link_graphs 50
  regexstring[13]<-"^(?!mailto:)(?:(?:http|https|ftp)://)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$"
  regexstring[14]<-"(((((http|ftp|https):\\/\\/)|(www\\.)|(xn--)){1}([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?)|(([\\w_-]+(?:(?:\\.[\\w_-]+)*))((\\.((org|com|net|edu|gov|mil|int)|(([:alpha:]{2})(?=[, ]))))|([\\/]([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?))))(?!(((ttp|tp|ttps):\\/\\/)|(ww\\.)|(n--)))"
  regexstring[15]<-"(((((http|ftp|https|gopher|telnet|file|localhost):\\/\\/)|(www\\.)|(xn--)){1}([\\w_-]+(?:(?:\\.[\\w_-]+)+))([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?)|(([\\w_-]{2,200}(?:(?:\\.[\\w_-]+)*))((\\.[\\w_-]+\\/([\\w.,@?^=%&:\\/~+#-]*[\\w@?^=%&\\/~+#-])?)|(\\.((org|com|net|edu|gov|mil|int|arpa|biz|info|unknown|one|ninja|network|host|coop|tech)|(jp|br|it|cn|mx|ar|nl|pl|ru|tr|tw|za|be|uk|eg|es|fi|pt|th|nz|cz|hu|gr|dk|il|sg|uy|lt|ua|ie|ir|ve|kz|ec|rs|sk|py|bg|hk|eu|ee|md|is|my|lv|gt|pk|ni|by|ae|kr|su|vn|cy|am|ke))))))(?!(((ttp|tp|ttps):\\/\\/)|(ww\\.)|(n--)))"
    }

for(i in wierdurl){#c(7,22)
  for(c in regexstring[c(15)]) {
    print(paste(i,which(regexstring==c)))
    print(str_extract_all(i,c))
  }
}

Ich benutze die Logik, Text zwischen zwei Punkten oder Punkten zu finden

Die Regex unten funktioniert gut mit Python

(?<=\.)[^}]*(?=\.)

Das Abgleichen einer URL in einem Text sollte nicht so komplex sein

(?:(?:(?:ftp|http)[s]*:\/\/|www\.)[^\.]+\.[^ \n]+)

https://regex101.com/r/wewpP1/2

Dies ist die einfachste. welche arbeiten für mich gut.

%(http|ftp|https|www)(://|\.)[A-Za-z0-9-_\.]*(\.)[a-z]*%

Es ist einfach.

Verwenden Sie dieses Muster: \b((ftp|https?)://)?([\w-\.]+\.(com|net|org|gov|mil|int|edu|info|me)|(\d+\.\d+\.\d+\.\d+))(:\d+)?(\/[\w-\/]*(\?\w*(=\w+)*[&\w-=]*)*(#[\w-]+)*)?

Es passt zu jedem Link, der Folgendes enthält:

Zulässige Protokolle: http, https und ftp

Zulässige Domänen: * .com, * .net, * .org, * .gov, * .mil, * .int, * .edu, * .info und * .me ODER IP

Zulässige Ports: true

Zulässige Parameter: true

Erlaubte Hashes: wahr

Dies ist der beste.

NSString *urlRegex="(http|ftp|https|www|gopher|telnet|file)(://|.)([\\w_-]+(?:(?:\\.[\\w_-]+)‌​+))([\\w.,@?^=%&:/~+#-]*[\\w@?^=%&/~+#-])?";