Cómo probar si existen parámetros en rails

Soy un fan de

params[:one].present?

Solo porque mantiene la forma params[sym] para que sea más fácil de leer.

¿Usar espacio en blanco? http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

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

Devolverá true si está vacío o nil

También... eso no funcionará si está probando valores booleanos.. desde

>> false.blank?
=> true

En ese caso se podría utilizar

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

Simple como pastel:

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

Puedes escribirlo de forma más sucinta como lo siguiente:

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

Una forma muy sencilla de proporcionar valores predeterminados a sus parámetros: params[:foo] ||= 'default value'

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

Acabo de leer esto en las clases de RubyInRails http://api.rubyonrails.org/classes/Object.html#method-i-blank-3F

Puede usar el método blank? que es equivalente a params[:one].nil? || params[:one].empty?

(p. ej.)

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

También puedes hacer lo siguiente:

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

Tiendo a usar la solución anterior cuando quiero verificar más de uno o dos parámetros.

.values_at devuelve y array con nil en el lugar de cualquier clave param indefinida. i. e:

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

Devolverá lo siguiente:

[3,nil,5] 

.incluye?(nil) luego comprueba la matriz para cualquier valor nil. Devolverá true si el array incluye nil.

En algunos casos es posible que también desee comprobar que los parámetros no contienen y están vacíos cadena con valor falso.

Puede manejar esos valores agregando el siguiente código encima de la instrucción unless.

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

Todo en conjunto se vería así:

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

Es importante tener en cuenta que delete_if modificará tu hash/params, así que úsalo con precaución.

La solución anterior claramente requiere un poco más de trabajo para configurarla, pero vale la pena si está comprobando más de uno o dos parámetros.

Esto es lo que hago,

before_action :validate_presence

Y luego los siguientes métodos:

    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

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

También puede comprobar si los parámetros están vacíos usando params[:two].vacío

Intento una respuesta tardía, pero de lejos:

Si desea saber si se establecen valores en un hash (cualquiera), all above responde a true, dependiendo de su punto de vista.

Si quieres probar tu (GET/POST..) params, usted debe utilizar algo más especial a lo que usted espera que sea el valor de params[:one], algo como

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

Ignorando los parámetros (GET / POST) como si no estuvieran configurados, si no encajan como se espera

Solo un if params[:one] con o sin detección nil/true es un paso para abrir su página para hackear, porque, por lo general, es el siguiente paso para usar algo como select ... where params[:one] ..., si esto es intencionado o no, activo o dentro o después de un marco.

Una respuesta o solo una pista

Simplemente juntó esto para el mismo 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 primera línea comprueba si nuestras claves de destino están presentes en las claves de los parámetros usando el subconjunto

Además de las respuestas anteriores: has_key? y has_value? tienen alternativas más cortas en forma de key? y value?. Ruby team también sugiere usar alternativas más cortas, pero para legibilidad algunos podrían preferir versiones más largas de estos métodos.

Por lo tanto, en su caso sería algo como

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

NB! .key? simplemente comprobará si la clave existe e ignora el valor posible. Para 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