ruby-on-rails - que - ruby on rails tutorial

Cómo probar si los parámetros existen en los rieles

Question

Estoy usando una instrucción IF en Ruby on Rails para probar y probar si los parámetros de solicitud están establecidos. Independientemente de si se configuran ambos parámetros, la primera parte del siguiente si se activa el bloqueo. ¿Cómo puedo hacer que esta parte SÓLO se active si se configuran ambos params [: uno] y params [: dos]?

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

Answer 1

¿Quieres has_key? :

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

Simplemente verificando if(params[:one]) dejará engañar por un valor "there but nothing" y "there but false" y usted estará preguntando por la existencia. Es posible que deba diferenciar:

• No está allí en absoluto.
• No hay más
• Allí pero false
• Solo una cadena vacía.

también. Difícil de decir sin más detalles de su situación precisa.

Answer 2

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

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

(p.ej)

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

Answer 3

Además de las respuestas anteriores: has_key? y has_value? tener alternativas más cortas en forma de key? y value? . El equipo de Ruby también suggests usar alternativas más cortas, pero para la readability algunos podrían preferir versiones más largas de estos métodos.

Por lo tanto, en tu caso sería algo así como

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

¡NÓTESE BIEN! .key? simplemente comprobará si la clave existe e ignorará el valor posible. Por ejemplo:

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

Answer 4

Esto es lo que hago,

before_action :validate_presence

y luego siguiendo los 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

Answer 5

Intento una respuesta tardía, pero desde lejos:

Si desea saber si los valores en un hash (cualquiera) están configurados, todas las respuestas anteriores son verdaderas, dependiendo de su punto de vista.

Si desea probar sus parámetros (GET / POST ..), debe usar algo más especial para lo que espera que sea el valor de params[:one] , algo así como

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

ignorando el parámetro (GET / POST) como si no estuvieran configurados, si no encajan como se esperaba

solo if params[:one] con o sin detección nil / true es un paso para abrir su página para piratear, porque, típicamente, es el siguiente paso para usar algo como select ... where params[:one] ... , si está previsto o no, activo o dentro o después de un marco.

una respuesta o solo una pista

Answer 6

Puede escribirlo de manera más sucinta de la siguiente manera:

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

Answer 7

Simple como un 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

Answer 8

Solo reconstruí esto por 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 verifica si nuestras claves de destino están presentes en las claves de params usando el <= subconjunto? operador. Enumerable.all? sin bloque por defecto devuelve falso si cualquier valor es nulo o falso.

Answer 9

También puede hacer lo siguiente:

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

Tiendo a usar la solución anterior cuando deseo verificar más de uno o dos params.

.values_at devuelve y matriz con nil en el lugar de cualquier clave param indefinida. es decir:

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

devolverá lo siguiente:

[3,nil,5] 

.includes? (nil) luego verifica la matriz en busca de valores nulos. Volverá verdadero es que la matriz incluye nil.

En algunos casos, es posible que también desee verificar que los parámetros no contengan y vaciar cadenas en valores falsos.

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

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

todos juntos 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á sus hash / params, por lo que debe usarse con precaución.

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

Answer 10

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

Answer 11

soy un fan de

params[:one].present?

solo porque mantiene la forma params [sym] por lo que es más fácil de leer.

Answer 12

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

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

devolverá verdadero si está vacío o nulo

también ... eso no funcionará si está probando valores booleanos ... ya que

>> false.blank?
=> true

en ese caso podrías usar

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

Answer 13

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

También puede verificar si los parámetros están vacíos usando params [: dos] .empty

Answer 14

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