Vérifier si une variable n'est pas nulle et non nulle en rubis

J'utilise le code suivant pour vérifier si une variable n'est pas nulle et non nulle

if(discount != nil && discount != 0) 
  ...
end

Y a-t-il une meilleure manière de faire cela?

sauf discount.nil? || remise == 0
  # ...
fin

class Object
  def nil_zero?
    self.nil? || self == 0
  end
end

# which lets you do
nil.nil_zero? # returns true
0.nil_zero?   # returns true
1.nil_zero?   # returns false
"a".nil_zero? # returns false

unless discount.nil_zero?
  # do stuff...
end

Méfiez-vous des avertissements habituels ... grande puissance / responsabilité, correction de singe menant au côté obscur, etc.

ok, après 5 ans se sont écoulés ....

if discount.try :nonzero?
  ...
end

Il est important de noter qu'il tryest défini dans la gemme ActiveSupport, il n'est donc pas disponible en rubis uni.

sauf si [nul, 0] .inclut? (remise) 
  # ...
fin

À partir de Ruby 2.3.0, vous pouvez combiner l'opérateur de navigation sécurisée ( &.) avec Numeric#nonzero?. &.renvoie nilsi l'instance était nilet nonzero?- si le nombre était 0:

if discount&.nonzero?
  # ...
end

Ou suffixe:

do_something if discount&.nonzero?

if (discount||0) != 0
  #...
end

Vous pouvez faire ceci:

if (!discount.nil? && !discount.zero?)

L'ordre est important ici, car s'il l' discountest nil, alors il n'aura pas de zero?méthode. L'évaluation des courts-circuits de Ruby devrait cependant l'empêcher d'essayer d'évaluer discount.zero?si discountc'est le cas nil.

Vous pouvez convertir votre ligne vide en valeur entière et vérifier zéro?.

"".to_i.zero? => true
nil.to_i.zero? => true

if discount and discount != 0
  ..
end

mise à jour, il sera falsepourdiscount = false

Vous pouvez profiter de la méthode NilClassfournie #to_i, qui renverra zéro pour les nilvaleurs:

unless discount.to_i.zero?
  # Code here
end

S'il discountpeut s'agir de nombres fractionnaires, vous pouvez utiliser à la #to_fplace, pour éviter que le nombre ne soit arrondi à zéro.

def is_nil_and_zero(data)
     data.blank? || data == 0 
end  

Si nous passons "" il retournera faux alors vide? renvoie vrai. Il en va de même lorsque data = false blank? renvoie true pour nil, false, vide ou une chaîne d'espaces. Il est donc préférable d'utiliser des blancs? pour éviter également les chaînes vides.

Lorsque je traite un enregistrement de base de données , j'aime initialiser toutes les valeurs vides avec 0, en utilisant l'aide à la migration:

add_column :products, :price, :integer, default: 0

Vous pouvez initialiser la remise à 0 tant que votre code est garanti de ne pas essayer de l'utiliser avant son initialisation. Cela supprimerait un chèque, je suppose, je ne peux penser à rien d'autre.

if discount.nil? || discount == 0
  [do something]
end

Je préfère utiliser une approche plus propre:

val.to_i.zero?

val.to_irenverra un 0si val est un nil,

après cela, tout ce que nous devons faire est de vérifier si la valeur finale est un zéro .

La solution alternative consiste à utiliser les raffinements, comme ceci:

module Nothingness
  refine Numeric do
    alias_method :nothing?, :zero?
  end

  refine NilClass do
    alias_method :nothing?, :nil?
  end
end

using Nothingness

if discount.nothing?
  # do something
end

Je crois que ce qui suit est assez bon pour le code ruby. Je ne pense pas que je pourrais écrire un test unitaire qui montre une différence entre cela et l'original.

if discount != 0
end