C'est assez facile avec un hash simple comme
{:a => "a", :b => "b"}
qui se traduirait par
"a=a&b=b"
Mais que faites-vous avec quelque chose de plus complexe comme
{:a => "a", :b => ["c", "d", "e"]}
qui devrait se traduire par
"a=a&b[0]=c&b[1]=d&b[2]=e"
Ou pire encore (que faire) avec quelque chose comme:
{:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]
Merci pour l'aide très appréciée avec ça!
Mise à jour: Cette fonctionnalité a été supprimée de la gemme.
Julien, ta réponse est bonne, et je l'ai empruntée sans vergogne, mais elle n'échappe pas correctement aux caractères réservés, et il y a quelques autres cas Edge où elle tombe en panne.
require "addressable/uri"
uri = Addressable::URI.new
uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
uri.query
# => "a=a&b[0]=c&b[1]=d&b[2]=e"
uri.query_values = {:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}]}
uri.query
# => "a=a&b[0][c]=c&b[0][d]=d&b[1][e]=e&b[1][f]=f"
uri.query_values = {:a => "a", :b => {:c => "c", :d => "d"}}
uri.query
# => "a=a&b[c]=c&b[d]=d"
uri.query_values = {:a => "a", :b => {:c => "c", :d => true}}
uri.query
# => "a=a&b[c]=c&b[d]"
uri.query_values = {:a => "a", :b => {:c => "c", :d => true}, :e => []}
uri.query
# => "a=a&b[c]=c&b[d]"
La gemme est ' adressable '
gem install addressable
Pour les hachages de base non imbriqués, Rails/ActiveSupport a Object#to_query
.
>> {:a => "a", :b => ["c", "d", "e"]}.to_query
=> "a=a&b%5B%5D=c&b%5B%5D=d&b%5B%5D=e"
>> CGI.unescape({:a => "a", :b => ["c", "d", "e"]}.to_query)
=> "a=a&b[]=c&b[]=d&b[]=e"
http://api.rubyonrails.org/classes/Object.html#method-i-to_query
Si vous utilisez Ruby 1.9.2 ou une version ultérieure, vous pouvez utiliser URI.encode_www_form
si vous n'avez pas besoin de tableaux.
Par exemple. (de la Ruby docs en 1.9.3):
URI.encode_www_form([["q", "Ruby"], ["lang", "en"]])
#=> "q=Ruby&lang=en"
URI.encode_www_form("q" => "Ruby", "lang" => "en")
#=> "q=Ruby&lang=en"
URI.encode_www_form("q" => ["Ruby", "Perl"], "lang" => "en")
#=> "q=Ruby&q=Perl&lang=en"
URI.encode_www_form([["q", "Ruby"], ["q", "Perl"], ["lang", "en"]])
#=> "q=Ruby&q=Perl&lang=en"
Vous remarquerez que les valeurs de tableau ne sont pas définies avec des noms de clé contenant []
comme si nous étions tous habitués aux chaînes de requête. La spécification que encode_www_form
utilise correspond à la définition HTML5 de application/x-www-form-urlencoded
Les données.
Il existe un moyen beaucoup plus simple de le faire si vous utilisez Rails: http://apidock.com/Rails/ActiveSupport/CoreExtensions/Hash/to_query
Alors tu pourrais faire:
{:a => "a", :b => "b"}.to_query
Nul besoin de charger le ActiveSupport gonflé ou de rouler le vôtre, vous pouvez utiliser Rack::Utils.build_query
et Rack::Utils.build_nested_query
. Voici un article de blog qui donne un bon exemple:
require 'rack'
Rack::Utils.build_query(
authorization_token: "foo",
access_level: "moderator",
previous: "index"
)
# => "authorization_token=foo&access_level=moderator&previous=index"
Il gère même les tableaux:
Rack::Utils.build_query( {:a => "a", :b => ["c", "d", "e"]} )
# => "a=a&b=c&b=d&b=e"
Rack::Utils.parse_query _
# => {"a"=>"a", "b"=>["c", "d", "e"]}
Ou les choses plus difficiles imbriquées:
Rack::Utils.build_nested_query( {:a => "a", :b => [{:c => "c", :d => "d"}, {:e => "e", :f => "f"}] } )
# => "a=a&b[][c]=c&b[][d]=d&b[][e]=e&b[][f]=f"
Rack::Utils.parse_nested_query _
# => {"a"=>"a", "b"=>[{"c"=>"c", "d"=>"d", "e"=>"e", "f"=>"f"}]}
Voler de Merb:
# File merb/core_ext/hash.rb, line 87
def to_params
params = ''
stack = []
each do |k, v|
if v.is_a?(Hash)
stack << [k,v]
else
params << "#{k}=#{v}&"
end
end
stack.each do |parent, hash|
hash.each do |k, v|
if v.is_a?(Hash)
stack << ["#{parent}[#{k}]", v]
else
params << "#{parent}[#{k}]=#{v}&"
end
end
end
params.chop! # trailing &
params
end
Voir http://noobkit.com/show/Ruby/gems/development/merb/hash/to_params.html
Voici un exemple très simple si vous avez seulement besoin de supporter des chaînes de requête simples ASCII clé/valeur):
hash = {"foo" => "bar", "fooz" => 123}
# => {"foo"=>"bar", "fooz"=>123}
query_string = hash.to_a.map { |x| "#{x[0]}=#{x[1]}" }.join("&")
# => "foo=bar&fooz=123"
class Hash
def to_params
params = ''
stack = []
each do |k, v|
if v.is_a?(Hash)
stack << [k,v]
elsif v.is_a?(Array)
stack << [k,Hash.from_array(v)]
else
params << "#{k}=#{v}&"
end
end
stack.each do |parent, hash|
hash.each do |k, v|
if v.is_a?(Hash)
stack << ["#{parent}[#{k}]", v]
else
params << "#{parent}[#{k}]=#{v}&"
end
end
end
params.chop!
params
end
def self.from_array(array = [])
h = Hash.new
array.size.times do |t|
h[t] = array[t]
end
h
end
end
{:a=>"a", :b=>"b", :c=>"c"}.map{ |x,v| "#{x}=#{v}" }.reduce{|x,v| "#{x}&#{v}" }
"a=a&b=b&c=c"
Voici un autre moyen. Pour des requêtes simples.
Je sais que c'est une vieille question, mais je voulais simplement poster ce morceau de code car je ne pouvais pas trouver un simple joyau pour effectuer cette tâche à ma place.
module QueryParams
def self.encode(value, key = nil)
case value
when Hash then value.map { |k,v| encode(v, append_key(key,k)) }.join('&')
when Array then value.map { |v| encode(v, "#{key}[]") }.join('&')
when nil then ''
else
"#{key}=#{CGI.escape(value.to_s)}"
end
end
private
def self.append_key(root_key, key)
root_key.nil? ? key : "#{root_key}[#{key.to_s}]"
end
end
Roulé comme une pierre précieuse ici: https://github.com/simen/queryparams
Encore une autre réponse, il s’avère que c’est:
require 'uri'
URI.encode_www_form({"one" => "value with space", "two" => ["v1", "v2"]})
# => => "one=value+with+space&two=v1&two=v2"
Notez qu'il échappe aux espaces en tant que "+", ce qui peut être ou ne pas être techniquement correct pour les URL/URI. Tout devient très déroutant.
La meilleure approche consiste à utiliser Hash.to_params, qui fonctionne bien avec les tableaux.
{a: 1, b: [1,2,3]}.to_param
"a=1&b[]=1&b[]=2&b[]=3"
require 'uri'
class Hash
def to_query_hash(key)
reduce({}) do |h, (k, v)|
new_key = key.nil? ? k : "#{key}[#{k}]"
v = Hash[v.each_with_index.to_a.map(&:reverse)] if v.is_a?(Array)
if v.is_a?(Hash)
h.merge!(v.to_query_hash(new_key))
else
h[new_key] = v
end
h
end
end
def to_query(key = nil)
URI.encode_www_form(to_query_hash(key))
end
end
2.4.2 :019 > {:a => "a", :b => "b"}.to_query_hash(nil)
=> {:a=>"a", :b=>"b"}
2.4.2 :020 > {:a => "a", :b => "b"}.to_query
=> "a=a&b=b"
2.4.2 :021 > {:a => "a", :b => ["c", "d", "e"]}.to_query_hash(nil)
=> {:a=>"a", "b[0]"=>"c", "b[1]"=>"d", "b[2]"=>"e"}
2.4.2 :022 > {:a => "a", :b => ["c", "d", "e"]}.to_query
=> "a=a&b%5B0%5D=c&b%5B1%5D=d&b%5B2%5D=e"
J'aime utiliser ce petit bijou:
https://rubygems.org/gems/php_http_build_query
Exemple d'utilisation:
puts PHP.http_build_query({"a"=>"b","c"=>"d","e"=>[{"hello"=>"world","bah"=>"black"},{"hello"=>"world","bah"=>"black"}]})
# a=b&c=d&e%5B0%5D%5Bbah%5D=black&e%5B0%5D%5Bhello%5D=world&e%5B1%5D%5Bbah%5D=black&e%5B1%5D%5Bhello%5D=world