variable - somme en ruby




Comment écrire une déclaration de commutateur dans Ruby? (14)

Comment écrire une instruction switch dans Ruby?


cas ... quand

Pour ajouter plus d'exemples à la réponse de Chuck :

Avec paramètre:

case a
when 1
  puts "Single value"
when 2, 3
  puts "One of comma-separated values"
when 4..6
  puts "One of 4, 5, 6"
when 7...9
  puts "One of 7, 8, but not 9"
else
  puts "Any other thing"
end

Sans paramètre:

case
when b < 3
  puts "Little than 3"
when b == 3
  puts "Equal to 3"
when (1..10) === b
  puts "Something in closed range of [1..10]"
end

S'il vous plaît, soyez conscient du problème que kikito met en garde.


Beaucoup de bonnes réponses mais je pensais que j'ajouterais un factoid .. Si vous essayez de comparer des objets (Classes) assurez-vous que vous avez une méthode de vaisseau spatial (pas une blague) ou de comprendre comment ils sont comparés

Voici une bonne discussion sur le sujet http://www.skorks.com/2009/09/ruby-equality-and-object-comparison/


C'est fait par case en Ruby. Voir aussi cet article sur Wikipedia .

Cité:

case n
when 0
  puts 'You typed zero'
when 1, 9
  puts 'n is a perfect square'
when 2
  puts 'n is a prime number'
  puts 'n is an even number'
when 3, 5, 7
  puts 'n is a prime number'
when 4, 6, 8
  puts 'n is an even number'
else
  puts 'Only single-digit numbers are allowed'
end

Un autre exemple:

score = 70

result = case score
   when 0..40 then "Fail"
   when 41..60 then "Pass"
   when 61..70 then "Pass with Merit"
   when 71..100 then "Pass with Distinction"
   else "Invalid Score"
end

puts result

Sur la page 123 (j'utilise Kindle) de The Ruby Programming Lanugage (1ère édition, O'Reilly), il est dit que le mot-clé then suivant les clauses when peut être remplacé par un saut de ligne ou un point-virgule (comme dans la syntaxe if then else ). (Ruby 1.8 permet aussi un deux-points à la place de ... Mais cette syntaxe n'est plus autorisée dans Ruby 1.9.)


Comme indiqué dans la plupart des réponses ci-dessus, l'opérateur === est utilisé sous le capot sur les déclarations cas / when.

Voici quelques informations supplémentaires sur cet opérateur.

Opérateur d'égalité de cas: ===

Beaucoup de classes intégrées de Ruby, telles que String, Range et Regexp, fournissent leurs propres implémentations de l'opérateur ===, également connu sous le nom d'égalité des cas, triple égal ou troisquals. Comme il est implémenté différemment dans chaque classe, il se comportera différemment selon le type d'objet sur lequel il a été appelé. Généralement, il renvoie true si l'objet de droite "appartient à" ou "est membre de" l'objet de gauche. Par exemple, il peut être utilisé pour tester si un objet est une instance d'une classe (ou d'une de ses sous-classes).

String === "zen"  # Output: => true
Range === (1..2)   # Output: => true
Array === [1,2,3]   # Output: => true
Integer === 2   # Output: => true

Le même résultat peut être obtenu avec d'autres méthodes qui sont probablement les mieux adaptées au travail, comme is_a? et instance_of ?.

Implémentation de la plage de ===

Lorsque l'opérateur === est appelé sur un objet range, il renvoie true si la valeur sur la droite se situe dans la plage de gauche.

(1..4) === 3  # Output: => true
(1..4) === 2.345 # Output: => true
(1..4) === 6  # Output: => false

("a".."d") === "c" # Output: => true
("a".."d") === "e" # Output: => false

Souvenez-vous que l'opérateur === invoque la méthode === de l'objet de gauche. Donc (1..4) === 3 est équivalent à (1..4). === 3. En d'autres termes, la classe de l'opérande de gauche définira quelle implémentation de la méthode === sera appelé, de sorte que les positions d'opérande ne sont pas interchangeables.

Implémentation de Regexp de ===

Renvoie true si la chaîne de droite correspond à l'expression régulière sur la gauche. / zen / === "pratique zazen aujourd'hui" # Output: => true # est similaire à "zazen practice now" = ~ / zen /

La seule différence pertinente entre les deux exemples ci-dessus est que, quand il y a une correspondance, === renvoie true et = ~ renvoie un entier, ce qui est une valeur de vérité dans Ruby. Nous y reviendrons bientôt.


De nombreux langages de programmation, en particulier ceux dérivés du langage C, prennent en charge ce que l'on appelle le commutateur Fallthrough . Je cherchais le meilleur moyen de faire la même chose avec Ruby et je pensais que cela pourrait être utile aux autres:

Dans les langages en forme de C, le déroulement ressemble généralement à ceci:

switch (expression) {
    case 'a':
    case 'b':
    case 'c':
        // Do something for a, b or c
        break;
    case 'd':
    case 'e':
        // Do something else for d or e
        break;
}

En Ruby, la même chose peut être réalisée de la façon suivante:

case expression
when 'a', 'b', 'c'
  # Do something for a, b or c
when 'd', 'e'
  # Do something else for d or e
end

Ce n'est pas strictement équivalent, car il n'est pas possible de laisser 'a' exécuter un bloc de code avant de passer à 'b' ou 'c' , mais pour la plupart, je le trouve assez similaire pour être utile de la même manière.


J'ai commencé à utiliser:

a = "secondcase"

var_name = case a
  when "firstcase" then "foo"
  when "secondcase" then "bar"
end

puts var_name
>> "bar"

Cela aide le code compact dans certains cas.


Puisque le switch case retourne toujours un seul objet, nous pouvons directement imprimer son résultat:

puts case a
     when 0
        "It's zero"
     when 1
        "It's one"
     end

Ruby utilise le case pour écrire des instructions de commutation.

Selon les Ruby Docs :

Les instructions de cas sont constituées d'une condition optionnelle, qui est dans la position d'un argument à case , et de zéro ou plus when clauses. La première when clause pour correspondre à la condition (ou pour évaluer à la vérité booléenne, si la condition est nulle) "gagne", et sa strophe de code est exécutée. La valeur de l'instruction case est la valeur de la clause successful when ou nil s'il n'y a pas de clause.

Une instruction case peut se terminer par une clause else . Chaque when qu'une instruction peut avoir plusieurs valeurs candidates, séparées par des virgules.

Exemple:

case x
when 1,2,3
  puts "1, 2, or 3"
when 10
  puts "10"
else
  puts "Some other number"
end

Version plus courte:

case x
when 1,2,3 then puts "1, 2, or 3"
when 10 then puts "10"
else puts "Some other number"
end

Et comme ce blog de Honeybadger décrit Ruby Case;

Peut être utilisé avec des Ranges :

case 5
when (1..10)
  puts "case statements match inclusion in a range"
end

## => "case statements match inclusion in a range"

Peut être utilisé avec Regex :

case "FOOBAR"
when /BAR$/
  puts "they can match regular expressions!"
end

## => "they can match regular expressions!"

Peut être utilisé avec Procs et Lambda :

case 40
when -> (n) { n.to_s == "40" }
  puts "lambdas!"
end

## => "lambdas"

En outre, peut être utilisé avec vos propres classes de correspondance:

class Success
  def self.===(item)
    item.status >= 200 && item.status < 300
  end
end

class Empty
  def self.===(item)
    item.response_size == 0
  end
end

case http_response
when Empty
  puts "response was empty"
when Success
  puts "response was a success"
end


Valise multi-valeur quand et sans valeur:

print "Enter your grade: "
grade = gets.chomp
case grade
when "A", "B"
  puts 'You pretty smart!'
when "C", "D"
  puts 'You pretty dumb!!'
else
  puts "You can't even use a computer!"
end

Et une solution d' expression régulière ici:

print "Enter a string: "
some_string = gets.chomp
case
when some_string.match(/\d/)
  puts 'String has numbers'
when some_string.match(/[a-zA-Z]/)
  puts 'String has letters'
else
  puts 'String has no numbers or letters'
end

Vous pouvez faire comme ça de manière plus naturelle,

case expression
when condtion1
   function
when condition2
   function
else
   function
end

Vous pouvez utiliser des expressions régulières, telles que la recherche d'un type de chaîne:

case foo
when /^(true|false)$/
   puts "Given string is boolean"
when /^[0-9]+$/ 
   puts "Given string is integer"
when /^[0-9\.]+$/
   puts "Given string is float"
else
   puts "Given string is probably string"
end

Le case de Ruby utilisera l'opérande d'égalité === pour cela (merci @JimDeville). Des informations supplémentaires sont disponibles sur " Ruby Operators ". Cela peut également être fait en utilisant l'exemple @mmdemirbas (sans paramètre), seule cette approche est plus propre pour ces types de cas.


Ruby utilise l' expression de case place.

case x
when 1..5
  "It's between 1 and 5"
when 6
  "It's 6"
when "foo", "bar"
  "It's either foo or bar"
when String
  "You passed a string"
else
  "You gave me #{x} -- I have no idea what to do with that."
end

Ruby compare l'objet de la clause when avec l'objet de la clause case utilisant l'opérateur === . Par exemple, 1..5 === x , et non x === 1..5 .

Cela permet des clauses sophistiquées when vu ci-dessus. Les gammes, les classes et toutes sortes de choses peuvent être testées plutôt que simplement l'égalité.

Contrairement aux instructions de switch dans de nombreuses autres langues, le case de Ruby n'a pas de fall-through , il n'est donc pas nécessaire de terminer chaque when avec une break . Vous pouvez également spécifier plusieurs correspondances dans une seule clause when "foo", "bar" .






conditional