Come verificare se esistono parametri nei binari

Sto usando un'istruzione IF in Ruby on Rails per provare e verificare se sono impostati i parametri di richiesta. Indipendentemente dal fatto che siano impostati o meno entrambi i parametri, la prima parte di quanto segue se viene attivato il blocco. Come posso fare in modo che questa parte venga attivata SOLO se sono impostati sia params [: one] che params [: two]?

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

Tu vuoi has_key?:

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

Solo il controllo if(params[:one])verrà ingannato da un valore "lì ma zero" e "lì ma falso" e stai chiedendo l'esistenza. Potrebbe essere necessario differenziare:

• Niente affatto.
• Lì ma nil.
• Lì ma false.
• C'è solo una stringa vuota.

anche. Difficile a dirsi senza ulteriori dettagli sulla tua precisa situazione.

Sono un fan di

params[:one].present?

Solo perché mantiene il params[sym]modulo, quindi è più facile da leggere.

usare il bianco? http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

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

restituirà true se è vuoto o nullo

inoltre ... che non funzionerà se stai testando valori booleani .. da allora

>> false.blank?
=> true

in tal caso potresti usare

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

Puoi scriverlo in modo più succinto come il seguente:

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

Semplice come una torta:

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 modo molto semplice per fornire valori predefiniti ai tuoi parametri: params[:foo] ||= 'default value'

Ho appena letto questo sulle lezioni di RubyInRails http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

Puoi usare blank? metodo equivalente aparams[:one].nil? || params[:one].empty?

(per esempio)

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

Puoi anche fare quanto segue:

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

Tendo a utilizzare la soluzione di cui sopra quando voglio controllare più di uno o due parametri.

.values_at restituisce e array con zero al posto di qualsiasi chiave param non definita. vale a dire:

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

restituirà quanto segue:

[3,nil,5] 

.includes? (zero) quindi controlla l'array per eventuali valori nulli. Restituirà vero se l'array include zero.

In alcuni casi potresti anche voler verificare che i parametri non contengano e svuotino la stringa con un valore falso.

È possibile gestire tali valori aggiungendo il seguente codice sopra l'istruzione

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

tutti insieme sembrerebbe così:

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

È importante notare che delete_if modificherà il tuo hash / params, quindi usa con cautela.

La soluzione sopra richiede chiaramente un po 'più di lavoro per la configurazione, ma ne vale la pena se stai controllando più di uno o due parametri.

Oltre alle risposte precedenti: has_key?e has_value?hanno alternative più brevi in forma di key?e value?. Il team di Ruby suggerisce anche di utilizzare alternative più brevi, ma per leggibilità alcuni potrebbero ancora preferire versioni più lunghe di questi metodi.

Quindi nel tuo caso sarebbe qualcosa di simile

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

NB! .key?controllerà solo se esiste la chiave e ignora il valore possibile. Ad esempio:

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

Ecco cosa faccio

before_action :validate_presence

e quindi i seguenti metodi:

    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

Ho appena messo insieme questo per lo stesso problema:

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 prima riga controlla se le nostre chiavi target sono presenti nelle chiavi dei parametri usando il sottoinsieme <=? operatore. Enumerable.all? senza blocco per impostazione predefinita restituisce false se un valore è zero o falso.

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

Puoi anche verificare se i parametri sono vuoti usando params [: two] .empty

Provo una risposta in ritardo, ma da lontano vista:

Se vuoi sapere se sono impostati i valori in un (qualsiasi) hash, tutto quanto sopra risponde a true, a seconda del loro punto di vista.

Se vuoi testare i tuoi parametri (GET / POST ..), dovresti usare qualcosa di più speciale per quello che ti aspetti sia il valore params[:one], qualcosa come

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

ignorando il parametro (GET / POST) come se non fossero impostati, se non si adattano come previsto

solo un if params[:one] rilevamento con o senza zero / true è un passaggio per aprire la tua pagina per l'hacking, perché, in genere, è il passaggio successivo per utilizzare qualcosa di simile select ... where params[:one] ..., se questo è previsto o meno, attivo o all'interno o dopo un framework.

una risposta o solo un suggerimento