¿Hay una mejor manera de marcar Nil o Length == 0 de una cadena en Ruby?

¿Hay una manera mejor que la siguiente para verificar si una cadena es nula O tiene una longitud de 0 en Ruby?

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

En C # está lo útil

string.IsNullOrEmpty(myString)

¿Algo similar a eso en Ruby?

Cuando no estoy preocupado por el rendimiento, a menudo uso esto:

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

Hay varias variaciones, por supuesto ...

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

Si está dispuesto a requerir ActiveSupport, puede usar el #blank?método, que se define para NilClass y String.

Me gusta hacer esto de la siguiente manera (en un entorno no Rails / ActiveSupport):

variable.to_s.empty?

esto funciona porque:

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

Una alternativa a la propuesta de jcoby sería:

class NilClass
  def nil_or_empty?
    true
  end
end

class String
  def nil_or_empty?
    empty?
  end
end

Como se dijo aquí antes de que Rails (ActiveSupport) tenga un espacio en blanco útil . método y se implementa así:

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

Bastante fácil de agregar a cualquier proyecto basado en rubí.

La belleza de esta solución es que funciona de forma automática no solo para cadenas, sino también para matrices y otros tipos.

variable.blank? lo haré. Devuelve verdadero si la cadena está vacía o si la cadena es nula.

nil?puede omitirse en contextos booleanos. En general, puede usar esto para replicar el código C #:

return my_string.nil? || my_string.empty?

En primer lugar, tenga cuidado con ese método:

Como dice Jesse Ezel :

Brad Abrams

"El método puede parecer conveniente, pero la mayoría de las veces he descubierto que esta situación surge de tratar de ocultar errores más profundos.

Su código debe apegarse a un protocolo particular sobre el uso de cadenas, y debe comprender el uso del protocolo en el código de la biblioteca y en el código con el que está trabajando.

El protocolo NullOrEmpty suele ser una solución rápida (por lo que el problema real todavía está en otro lugar, y tienes dos protocolos en uso) o es una falta de experiencia en un protocolo particular al implementar un nuevo código (y de nuevo, realmente debes saber qué sus valores de retorno son) ".

Y si parches la clase String ... ¡asegúrate de que NilClass tampoco haya sido parcheado !

class NilClass
    def empty?; true; end
end

Cada clase tiene un nil?método:

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

Y las cadenas tienen el empty?método:

if a_string.empty?
    # the string is empty
}

Recuerde que una cadena no es igual nilcuando está vacía, así que use el empty?método para verificar si una cadena está vacía.

Otra opción es convertir nulo en un resultado vacío sobre la marcha:

(my_string||'').empty?

Konrad Rudolph tiene la respuesta correcta.

Si realmente te molesta, mono parchea la clase String o agrégala a una clase / módulo de tu elección. Realmente no es una buena práctica hacer un parche de objetos centrales a menos que tenga una razón realmente convincente.

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

Entonces puedes hacer String.nilorempty? mystring

Verifique si hay cadenas vacías en Ruby simple mientras evita las excepciones de NameError

Aquí hay algunas buenas respuestas, pero no necesita ActiveSupport o parches de mono para abordar el caso de uso común aquí. Por ejemplo:

my_string.to_s.empty? if defined? my_string

Esto "hará lo correcto" si my_string es nulo o una cadena vacía, pero no generará una excepción NameError si my_string no está definido. Esto generalmente es preferible a los más artificiales:

my_string.to_s.empty? rescue NameError

o es más detallado, porque las excepciones realmente deberían guardarse para cosas que no esperas que sucedan. En este caso, si bien puede ser un error común, una variable indefinida no es realmente una circunstancia excepcional, por lo que debe manejarse en consecuencia.

Su experiencia puede ser diferente.

¿Has probado refinamientos?

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?

Si usa rieles, puede usar #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)

Por lo tanto, para verificar el uso de longitud nula o cero !present?

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

En rieles puedes probar #blank?.

Advertencia: le dará positivos cuando la cadena consiste en espacios:

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

Solo quería señalarlo. Tal vez se adapte a tus necesidades.

UPD ¿Por qué recibo viejas preguntas en mi feed? Perdón por la necroposición.

Para golfistas de código:

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

O si no eres golfista (requiere ruby ​​2.3 o posterior):

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