it-swarm.com.de

Überprüfen Sie erneut, ob eine gültige URL mit den Endungen .jpg, .png oder .gif vorhanden ist

Ich möchte, dass Benutzer eine URL übermitteln, die gültig ist, aber auch ein Bild ist, das mit .jpg, .png oder .gif endet.

30
Jim
(?: ([^: /? #] +):)? (?: // ([^ /? #] *))? ([^? #] * \. (?: jpg | gif | png) ) (?: \? ([^ #] *)? (?: # (. *))?

Dies ist eine (leicht modifizierte) Version des offiziellen URI-Parsing-Ausdrucks von RFC 2396 . Es ermöglicht #fragments und ?querystrings wird nach dem Dateinamen angezeigt, der möglicherweise nicht Ihren Wünschen entspricht. Es stimmt auch mit jeder gültigen Domain überein, einschließlich localhost, die möglicherweise nicht Ihren Wünschen entspricht, aber geändert werden kann.

Ein herkömmlicherer Ausdruck dafür könnte wie folgt aussehen.

^ https?: // (?: [a-z0-9\-] + \.) + [az] {2,6} (?:/[^/#?] +) + \. (?: jpg | gif | png) $ 
 | -------- domain -------- --- path --- | - extension --- |

[~ # ~] edit [~ # ~] Siehe mein --- (anderer Kommentar , der die Frage zwar nicht als beantwortet Ich denke, es ist in diesem Fall wahrscheinlich nützlicher. Allerdings lasse ich das hier für karma-Hure Vollständigkeitsgründe.

69
Dan

Tatsächlich.

Warum überprüfst du die URL? Das ist keine Garantie dafür, dass Sie ein Bild erhalten, und keine Garantie dafür, dass die Dinge, die Sie ablehnen, nicht Bilder sind. Versuchen Sie, eine HEAD) -Anforderung auszuführen, und überprüfen Sie, um welchen Inhaltstyp es sich handelt tatsächlich.

37
Dan

Im Allgemeinen ist es besser, URLs mithilfe integrierter Bibliotheks- oder Framework-Funktionen zu validieren, als dafür eigene reguläre Ausdrücke zu verwenden - siehe Was ist der beste reguläre Ausdruck, um zu überprüfen, ob eine Zeichenfolge eine gültige URL ist für Details.

Wenn Sie daran interessiert sind, lesen Sie diese Frage:

Teile einer URL abrufen (Regex)

Sobald Sie mit der URL zufrieden sind (mit welchen Mitteln auch immer Sie sie validiert haben), können Sie entweder einen einfachen Zeichenfolgenoperator vom Typ "endswith" verwenden, um die Erweiterung zu überprüfen, oder einen einfachen regulären Ausdruck wie

(?i)\.(jpg|png|gif)$
14
Blair Conrad
(http(s?):)|([/|.|\w|\s])*\.(?:jpg|gif|png)

Dies wird alle Bilder von diesem String bearbeiten:

background: rgb(255, 0, 0) url(../res/img/temp/634043/original/cc3d8715eed0c.jpg) repeat fixed left top; cursor: auto;
<div id="divbg" style="background-color:#ff0000"><img id="bg" src="../res/img/temp/634043/original/cc3d8715eed0c.jpg" width="100%" height="100%" /></div>
background-image: url(../res/img/temp/634043/original/cc3d8715eed0c.png);
background: rgb(255, 0, 0) url(http://google.com/res/../img/temp/634043/original/cc3    _d8715eed0c.jpg) repeat fixed left top; cursor: auto;
background: rgb(255, 0, 0) url(https://google.com/res/../img/temp/634043/original/cc3_d8715eed0c.jpg) repeat fixed left top; cursor: auto;

Testen Sie Ihre Regex hier: https://regex101.com/r/l2Zt7S/1

13
FDisk

Wenn Sie wirklich sicher sein möchten, sollte es ausreichen, die ersten ein oder zwei Kilobyte der angegebenen URL zu erfassen, um alles zu bestimmen, was Sie über das Bild wissen müssen.

Hier ist ein Beispiel, wie Sie diese Informationen erhalten können mit Python, und hier ist ein Beispiel, wie es als Django Formularfeld verwendet wird) Damit können Sie das Vorhandensein, die Dateigröße, die Abmessungen und das Format eines Bildes anhand seiner URL leicht überprüfen.

2
Jonny Buchanan

(http(s?):)([/|.|\w|\s|-])*\.(?:jpg|gif|png) hat bei mir sehr gut funktioniert.

Dies entspricht URLs in den folgenden Formen:

https://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.jpg
http://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.jpg
https://farm4.staticflickr.com/3894/15008518202-c265dfa55f-h.jpg
https://farm4.staticflickr.com/3894/15008518202.c265dfa55f.h.jpg
https://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.gif
http://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.gif
https://farm4.staticflickr.com/3894/15008518202-c265dfa55f-h.gif
https://farm4.staticflickr.com/3894/15008518202.c265dfa55f.h.gif
https://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.png
http://farm4.staticflickr.com/3894/15008518202_c265dfa55f_h.png
https://farm4.staticflickr.com/3894/15008518202-c265dfa55f-h.png
https://farm4.staticflickr.com/3894/15008518202.c265dfa55f.h.png

Überprüfen Sie diesen regulären Ausdruck anhand der folgenden URLs: http://regexr.com/3g1v7

2
Blairg23

Hier ist die Grundidee in Perl. Salz nach Geschmack.

 #!/usr/bin/Perl 
 
 LWP :: UserAgent verwenden; 
 
 my $ ua = LWP :: UserAgent-> new ; 
 
 @ ARGV = qw (http://www.example.com/logo.png); 
 
 My $ response = $ ua-> head ($ ARGV [0]); 
 
 My ($ class, $ type) = split m |/|, lc $ response-> content_type; 
 
 print "Es ist ein Bild!\n", wenn $ class eq 'image'; 

Wenn Sie die URL überprüfen müssen, verwenden Sie eine solide Bibliothek, anstatt zu versuchen, alle ungewöhnlichen Situationen selbst zu handhaben:

 benutze URI; 
 
 mein $ uri = URI-> neu ($ ARGV [0]); 
 
 mein $ last = ($ uri-> path_segments) [- 1]; 
 
 my ($ extension) = $ last = ~ m /\.([^.‹+)$/ g; 
 
 print "Meine Erweiterung ist $ extension\n"; 

Viel Glück, :)

2
brian d foy
^((http(s?)\:\/\/|~/|/)?([\w]+:\[email protected])?([a-zA-Z]{1}([\w\-]+\.)+([\w]{2,5}))(:[\d]{1,5})?((/?\w+/)+|/?)(\w+\.(jpg|png|gif))
1
Mark Cidade

Dieser Ausdruck entspricht allen Bild-URLs.

^(?:http(s)?:\/\/)?[\w.-]+(?:\.[\w\.-]+)+[\w\-\._~:/?#[\]@!\$&'\(\)\*\+,;=.]+(?:png|jpg|jpeg|gif|svg)+$

Beispiele -

Gültig -

https://itelligencegroup.com/wp-content/usermedia/de_home_teaser-box_puzzle_in_the_Sun.png
http://sweetytextmessages.com/wp-content/uploads/2016/11/9-Happy-Monday-images.jpg
example.com/de_home_teaser-box_puzzle_in_the_Sun.png
www.example.com/de_home_teaser-box_puzzle_in_the_Sun.png
https://www.greetingseveryday.com/wp-content/uploads/2016/08/Happy-Independence-Day-Greetings-Cards-Pictures-in-Urdu-Marathi-1.jpg
http://thuglifememe.com/wp-content/uploads/2017/12/Top-Happy-tuesday-quotes-1.jpg
https://1.bp.blogspot.com/-ejYG9pr06O4/Wlhn48nx9cI/AAAAAAAAC7s/gAVN3tEV3NYiNPuE-Qpr05TpqLiG79tEQCLcBGAs/s1600/Republic-Day-2017-Wallpapers.jpg

Ungültig -

https://www.example.com
http://www.example.com
www.example.com
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://invalid.com/Perl.cgi?key= | http://web-site.com/cgi-bin/Perl.cgi?key1=value1&key2
http://www.siteabcd.com:8008
0
Tushar Walzade

Referenz: Siehe den Abschnitt DecodeConfig im offiziellen Dokument go lang image lib hier

Ich glaube, Sie könnten DecodeConfig auch verwenden, um das Format eines Bildes zu erhalten, das Sie dann anhand von const-Typen wie jpeg, png, jpg und gif validieren können

import (
  "encoding/base64"
  "fmt"
  "image"
  "log"
  "strings"
  "net/http"

  // Package image/jpeg is not used explicitly in the code below,
  // but is imported for its initialization side-effect, which allows
  // image.Decode to understand JPEG formatted images. Uncomment these
  // two lines to also understand GIF and PNG images:
  // _ "image/gif"
  // _ "image/png"
  _ "image/jpeg"
   )

func main() {
  resp, err := http.Get("http://i.imgur.com/Peq1U1u.jpg")
  if err != nil {
      log.Fatal(err)
  }
  defer resp.Body.Close()
  data, _, err := image.Decode(resp.Body)
  if err != nil {
      log.Fatal(err)
  }
  reader := base64.NewDecoder(base64.StdEncoding, strings.NewReader(data))
  config, format, err := image.DecodeConfig(reader)
  if err != nil {
      log.Fatal(err)
  }
  fmt.Println("Width:", config.Width, "Height:", config.Height, "Format:", format)
}

format ist hier ein String, der das Dateiformat angibt, zB jpg, png etc

0
kevthanewversi

Verwenden Sie FastImage - um zu bestimmen, ob es sich um ein Bild handelt, welche Art von Bild und welche Größe.

0
dkam

Zusatz zu Dan's Antwort.

Wenn es eine IP-Adresse anstelle einer Domain gibt.

Regex ein bisschen ändern. (Temporäre Lösung für gültiges IPv4 und IPv6)

^https?://(?:[a-z0-9\-]+\.)+[a-z0-9]{2,6}(?:/[^/#?]+)+\.(?:jpg|gif|png)$

Dies kann jedoch verbessert werden, damit IPv4 und IPv6 Subnetzbereiche validieren.

0
shyammakwana.me