Quelle est la différence entre URI.s'échapper et CGI.échapper?

Quelle est la différence entre une hache et une épée, et celui que je devrais utiliser? Eh bien, il dépend sur ce que vous devez faire.

URI.escape était censé pour encoder une chaîne de caractères (URL) dans, soi-disant, "Pour cent de codage".

CGI::escape est à venir à partir de la CGI spec, qui décrit comment les données doivent être codées/décodage entre le serveur web et l'application.

Maintenant, disons que vous avez besoin pour échapper à une URI dans votre application. C'est un plus en cas d'utilisation spécifiques.
Pour cela, la communauté Ruby utilisé URI.escape pendant des années. Le problème avec URI.escape était qu'il ne pouvait pas gérer la RFC-3896 spec.

URI.escape 'http://google.com/foo?bar=at#anchor&title=My Blog & Your Blog' 
# => "http://google.com/foo?bar=at%23anchor&title=My%20Blog%20&%20Your%20Blog"

URI.escape a été marqué comme obsolète:

En outre URI en cours.l'encodage est simple gsub. Mais je pense qu'il devrait
diviser un URI de composants, puis échapper à chaque composants, et enfin
se joindre à eux.

Donc les URI.coder est considéré comme dangereux et obsolète. Ce sera
être retiré ou un changement de comportement de façon drastique.

Qu'est-ce que le remplacement en ce moment?

Comme je l'ai dit ci-dessus, URI en cours.l'encodage est mauvais sur spec niveau. Nous avons donc
ne pas fournir le remplacement exact. Le remplacement varient par son
cas d'utilisation.

https://bugs.ruby-lang.org/issues/4167

Malheureusement, il n'existe pas un seul mot à ce sujet dans la doc, la seule façon de le savoir est de vérifier la source, ou d'exécuter le script avec des avertissements dans le niveau de détail (-wW2) (ou d'utiliser certains de google-fu).

Certains proposé à utiliser CGI::Escape pour les paramètres de la requête, parce que vous ne pouvait pas échapper à un ensemble d'URI:

CGI::escape 'http://google.com/foo?bar=at#anchor&title=My Blog & Your Blog'
# => "http%3A%2F%2Fgoogle.com%2Ffoo%3Fbar%3Dat%23anchor%26title%3DMy+Blog+%26+Your+Blog"

CGI::escape doit être utilisé pour les paramètres de la requête seulement, mais les résultats seront, de nouveau, à l'encontre de la spec. En fait l'utilisation la plus courante de cas s'échappe des données de formulaire, par exemple lors de l'envoi d'un application/x-www-form-urlencoded requête POST.

Également mentionné WEBrick::HTTPUtils.escape n'est pas beaucoup d'amélioration (encore une fois c'est juste une simple gsub, qui est, IMO, même pire que de URI.escape):

WEBrick::HTTPUtils.escape 'http://google.com/foo?bar=at#anchor&title=My Blog & Your Blog'
# => "http://google.com/foo?bar=at%23anchor&title=My%20Blog%20&%20Your%20Blog" 

Le plus proche de la spec semble être le Adressable gem:

require 'addressable/uri'
Addressable::URI.escape 'http://google.com/foo?bar=at#anchor&title=My Blog & Your Blog'
# => "http://google.com/foo?bar=at#anchor&title=My%20Blog%20&%20Your%20Blog"

Avis, que, contrairement à toutes les précédentes options, Adressable n'échappe pas à #, et c'est le comportement attendu. vous voulez garder le # de hachage dans le chemin de l'URI, mais pas dans l'URI de la requête.

Le seul problème reste, c'est que nous n'avons pas échappé à nos paramètres de requête correctement, ce qui nous amène à la conclusion: il ne faut pas utiliser une méthode unique pour l'ensemble de l'URI, car il n'y a pas de solution parfaite (jusqu'à présent).
Comme vous le voyez & a pas échappé à "Mon Blog & Votre Blog". Nous avons besoin d'utiliser un autre moyen de s'échapper pour la requête params, où les utilisateurs peuvent mettre les différents caractères qui ont une signification particulière dans les Url. Entrez l'URL de l'encodage. Encoder doit être utilisé pour tous les "suspects" valeur de la requête, similaire à ce que ERB::Util.url_encode n':

ERB::Util.url_encode "My Blod & Your Blog"
# => "My%20Blod%20%26%20Your%20Blog""

C'est cool mais nous avons déjà requis Adressable:

uri = Addressable::URI.parse("http://www.go.com/foo")
# => #<Addressable::URI:0x186feb0 URI:http://www.go.com/foo>
uri.query_values = {title: "My Blog & Your Blog"}
uri.normalize.to_s
# => "http://www.go.com/foo?title=My%20Blog%20%26%20Your%20Blog"

Conclusion:

• Ne pas utiliser URI.escape ou similaire
• Utilisation CGI::escape si vous avez seulement besoin de formulaire échapper
• Si vous avez besoin de travailler avec les Uri, utilisez Adressable, il propose l'encodage de l'URL, formulaire d'encodage et normalise les Url.
• Si c'est un Rails de projet, découvrez "Comment puis-je l'URL d'échapper à une chaîne de caractères dans les Rails?"

CGI::escape est bon pour échapper segment de texte de sorte qu'ils peuvent être utilisés dans les url des paramètres de la requête (les chaînes après le '?'). Par exemple, si vous voulez avoir paramètre contenant des caractères barre oblique dans l'url, vous CGI::escape (en chaîne) d'abord, puis l'insérer dans l'url.

Cependant dans les Rails, vous n'aurez probablement pas l'utiliser directement. En général, vous utilisez hash.to_param, qui utilisera CGI::escape sous le capot.

---

URI::escape est bon pour échapper à une url qui n'a pas échappé correctement. Par exemple, certains sites de sortie de mal/non échappés url dans leur balise d'ancrage. Si votre programme, utilisez ces url pour récupérer plus de ressources, OpenURI va se plaindre que les url ne sont pas valides. Vous devez URI::escape ces pour en faire une url valide. Il est donc utilisé pour échapper à l'ensemble de la chaîne URI pour le rendre bon. Dans ma parole URI::ne pas encoder rend une url lisible par l'homme, et URI::échapper à fait valable pour les navigateurs.

Ce sont mes profane du terme et n'hésitez pas à corriger ceux-ci.

CGI.escape est pour échapper à une URL de la valeur dans la chaîne de requête. Tous les caractères qui ne tombent pas dans l'ALPHA, le CHIFFRE, '_', '-', '.' et ' jeu de caractères sont échappés.

Mais que ferait une URL incorrecte, depuis une url doit avoir '/', ':', '?', '[', '&', ' = ' et ';'. Peut-être plus que je ne peux pas penser à du haut de ma tête.

URI.échapper à feuilles URL caractères seul, et essaie de trouver la chaîne de requête de clés et de valeurs à s'échapper. Cependant ce ne peut vraiment pas compter sur puisque les valeurs peuvent avoir toutes sortes de personnages de la prévention d'une échappatoire facile. Fondamentalement, c'est trop tard. Mais si l'URL peut être dépendait pour être simple (pas de '&'s et '='s etc dans les valeurs), cette fonction peut être utilisée pour échapper peut-être illisible ou des caractères illégaux.

En général-toujours utiliser des CGI.échapper à l'individu de clés et de valeurs avant de se joindre à eux avec des "& " et en ajoutant après le '?'.