Ruby a une idée universelle de « véracité » et de « fausseté ».

Ruby n'ont deux classes spécifiques pour les objets Boolean, et , avec les instances singleton désignés par les variables spéciales et , respectivement.TrueClassFalseClasstruefalse

Cependant, la véracité et la fausseté ne sont pas limitées aux instances de ces deux classes, le concept est universel et s'applique à chaque objet unique dans Ruby. Chaque objet est soit vrai soit faux . Les règles sont très simples. En particulier, seuls deux objets sont faux :

• nil, l'instance singleton de NilClasset
• false, l'instance singleton de FalseClass

Chaque autre objet est véridique . Cela inclut même les objets qui sont considérés comme faux dans d'autres langages de programmation, tels que

• le ,Integer 0
• le ,Float 0.0
• le vide ,String ''
• le vide ,Array []
• le vide ,Hash {}

Ces règles sont intégrées dans la langue et ne sont pas définissables par l'utilisateur. Il n'y a pas de to_boolconversion implicite ou quelque chose de similaire.

Voici une citation de la spécification ISO Ruby Language :

6.6 Valeurs booléennes

Un objet est classé en un objet vrai ou un objet faux .

Seuls faux et nil sont des objets faux. false est la seule instance de la classe FalseClass(voir 15.2.6) à laquelle une fausse expression est évaluée (voir 11.5.4.8.3). nil est la seule instance de la classe NilClass(voir 15.2.4) à laquelle une expression nil est évaluée (voir 11.5.4.8.2).

Les objets autres que faux et nul sont classés en objets vrais. true est la seule instance de la classe TrueClass(voir 15.2.5) à laquelle une expression vraie est évaluée (voir 11.5.4.8.3).

L'exécutable Ruby / Spec semble d'accord :

it "considers a non-nil and non-boolean object in expression result as true" do
  if mock('x')
    123
  else
    456
  end.should == 123
end

Selon ces deux sources, je suppose que les Regexps sont également véridiques , mais selon mes tests, ils ne le sont pas:

if // then 'Regexps are truthy' else 'Regexps are falsy' end
#=> 'Regexps are falsy'

J'ai testé cela sur YARV 2.7.0-preview1 , TruffleRuby 19.2.0.1 et JRuby 9.2.8.0 . Les trois implémentations sont en accord et en désaccord avec la spécification ISO Ruby Language et mon interprétation de Ruby / Spec.

Plus précisément, les Regexpobjets qui sont le résultat de l'évaluation des Regexp littéraux sont faux , alors que les Regexpobjets qui sont le résultat d'une autre expression sont véridiques :

r = //
if r then 'Regexps are truthy' else 'Regexps are falsy' end
#=> 'Regexps are truthy'

Est-ce un bug ou un comportement souhaité?

Ce n'est pas un bug. Ce qui se passe, c'est que Ruby réécrit le code pour que

if /foo/
  whatever
end

devient effectivement

if /foo/ =~ $_
  whatever
end

Si vous exécutez ce code dans un script normal (et n'utilisez pas l' -eoption), vous devriez voir un avertissement:

warning: regex literal in condition

C'est probablement un peu déroutant la plupart du temps, c'est pourquoi l'avertissement est donné, mais peut être utile pour une ligne utilisant l' -eoption. Par exemple, vous pouvez imprimer toutes les lignes correspondant à une expression rationnelle donnée à partir d'un fichier avec

$ ruby -ne 'print if /foo/' filename

(L'argument par défaut de l' printest $_également.)

C'est le résultat (pour autant que je sache) d'une fonctionnalité non documentée du langage ruby, qui s'explique mieux par cette spécification :

it "matches against $_ (last input) in a conditional if no explicit matchee provided" do
  -> {
    eval <<-EOR
    $_ = nil
    (true if /foo/).should_not == true
    $_ = "foo"
    (true if /foo/).should == true
    EOR
  }.should complain(/regex literal in condition/)
end

Vous pouvez généralement penser $_à la "dernière chaîne lue par gets"

Pour rendre les choses encore plus confuses, $_(avec $-) n'est pas une variable globale; il a une portée locale .

Lorsqu'un script Ruby démarre, $_ == nil.

Donc, le code:

// ? 'Regexps are truthy' : 'Regexps are falsey'

S'interprète comme:

(// =~ nil) ? 'Regexps are truthy' : 'Regexps are falsey'

... Ce qui renvoie falsey.

En revanche, pour une expression rationnelle non littérale (par exemple r = //ou Regexp.new('')), cette interprétation spéciale ne s'applique pas.

//est véridique; comme tous les autres objets en rubis en plus nilet false.

À moins d'exécuter un script ruby ​​directement sur la ligne de commande (c'est-à-dire avec le -edrapeau), l'analyseur ruby ​​affichera un avertissement contre une telle utilisation:

avertissement: expression régulière littérale en condition

Vous pouvez utiliser ce comportement dans un script, avec quelque chose comme:

puts "Do you want to play again?"
gets
# (user enters e.g. 'Yes' or 'No')
/y/i ? play_again : back_to_menu

... Mais il serait plus normal d'affecter une variable locale au résultat getset d'effectuer la vérification d'expression régulière par rapport à cette valeur explicitement.

Je ne connais aucun cas d'utilisation pour effectuer cette vérification avec une expression régulière vide , en particulier lorsqu'elle est définie comme une valeur littérale. Le résultat que vous avez mis en évidence surprendrait en effet la plupart des développeurs de rubis.