Je connais des moyens de vérifier si le paramètre n'est pas nul lequel est correct et le plus populaire? Quelle est la différence entre eux?
Je préférerais utiliser si param [: quelque_value] car il est le plus simple et shorterst.
4 Réponses :
Cela dépend de ce que vous voulez faire, mais j'utilise généralement ces formulaires: bien sûr que tous ne fonctionnent que si le paramètre ne peut pas être faux . Dans ce cas, j'irais pour le sauf si Param [: quelque_value] .nil? version.
Bien sûr, toutes ne fonctionnent que si le paramètre ne peut pas être faux . Ah bon? Je ne le savais pas. C'est-à-dire que si l'URL contient site.com/article/19.html?some_article=false puis si param [: Quelque_value] ne sera pas exécuté, non?
Non, Certains_article devrait être la chaîne "false" alors. Mais j'ai vu des gens à tourner cela en booléens et à le stocker dans parames` ...
Voici quelques différences entre note que Alors, lequel choisir? Bien sûr, cela dépend de ce que vous voulez, mais lorsque vous évaluez les paramètres [: quelque_value], vous voudrez généralement vérifier non seulement que ce n'est pas nul, mais aussi s'il s'agit d'une chaîne vide. Ces deux sont couverts par nil? , vide? et présent? : présent? traduit par pas nul et pas vide . Notez également que, tandis que nil? est fourni par RUBY, vide? et présents? Les aides sont fournis par des rails. présent? .
Ensuite, quelle est la différence entre si param [: quelque_value] et si! Param [: quelque_value] .nil? ?
Si param [: Quelque_value] est FALSE , si la valeur renvoyée est nil ou false , ! Param [: Certain_value] .nil? D'autre part est FALSE Si et uniquement si ( iff ) param [: Quelque_value] Retours nil .
Juste pour noter, présent? traduit par non vide? . Blank? elle-même vérifie la nulle.
Les cas pertinents sont:
nil pour la clé
- Le hachage a la chaîne vide de valeur (
"" ") ou du tableau vide ( [] ) pour la clé
- Le hachage a une autre valeur pour la clé
Selon l'endroit où vous souhaitez dessiner la ligne, utilisez la méthode appropriée.
- 1 vs. 2, 3, 4:
! Param.key? (: Quelqu'un)
- 1, 2 vs. 3, 4:
param [: quelque_value] .nil?
- 1, 2, 3 vs. 4:
param [: quelque_value] .blank?
- 2, 3, 4 vs. 1:
param.key? (: Quelqu'un)
- 3, 4 vs. 1, 2:
param [: quelque_value]
- 4 vs. 1, 2, 3:
param [: quelque_value] .present?
Mais si vous travaillez avec des données booléennes ( ( aussi, il pourrait être important de tester si la valeur est vraiment nulle ou si le combo de la valeur de clé n'est pas défini. si param [: elvalue] code> est le plus courant. true code>, false code>) la meilleure méthode
serait si! param [: quelque_value] .nil? code>, parce que: p> code> retourne le booléen Valeur, qui serait testée dans une instruction IF) p> clé? (clé) code> Est-ce que pour vous. P> >> hash ={foo:nil}
>> hash[:foo]
=> nil
>> hash[:not_there]
=> nil
>> hash.key?(:foo)
=> true
>> hash.key?(:not_there)
=> false
Lequel est correct dépend de votre intention alors qu'est-ce que vous essayez spécifiquement de faire? Ces quatre ne sont pas équivalents, il y a des différences subtiles là-bas. Et parfois, vous pourriez dire que vous voulez dire
param.has_key? : quelque_value .