Existe uma maneira melhor de verificar zero ou comprimento == 0 de uma seqüência de caracteres em Ruby?

Existe uma maneira melhor do que a seguinte para verificar se uma string é nula OU tem um comprimento de 0 em Ruby?

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

Em C # há a mão

string.IsNullOrEmpty(myString)

Algo semelhante ao de Ruby?

Quando não estou preocupado com o desempenho, usarei frequentemente isso:

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

Existem várias variações, é claro ...

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

Se você deseja solicitar o ActiveSupport, basta usar o #blank?método definido para NilClass e String.

Eu gosto de fazer o seguinte (em um ambiente que não seja Rails / ActiveSupport):

variable.to_s.empty?

isso funciona porque:

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

Uma alternativa à proposta do jcoby seria:

class NilClass
  def nil_or_empty?
    true
  end
end

class String
  def nil_or_empty?
    empty?
  end
end

Como foi dito aqui antes do Rails (ActiveSupport) ter um espaço em branco útil ? método e é implementado assim:

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

Muito fácil de adicionar a qualquer projeto baseado em rubi.

A vantagem dessa solução é que ela funciona automaticamente, não apenas para Strings, mas também para matrizes e outros tipos.

variable.blank? vai fazer isso. Retorna true se a string estiver vazia ou se a string for nula.

nil?pode ser omitido em contextos booleanos. Geralmente, você pode usar isso para replicar o código C #:

return my_string.nil? || my_string.empty?

Primeiro de tudo, cuidado com esse método:

Como Jesse Ezel diz:

Brad Abrams

"O método pode parecer conveniente, mas na maioria das vezes eu descobri que essa situação surge da tentativa de encobrir erros mais profundos.

Seu código deve seguir um protocolo específico sobre o uso de strings e você deve entender o uso do protocolo no código da biblioteca e no código com o qual você está trabalhando.

O protocolo NullOrEmpty geralmente é uma solução rápida (portanto, o problema real ainda está em outro lugar, e você tem dois protocolos em uso) ou é uma falta de conhecimento em um protocolo específico ao implementar um novo código (e, novamente, você realmente deve saber o que seus valores de retorno são). "

E se você aplicar patch à classe String ... verifique se o NilClass também não foi corrigido !

class NilClass
    def empty?; true; end
end

Toda classe tem um nil?método:

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

E as cordas têm o empty?método:

if a_string.empty?
    # the string is empty
}

Lembre-se de que uma string não é igual nilquando está vazia; portanto, use o empty?método para verificar se uma string está vazia.

Outra opção é converter nada em um resultado vazio em tempo real:

(my_string||'').empty?

Konrad Rudolph tem a resposta certa.

Se isso realmente o incomoda, faça um patch para a classe String ou adicione-a a uma classe / módulo de sua escolha. Realmente não é uma boa prática usar objetos principais do patch, a menos que você tenha uma razão realmente convincente.

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

Então você pode fazer String.nilorempty? mystring

Verifique se há cadeias vazias no Ruby comum, evitando exceções de NameError

Há algumas boas respostas aqui, mas você não precisa do ActiveSupport ou do patch de macacos para resolver o caso de uso comum aqui. Por exemplo:

my_string.to_s.empty? if defined? my_string

Isso "fará a coisa certa" se my_string for nulo ou uma string vazia, mas não gerará uma exceção NameError se my_string não estiver definido. Isso geralmente é preferível ao mais artificial:

my_string.to_s.empty? rescue NameError

ou é mais detalhado, porque as exceções devem ser realmente salvas para coisas que você não espera que aconteçam. Nesse caso, embora possa ser um erro comum, uma variável indefinida não é realmente uma circunstância excepcional, portanto deve ser tratada de acordo.

Sua milhagem pode variar.

Você já experimentou refinamentos?

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 você estiver usando trilhos, você pode 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 isso, verifique inversamente o uso de comprimento nulo ou zero !present?

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

Nos trilhos você pode tentar #blank?.

Atenção: ele fornecerá pontos positivos quando a string for composta por espaços:

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

Só queria salientar. Talvez atenda às suas necessidades

UPD. por que estou recebendo perguntas antigas no meu feed? Desculpe pelo necroposting.

Para jogadores de código:

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

Ou se você não é um jogador de golfe (requer ruby ​​2.3 ou posterior):

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