So testen Sie, ob Parameter in Schienen vorhanden sind

Ich verwende eine IF-Anweisung in Ruby on Rails, um zu testen, ob Anforderungsparameter festgelegt sind. Unabhängig davon, ob beide Parameter eingestellt sind oder nicht, wird der erste Teil des folgenden Blocks ausgelöst. Wie kann ich diesen Teil NUR auslösen lassen, wenn sowohl params [: one] als auch params [: two] gesetzt sind?

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

Sie wollen has_key?:

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

Nur das Überprüfen if(params[:one])wird durch einen "da aber null" und "da aber falsch" Wert getäuscht und Sie fragen nach der Existenz. Möglicherweise müssen Sie unterscheiden:

• Überhaupt nicht da.
• Da aber nil.
• Da aber false.
• Da aber eine leere Schnur.

auch. Schwer zu sagen ohne weitere Details Ihrer genauen Situation.

Ich bin ein Fan von

params[:one].present?

Nur weil das params[sym]Formular so bleibt , dass es leichter zu lesen ist.

leer verwenden? http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

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

wird true zurückgeben, wenn es leer oder null ist

auch ... das wird nicht funktionieren, wenn Sie boolesche Werte testen .. da

>> false.blank?
=> true

in diesem Fall könnten Sie verwenden

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

Sie können es prägnanter wie folgt schreiben:

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

Einfach wie Torte:

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

Eine sehr einfache Möglichkeit, Ihren Parametern Standardwerte bereitzustellen: params[:foo] ||= 'default value'

Ich habe dies gerade in den RubyInRails-Klassen http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F gelesen

Sie können eine blank?Methode verwenden, die äquivalent zu istparams[:one].nil? || params[:one].empty?

(z.B)

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

Sie können auch Folgendes tun:

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

Ich neige dazu, die obige Lösung zu verwenden, wenn ich mehr als ein oder zwei Parameter überprüfen möchte.

.values_at gibt ein Array mit nil anstelle eines undefinierten Parameterschlüssels zurück. dh:

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

wird folgendes zurückgeben:

[3,nil,5] 

.includes? (nil) überprüft dann das Array auf Nullwerte. Es wird true zurückgegeben, wenn das Array nil enthält.

In einigen Fällen möchten Sie möglicherweise auch überprüfen, ob Parameter keine leere Zeichenfolge für einen falschen Wert enthalten.

Sie können mit diesen Werten umgehen, indem Sie den folgenden Code über der if-Anweisung hinzufügen.

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

Alles in allem würde es so aussehen:

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

Es ist wichtig zu beachten, dass delete_if Ihre Hash / Parameter ändert. Verwenden Sie sie daher mit Vorsicht.

Die obige Lösung erfordert eindeutig etwas mehr Arbeit beim Einrichten, lohnt sich jedoch, wenn Sie mehr als nur ein oder zwei Parameter überprüfen.

Zusätzlich zu früheren Antworten: has_key?und has_value?haben kürzere Alternativen in Form von key?und value?. Das Ruby-Team schlägt auch die Verwendung kürzerer Alternativen vor. Aus Gründen der Lesbarkeit bevorzugen einige jedoch möglicherweise längere Versionen dieser Methoden.

Daher wäre es in Ihrem Fall so etwas wie

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

NB! .key?prüft nur, ob der Schlüssel vorhanden ist und ignoriert den möglichen Wert. Zum Beispiel:

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

Folgendes mache ich:

before_action :validate_presence

und dann folgende Methoden:

    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

Einfach für das gleiche Problem zusammengesetzt:

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

In der ersten Zeile wird mithilfe der Teilmenge <= überprüft, ob unsere Zielschlüssel in den Parametern vorhanden sind. Operator. Enumerable.all? Standardmäßig wird ohne Block false zurückgegeben, wenn ein Wert null oder falsch ist.

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

Sie können auch überprüfen, ob die Parameter leer sind, indem Sie params [: two] .empty verwenden

Ich versuche eine späte, aber weitsichtige Antwort:

Wenn Sie wissen möchten, ob Werte in einem (beliebigen) Hash festgelegt sind, antworten alle oben genannten Antworten je nach Sichtweise mit true.

Wenn Sie Ihre (GET / POST ..) Parameter testen möchten, sollten Sie etwas Besonderes verwenden, das dem Wert entspricht params[:one], den Sie erwarten, beispielsweise

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

Ignorieren von Parametern (GET / POST), als ob sie nicht gesetzt wären, wenn sie nicht wie erwartet passen

Nur eine if params[:one] Erkennung mit oder ohne Null / Wahr-Erkennung ist ein Schritt, um Ihre Seite zum Hacken zu öffnen, da dies normalerweise der nächste Schritt ist, um so etwas wie select ... where params[:one] ..., ob beabsichtigt oder nicht, aktiv oder innerhalb oder nach einem Framework zu verwenden.

eine Antwort oder nur ein Hinweis