Verifica se una variabile non è nulla e non è zero in rubino

Sto usando il seguente codice per verificare se una variabile non è nulla e non è zero

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

C'è un modo migliore per farlo?

a meno che discount.nil? || sconto == 0
  # ...
fine

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

Attenzione ai soliti disclaimer ... grande potere / responsabilità, patching delle scimmie che portano al lato oscuro ecc.

ok, dopo 5 anni sono passati ....

if discount.try :nonzero?
  ...
end

È importante notare che tryè definito nella gemma ActiveSupport, quindi non è disponibile in rubino semplice.

salvo [nil, 0] .include? (sconto) 
  # ...
fine

Da Ruby 2.3.0 in poi, è possibile combinare l'operatore di navigazione sicura ( &.) con Numeric#nonzero?. &.ritorna nilse l'istanza era nile nonzero?- se il numero era 0:

if discount&.nonzero?
  # ...
end

O postfisso:

do_something if discount&.nonzero?

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

Potresti farlo:

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

L'ordine è importante qui, perché se lo discountè nil, allora non avrà un zero?metodo. La valutazione del corto circuito di Ruby dovrebbe impedirgli di provare a valutare discount.zero?, se lo discountè nil.

È possibile convertire la riga vuota in valore intero e controllare zero ?.

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

if discount and discount != 0
  ..
end

aggiornamento, lo farà falseperdiscount = false

Puoi sfruttare il metodo NilClassfornito #to_i, che restituirà zero per i nilvalori:

unless discount.to_i.zero?
  # Code here
end

Se discountpossono essere numeri frazionari, è possibile utilizzare #to_finvece, per evitare che il numero venga arrotondato a zero.

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

Se passiamo "" restituirà false mentre è vuoto? ritorna vero. Lo stesso vale quando data = false blank? restituisce vero per zero, falso, vuoto o una stringa di spazi bianchi. Quindi è meglio usare il bianco? metodo per evitare anche stringhe vuote.

Quando ho a che fare con un record di database , mi piace inizializzare tutti i valori vuoti con 0, usando l'helper di migrazione:

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

È possibile inizializzare lo sconto su 0 a condizione che il codice sia garantito per non tentare di utilizzarlo prima che venga inizializzato. Ciò toglierebbe un controllo, suppongo, non riesco a pensare ad altro.

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

Preferisco usare un approccio più pulito:

val.to_i.zero?

val.to_irestituirà a 0se val è a nil,

dopo ciò, tutto ciò che dobbiamo fare è verificare se il valore finale è zero .

La soluzione alternativa è utilizzare i perfezionamenti, in questo modo:

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

Credo che quanto segue sia abbastanza buono per il codice ruby. Non credo di poter scrivere un test unitario che mostri alcuna differenza tra questo e l'originale.

if discount != 0
end