Existe-t-il un meilleur moyen de vérifier Nil ou Length == 0 d'une chaîne en Ruby?

Existe-t-il un meilleur moyen que le suivant pour vérifier si une chaîne est nulle OU a une longueur de 0 dans Ruby?

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

En C #, il y a le pratique

string.IsNullOrEmpty(myString)

Quelque chose de similaire à celui de Ruby?

Quand je ne suis pas inquiet pour les performances, j'utilise souvent ceci:

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

Il existe bien sûr diverses variantes ...

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

Si vous souhaitez avoir besoin d'ActiveSupport, vous pouvez simplement utiliser la #blank?méthode, qui est définie pour NilClass et String.

J'aime faire cela comme suit (dans un environnement non Rails / ActiveSupport):

variable.to_s.empty?

cela fonctionne parce que:

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

Une alternative à la proposition de jcoby serait:

class NilClass
  def nil_or_empty?
    true
  end
end

class String
  def nil_or_empty?
    empty?
  end
end

Comme il a été dit ici avant que Rails (ActiveSupport) ait un vide pratique ? méthode et il est implémenté comme ceci:

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

Assez facile à ajouter à tout projet basé sur Ruby.

La beauté de cette solution est qu'elle fonctionne automatiquement par magie non seulement pour les chaînes, mais aussi pour les tableaux et autres types.

variable.blank? le fera. Il renvoie true si la chaîne est vide ou si la chaîne est nulle.

nil?peut être omis dans les contextes booléens. En règle générale, vous pouvez l'utiliser pour répliquer le code C #:

return my_string.nil? || my_string.empty?

Tout d'abord, méfiez-vous de cette méthode:

Comme le dit Jesse Ezel :

Brad Abrams

«La méthode peut sembler pratique, mais la plupart du temps, j'ai trouvé que cette situation venait de la tentative de dissimuler des bogues plus profonds.

Votre code doit s'en tenir à un protocole particulier sur l'utilisation des chaînes, et vous devez comprendre l'utilisation du protocole dans le code de la bibliothèque et dans le code avec lequel vous travaillez.

Le protocole NullOrEmpty est généralement une solution rapide (donc le vrai problème est toujours ailleurs, et vous avez deux protocoles en cours d'utilisation) ou il s'agit d'un manque d'expertise dans un protocole particulier lors de la mise en œuvre d'un nouveau code (et encore une fois, vous devez vraiment savoir ce que vos valeurs de retour sont). "

Et si vous corrigez la classe String ... assurez-vous que NilClass n'a pas été corrigée non plus !

class NilClass
    def empty?; true; end
end

Chaque classe a une nil?méthode:

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

Et les chaînes ont la empty?méthode:

if a_string.empty?
    # the string is empty
}

N'oubliez pas qu'une chaîne n'est pas égale nillorsqu'elle est vide, utilisez donc la empty?méthode pour vérifier si une chaîne est vide.

Une autre option consiste à convertir nil en résultat vide à la volée:

(my_string||'').empty?

Konrad Rudolph a la bonne réponse.

Si cela vous dérange vraiment, modifiez la classe String ou ajoutez-la à une classe / module de votre choix. Ce n'est vraiment pas une bonne pratique de monkey patcher les objets principaux à moins que vous n'ayez une raison vraiment convaincante.

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

Alors tu peux faire String.nilorempty? mystring

Rechercher les chaînes vides dans Ruby brut tout en évitant les exceptions NameError

Il y a quelques bonnes réponses ici, mais vous n'avez pas besoin d'ActiveSupport ou de monkey-patching pour traiter le cas d'utilisation courant ici. Par exemple:

my_string.to_s.empty? if defined? my_string

Cela "fera la bonne chose" si ma_chaîne est nulle ou une chaîne vide, mais ne lèvera pas d'exception NameError si ma_chaîne n'est pas définie. Ceci est généralement préférable aux plus artificiels:

my_string.to_s.empty? rescue NameError

ou son acabit plus verbeux, car les exceptions devraient vraiment être enregistrées pour des choses que vous ne vous attendez pas à ce qu'elles se produisent. Dans ce cas, bien qu'il s'agisse d'une erreur courante, une variable non définie n'est pas vraiment une circonstance exceptionnelle, elle doit donc être traitée en conséquence.

Votre kilométrage peut varier.

Avez-vous essayé les raffinements?

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 vous utilisez des rails, vous pouvez utiliser #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)

Donc, inversement pour vérifier l'utilisation de longueur nulle ou nulle !present?

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

Dans les rails, vous pouvez essayer #blank?.

Attention: cela vous donnera des points positifs lorsque la chaîne est composée d'espaces:

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

Je voulais juste le souligner. Peut-être que cela répond à vos besoins

UPD. pourquoi ai-je de vieilles questions dans mon flux? Désolé pour le nécropostage.

Pour les golfeurs de code:

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

Ou si vous n'êtes pas un golfeur (nécessite ruby ​​2.3 ou version ultérieure):

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