Comment puis-je vérifier le paramètre “param[:some_value]” en Ruby

Je sais que certaines façons de vérifier si le paramètre n'est pas nul,

if param[:some_value]
if param[:some_value].present?
if !param[:some_value].nil?    #unless param[:some_value].nil? 
if !param[:some_value].blank?  #unless param[:some_value].blank?

Qui est correct et le plus populaire? Quelle est la différence entre eux?
Je préfère utiliser if param[:some_value] parce que c'est plus simple et shorterst.

Lequel est correct dépend de votre intention si ce qui sont que vous essayez de faire? Ces quatre ne sont pas équivalents, il existe des différences subtiles. Et parfois, vous pouvez réellement dire param.has_key? :some_value.

OriginalL'auteur Alexandre | 2012-08-19

  1. 15

    Voici quelques différences entre nil?, blank? et present?:

    >> "".nil?
=> false
>> "".blank?
=> true
>> "".present?
=> false
>> " ".nil?
=> false
>> " ".blank?
=> true
>> " ".present?
=> false

    Noter que present? se traduit par not nil and not blank. Notez également que tout nil? est fourni par Ruby, blank? et present? sont des aides fournies par les Rails.

    Alors, lequel choisir? Cela dépend de ce que vous voulez, bien sûr, mais lors de l'évaluation des params[:some_value], vous voulez généralement à vérifier non seulement qu'il n'est pas nul, mais également si c'est une chaîne vide. Ces deux sont couverts par present?.

    Alors quelle est la différence entre if param[:some_value] et if !param[:some_value].nil? ?
    if param[:some_value] est false, si la valeur renvoyée est nil ou false, !param[:some_value].nil? sur l'autre main est false si et seulement si (forum) param[:some_value] retourne nil.
    Juste pour remarque, present? se traduit par not blank?. blank? se vérifie pour les nuls.
    Si présent? = (!vide?)

    OriginalL'auteur Shailen Tuli

  2. 3

    Les cas pertinents sont:

    1. Le manque de hachage de la clé (et sa valeur)
    2. La valeur de hachage a la valeur nil pour la clé
    3. La valeur de hachage a la valeur de chaîne vide ("") ou le tableau vide ([]) pour la clé
    4. La valeur de hachage a une autre valeur pour la clé

    Selon l'endroit où vous voulez dessiner la ligne, utilisez la méthode appropriée.

    • 1 vs 2, 3, 4: !param.key?(:some_value)
    • 1, 2 vs 3, 4: param[:some_value].nil?
    • 1, 2, 3, et 4: param[:some_value].blank?
    • 2, 3, 4 vs 1: param.key?(:some_value)
    • 3, 4 vs 1, 2: param[:some_value]
    • 4 vs 1, 2, 3: param[:some_value].present?

    OriginalL'auteur sawa

  3. 2

    if param[:some_value] est la plus commune.

    Mais si vous travaillez avec des données booléennes (true,false) la meilleure méthode
    serait if !param[:some_value].nil?, parce que:

    >> hash = {foo:false, bar:nil}

>> !! hash[:foo]
=> false
>> !! hash[:bar]
=> false

>> !! !hash[:foo].nil?
=> true
>> !! !hash[:bar].nil?
=> false

    (!! retourne la valeur booléenne, qui serait dans un test if)

    En outre, il pourrait être important de tester si la valeur est vraiment nul, ou si la clé-valeur de la combo n'est pas défini. key?(key) fait pour vous.

    >> hash ={foo:nil}

>> hash[:foo]
=> nil
>> hash[:not_there]
=> nil

>> hash.key?(:foo)
=> true
>> hash.key?(:not_there)
=> false

    OriginalL'auteur robustus

  4. 1

    Cela dépend de ce que vous voulez faire, mais j'ai généralement l'utilisation de ces formes:

    if param[:some_value]
  ...
end

# and
param[:some_value] && something
# or
param[:some_value] || somethinn

    Bien entendu, tous ne fonctionnent que si le paramètre ne peut pas être false. Dans ce cas, j'irais pour le unless param[:some_value].nil? version.

    Of course all of them only work if the parameter can't be false. Vraiment? Je ne le savais pas. C'est, si l'url contient site.com/article/19.html?some_article=false puis if param[:some_value] ne sera pas exécutée, à droite?
    Non, some_article devrait être la chaîne "false" then. But I've seen people turn that into booleans and store it back in params`...

    OriginalL'auteur Michael Kohl