Esiste un modo migliore di controllare zero o lunghezza == 0 di una stringa in Ruby?

Esiste un modo migliore di quanto segue per verificare se una stringa è nulla O ha una lunghezza di 0 in Ruby?

if !my_string || my_string.length == 0
  return true
else
  return false
end

In C # c'è il pratico

string.IsNullOrEmpty(myString)

Qualcosa di simile a quello in Ruby?

Quando non sono preoccupato per le prestazioni, userò spesso questo:

if my_string.to_s == ''
  # It's nil or empty
end

Ci sono varie varianti, ovviamente ...

if my_string.to_s.strip.length == 0
  # It's nil, empty, or just whitespace
end

Se sei disposto a richiedere ActiveSupport, puoi semplicemente utilizzare il #blank?metodo, definito sia per NilClass che per String.

Mi piace farlo come segue (in un ambiente non Rails / ActiveSupport):

variable.to_s.empty?

questo funziona perché:

nil.to_s == ""
"".to_s == ""

Un'alternativa alla proposta di jcoby sarebbe:

class NilClass
  def nil_or_empty?
    true
  end
end

class String
  def nil_or_empty?
    empty?
  end
end

Come è stato detto qui prima che Rails (ActiveSupport) abbia un utile spazio vuoto? metodo ed è implementato in questo modo:

class Object
  def blank?
    respond_to?(:empty?) ? empty? : !self
  end
end

Abbastanza facile da aggiungere a qualsiasi progetto basato su ruby.

Il bello di questa soluzione è che funziona auto-magia non solo per stringhe ma anche per array e altri tipi.

variable.blank? lo farà. Restituisce vero se la stringa è vuota o se la stringa è nulla.

nil?può essere omesso in contesti booleani. In generale, è possibile utilizzare questo per replicare il codice C #:

return my_string.nil? || my_string.empty?

Prima di tutto, fai attenzione a quel metodo:

Come dice Jesse Ezel :

Brad Abrams

"Il metodo potrebbe sembrare conveniente, ma la maggior parte delle volte ho scoperto che questa situazione nasce dal tentativo di nascondere bug più profondi.

Il tuo codice dovrebbe attenersi a un protocollo particolare sull'uso delle stringhe e dovresti comprendere l'uso del protocollo nel codice della libreria e nel codice con cui stai lavorando.

Il protocollo NullOrEmpty è in genere una soluzione rapida (quindi il vero problema è ancora da qualche altra parte e hai due protocolli in uso) o è una mancanza di esperienza in un protocollo particolare quando si implementa un nuovo codice (e, di nuovo, dovresti davvero sapere cosa i tuoi valori di ritorno sono). "

E se correggi la classe String ... assicurati che NilClass non sia stato nemmeno patch !

class NilClass
    def empty?; true; end
end

Ogni classe ha un nil?metodo:

if a_variable.nil?
    # the variable has a nil value
end

E le stringhe hanno il empty?metodo:

if a_string.empty?
    # the string is empty
}

Ricorda che una stringa non è uguale nilquando è vuota, quindi usa il empty?metodo per verificare se una stringa è vuota.

Un'altra opzione è quella di convertire al volo un risultato nullo in un risultato vuoto:

(my_string||'').empty?

Konrad Rudolph ha la risposta giusta.

Se ti infastidisce davvero, scimmia patch la classe String o aggiungila a una classe / modulo a tua scelta. Non è davvero una buona pratica scimmiettare gli oggetti core della patch a meno che tu non abbia una ragione davvero convincente.

class String
  def self.nilorempty?(string)
    string.nil? || string.empty?
  end
end

Quindi puoi farlo String.nilorempty? mystring

Verifica la presenza di stringhe vuote in Ruby normale evitando le eccezioni di NameError

Ci sono alcune buone risposte qui, ma non hai bisogno di ActiveSupport o patch di scimmie per affrontare il caso d'uso comune qui. Per esempio:

my_string.to_s.empty? if defined? my_string

Questo "farà la cosa giusta" se my_string è zero o una stringa vuota, ma non genererà un'eccezione NameError se my_string non è definito. Questo è generalmente preferibile ai più inventati:

my_string.to_s.empty? rescue NameError

o è più prolisso, perché le eccezioni dovrebbero essere salvate per cose che non si fanno aspetti che accadano. In questo caso, mentre potrebbe essere un errore comune, una variabile non definita non è in realtà una circostanza eccezionale, quindi dovrebbe essere gestita di conseguenza.

Il tuo chilometraggio può variare.

Hai provato i perfezionamenti?

module Nothingness
  refine String do
    alias_method :nothing?, :empty?
  end

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

using Nothingness

return my_string.nothing?

Se stai usando le rotaie, puoi usare #present?

require 'rails'

nil.present?  # ==> false (Works on nil)
''.present?    # ==> false (Works on strings)
'  '.present?  # ==> false (Works on blank strings)
[].present?    # ==> false(Works on arrays)
false.present? # ==> false (Works on boolean)

Quindi, al contrario, per verificare se la lunghezza è zero o zero !present?

!(nil.present?)  # ==> true
!(''.present?)    # ==> true
!('  '.present?)  # ==> true
!([].present?)    # ==> true
!(false.present?) # ==> true

In rotaie puoi provare #blank?.

Attenzione: ti darà degli aspetti positivi quando la stringa è composta da spazi:

nil.blank? # ==> true
''.blank? # ==> true
'  '.blank? # ==> true
'false'.blank? # ==> false

Volevo solo sottolinearlo. Forse si adatta alle tue esigenze

UPD. perché ricevo vecchie domande nel mio feed? Ci scusiamo per il necroposting.

Per i golfisti del codice:

if my_string=~/./
  p 'non-empty string'
else
  p 'nil or empty string'
end

O se non sei un golfista (richiede ruby ​​2.3 o successivo):

if my_string&.size&.positive?
  # nonzero? also works
  p 'non-empty string'
else
  p 'nil or empty string'
end