web-dev-qa-db-fra.com

Comment vérifier si des paramètres existent dans rails

J'utilise une instruction IF dans Ruby sur Rails pour essayer de tester si les paramètres de demande sont définis. Que les deux paramètres soient définis ou non, la première partie de ce qui suit si le bloc est déclenché. Comment puis-je faire que cette partie soit déclenchée UNIQUEMENT si les paramètres params [: one] et params [: two] sont définis?

if (defined? params[:one]) && (defined? params[:two])
 ... do something ...
elsif (defined? params[:one])
 ... do something ...
end
ruby-on-railsruby
173
Darren

Vous voulez has_key? :

_if(params.has_key?(:one) && params.has_key?(:two))
_

Le simple fait de vérifier if(params[:one]) va se laisser berner par une valeur "là mais nul" et "là mais faux" et vous posez des questions sur l'existence. Vous devrez peut-être différencier:

  • Pas du tout.
  • Là mais nil.
  • Là mais false.
  • Il n'y a qu'une chaîne vide.

ainsi que. Difficile à dire sans plus de détails sur votre situation précise.

330
mu is too short

Je suis un fan de

params[:one].present?

Simplement parce que la forme params[sym] est conservée, ce qui la rend plus facile à lire.

81
netricate

utiliser en blanc? http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

unless params[:one].blank? && params[:two].blank?

retournera vrai si c'est vide ou nul

aussi ... cela ne fonctionnera pas si vous testez des valeurs booléennes .. depuis

>> false.blank?
=> true

dans ce cas, vous pouvez utiliser

unless params[:one].to_s.blank? && params[:two].to_s.blank?
21
Orlando

Vous pouvez l'écrire plus succinctement comme suit:

required = [:one, :two, :three]
if required.all? {|k| params.has_key? k}
  # here you know params has all the keys defined in required array
else
  ...
end
13
Zack Xu

Simple comme bonjour:

if !params[:one].nil? and !params[:two].nil?
  #do something...
elsif !params[:one].nil?
  #do something else...
elsif !params[:two].nil?
  #do something extraordinary...
end
9
Jacob Relkin

Un moyen très simple de fournir des valeurs par défaut à vos paramètres: params[:foo] ||= 'default value'

5
chrpes
if params[:one] && params[:two]
 ... do something ...
elsif params[:one]
 ... do something ...
end
5
fl00r

Je viens de lire ceci sur les classes RubyInRails http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

vous pouvez utiliser la méthode blank? qui est équivalente à params[:one].nil? || params[:one].empty?

(par exemple)

if params[:one].blank? 
  # do something if not exist
else
  # do something if exist
end
5
Basil Mariano

En plus des réponses précédentes: has_key? et has_value? ont alternatives plus courtes sous la forme de key? et value?. Ruby team aussi suggère en utilisant des alternatives plus courtes, mais pour lisibilité , certains préfèreront peut-être encore des versions plus longues de ces méthodes.

Par conséquent, dans votre cas, ce serait quelque chose comme

if params.key?(:one) && params.key?(:two)
  ... do something ...
elsif params.key?(:one)
  ... do something ...
end

NB! .key? va simplement vérifier si la clé existe et ignore la valeur possible. Pour ex:

2.3.3 :016 > a = {first: 1, second: nil, third: ''}
  => {:first=>1, :second=>nil, :third=>""}
2.3.3 :017 > puts "#{a.key?(:first)}, #{a.key?(:second)}, #{a.key?(:third), #{a.key?(:fourth)}}"
true, true, true, false
3
Andres Ehrenpreis

Vous pouvez également faire ce qui suit:

unless params.values_at(:one, :two, :three, :four).includes?(nil)
 ... excute code ..
end

J'ai tendance à utiliser la solution ci-dessus lorsque je souhaite vérifier plus d'un ou deux paramètres.

.values_at retourne et array avec nil à la place de toute clé param non définie. c'est à dire:

some_hash = {x:3, y:5}
some_hash.values_at(:x, :random, :y}

retournera ce qui suit:

[3,nil,5]

.includes? (nil) vérifie ensuite le tableau pour toutes les valeurs nil. Il renverra true si le tableau inclut nil.

Dans certains cas, vous voudrez peut-être également vérifier que les paramètres ne contiennent pas de chaîne vide sur une valeur fausse.

Vous pouvez gérer ces valeurs en ajoutant le code suivant au-dessus de l'instruction less.

params.delete_if{|key,value| value.blank?}

tous ensemble cela ressemblerait à ceci:

 params.delete_if{|key,value| value.blank?}
 unless params.values_at(:one, :two, :three, :four).includes?(nil)
   ... excute code ..
  end

Il est important de noter que delete_if modifiera votre hash/params, donc utilisez-le avec prudence.

La solution ci-dessus demande clairement un peu plus de travail à configurer mais en vaut la peine si vous vérifiez plus d'un ou deux paramètres.

3
Greg L

Je viens de reconstituer cela ensemble pour le même problème:

before_filter :validate_params

private

def validate_params
  return head :bad_request unless params_present?
end

def params_present?  
  Set.new(%w(one two three)) <= (Set.new(params.keys)) &&
  params.values.all?
end

la première ligne vérifie si nos clés cibles sont présentes dans les clés des paramètres à l'aide du sous-ensemble <=? opérateur. Enumerable.all? sans bloc par défaut renvoie false si l'une des valeurs est nulle ou false.

1
okthatsneat

Voici ce que je fais

before_action :validate_presence

et ensuite méthodes suivantes:

    def check_presence
  params[:param1].present? && params[:param2].present?
 end

 def validate_presence
  if !check_presence
    render json:  {
                      error:  {
                                message: "Bad Request, parameters missing.",
                                status: 500
                              }
                    }
  end
 end
1
Parth Modi

J'essaie en retard, mais de loin, réponds:

Si vous voulez savoir si les valeurs dans un (n'importe quel) hachage sont définies, toutes les réponses ci-dessus répondent à true, en fonction de leur point de vue.

Si vous voulez tester vos paramètres (GET/POST ..), vous devez utiliser quelque chose de plus spécial que ce que vous attendez comme valeur de params[:one], quelque chose comme:

if params[:one]~=/   / and  params[:two]~=/[a-z]xy/

ignorer le paramètre (GET/POST) comme si elles n'étaient pas définies, si elles ne correspondent pas comme prévu

juste un if params[:one] avec ou sans détection nil/true est une étape pour ouvrir votre page pour le piratage, car c'est généralement la prochaine étape pour utiliser quelque chose comme select ... where params[:one] ..., si cela est prévu ou non, actif ou dans ou après un cadre.

une réponse ou juste un indice

0
halfbit
if params[:one] && param[:two]
  ... excute code ..
end

Vous pouvez aussi vérifier si les paramètres sont vides en utilisant params [: two] .empty

0
Jason Yost