web-dev-qa-db-fra.com

Regex pour vérifier si l'URL valide se termine par .jpg, .png ou .gif

Je souhaite que les utilisateurs soumettent une URL valide mais également une image se terminant par .jpg, .png ou .gif.

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

Il s'agit d'une version (légèrement modifiée) de l'expression rationnelle d'analyse d'URI officielle de RFC 2396 . Il permet #fragments et ?querystrings pour apparaître après le nom de fichier, qui peut être ou non ce que vous voulez. Il correspond également à n'importe quel domaine valide, y compris localhost, qui encore une fois pourrait ne pas être ce que vous voulez, mais il pourrait être modifié.

Une expression rationnelle plus traditionnelle pour cela pourrait ressembler à ce qui suit.

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

[~ # ~] modifier [~ # ~] Voir mon --- (autre commentaire , qui bien que ne répondant pas à la question comme complètement comme celui-ci, je pense que c'est probablement un plus utile dans ce cas. Cependant, je laisse cela ici pour putain de karma raisons d'exhaustivité.

69
Dan

Réellement.

Pourquoi vérifiez-vous l'URL? Ce n'est pas une garantie que vous obtiendrez une image, et aucune garantie que les choses que vous rejetez ne sont pas des images. Essayez d'effectuer une HEAD requête dessus, et voyez de quel type de contenu il s'agit en fait.

37
Dan

En général, il vaut mieux valider les URL à l'aide des fonctions de bibliothèque ou de framework intégrées, plutôt que de rouler vos propres expressions régulières pour ce faire - voir Quelle est la meilleure expression régulière pour vérifier si une chaîne est une URL valide pour plus de détails.

Si vous souhaitez le faire, consultez cette question:

Obtention de parties d'une URL (Regex)

Ensuite, une fois que vous êtes satisfait de l'URL (par tout moyen que vous avez utilisé pour la valider), vous pouvez soit utiliser un simple opérateur de chaîne de type "endswith" pour vérifier l'extension, soit une simple expression régulière comme

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

Cela va mach toutes les images de cette chaîne:

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;

Testez votre regex ici: https://regex101.com/r/l2Zt7S/1

13
FDisk

Si vous voulez vraiment être sûr, saisir le premier kilo-octet ou deux de l'URL donnée devrait être suffisant pour déterminer tout ce que vous devez savoir sur l'image.

Voici n exemple de la façon dont vous pouvez obtenir ces informations , en utilisant Python, et voici n exemple de son utilisation, comme un champ de formulaire Django qui vous permet de valider facilement l'existence d'une image, sa taille, ses dimensions et son format, compte tenu de son URL.

2
Jonny Buchanan

(http(s?):)([/|.|\w|\s|-])*\.(?:jpg|gif|png) a très bien fonctionné pour moi.

Cela correspondra aux URL sous les formes suivantes:

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

Vérifiez cette expression régulière par rapport aux URL ici: http://regexr.com/3g1v7

2
Blairg23

Voici l'idée de base en Perl. Sel au goût.

 #!/usr/bin/Perl 
 
 utilise LWP :: UserAgent; 
 
 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; 
 
 imprimer "C'est une image!\n" si $ class eq 'image';

Si vous devez inspecter l'URL, utilisez une bibliothèque solide plutôt que d'essayer de gérer vous-même toutes les situations étranges:

 utilisez l'URI; 
 
 mon $ uri = URI-> nouveau ($ ARGV [0]); 
 
 mon $ dernier = ($ uri-> path_segments) [- 1]; 
 
 my ($ extension) = $ last = ~ m /\.([^.[+)$/ g; 
 
 imprimer "Mon extension est $ extension\n";

Bonne chance, :)

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

Cette expression correspondra à toutes les URL d'image -

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

Exemples -

( Valide - 

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

Non valide - 

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

Référence: Voir la section DecodeConfig sur les documents officiels de la lib image go lang ici

Je pense que vous pouvez également utiliser DecodeConfig pour obtenir le format d'une image que vous pourrez ensuite valider par rapport aux types const tels que jpeg, png, jpg et gif ie

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)
}

le format est ici une chaîne qui indique le format de fichier, par exemple jpg, png, etc.

0
kevthanewversi

Utilisez FastImage - il récupérera les données minimales requises de l'URL pour déterminer s'il s'agit d'une image, quel type d'image et quelle taille.

0
dkam

Ajout à Dan's Réponse.

S'il y a une adresse IP au lieu d'un domaine.

Modifiez un peu l'expression régulière. (Solution temporaire pour IPv4 et IPv6 valides)

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

Cependant, cela peut être amélioré pour qu'IPv4 et IPv6 valident la ou les plages de sous-réseau.

0
shyammakwana.me