Comment tester si des paramètres existent dans les rails

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

if (defined? params[:one]) && (defined? params[:two])
 ... do something ...
elsif (defined? params[:one])
 ... do something ...
end

Vous voulez has_key?:

if(params.has_key?(:one) && params.has_key?(:two))

La simple vérification if(params[:one])sera trompée 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.
• Là mais une chaîne vide.

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

Je suis un fan de

params[:one].present?

Simplement parce qu'il conserve le params[sym]formulaire pour qu'il soit plus facile à lire.

utiliser du 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 .. puisque

>> false.blank?
=> true

dans ce cas, vous pouvez utiliser

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

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

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

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

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

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

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

(par exemple)

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

Vous pouvez également effectuer les opérations suivantes:

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

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

.values_at renvoie un tableau avec nil à la place de toute clé de paramètre non définie. c'est à dire:

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

renverra ce qui suit:

[3,nil,5] 

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

Dans certains cas, vous pouvez é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 sauf.

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 hachage / paramètres, utilisez donc avec prudence.

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

En plus des réponses précédentes: has_key?et has_value?ont des alternatives plus courtes sous forme de key?et value?. L'équipe Ruby suggère également d' utiliser des alternatives plus courtes, mais pour plus de lisibilité certains pourraient encore préférer 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?vérifiera simplement si la clé existe et ignore la valeur possible. Par exemple:

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

Voilà ce que je fais

before_action :validate_presence

puis les 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

Juste reconstitué ceci 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 en utilisant le sous-ensemble <=? opérateur. Enumerable.all? sans bloc par défaut renvoie false si une valeur est nulle ou fausse.

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

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

J'essaye une réponse tardive, mais de loin:

Si vous voulez savoir si les valeurs d'un hachage (quelconque) sont définies, tout ce qui précède répond à un vrai, 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 d'être la valeur params[:one], quelque chose comme

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

ignorer le paramètre (GET / POST) comme s'ils n'étaient pas définis, s'ils ne correspondent pas comme prévu

juste une if params[:one] détection avec ou sans nil / true est une étape pour ouvrir votre page pour le piratage, car c'est généralement la prochaine étape d'utiliser quelque chose commeselect ... 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