Différence entre "..." (double point) et "..." (triple point) dans la génération de gamme ?

Question

Je viens de commencer à apprendre Ruby et Ruby on Rails et je suis tombé sur un code de validation qui utilise des plages :

validates_inclusion_of :age, :in => 21..99
validates_exclusion_of :age, :in => 0...21, :message => "Sorry, you must be over 21"

J'ai d'abord pensé que la différence résidait dans l'inclusion des points de terminaison, mais dans les documents relatifs à l'API que j'ai consultés, il ne semblait pas y avoir de différence entre les deux. .. o ... : il a toujours inclus les points d'arrivée.

Cependant, j'ai effectué quelques tests dans irb et il semble que cela indique que .. inclut les deux points d'extrémité, tandis que ... n'incluait que la borne inférieure mais pas la borne supérieure. Est-ce correct ?

Answer 1

El documentation pour Range † dit ceci :

Les gammes construites à l'aide de .. se déroulent du début à la fin de manière inclusive. Ceux créés à l'aide de ... exclure la valeur finale.

Alors a..b c'est comme a <= x <= b alors que a...b c'est comme a <= x < b .

---

Notez que, si to_a sur une plage d'entiers donne une collection d'entiers, une plage est no un ensemble de valeurs, mais simplement une paire de valeurs de début et de fin :

(1..5).include?(5)           #=> true
(1...5).include?(5)          #=> false

(1..4).include?(4.1)         #=> false
(1...5).include?(4.1)        #=> true
(1..4).to_a == (1...5).to_a  #=> true
(1..4) == (1...5)            #=> false

† Auparavant, la documentation n'incluait pas cet élément, mais demandait plutôt de lire le fichier La section de la pioche sur les gammes . Merci à @MarkAmery ( voir ci-dessous ) pour avoir pris note de cette mise à jour.

Answer 2

C'est exact.

1.9.3p0 :005 > (1...10).to_a
 => [1, 2, 3, 4, 5, 6, 7, 8, 9]
1.9.3p0 :006 > (1..10).to_a
 => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

La syntaxe à triple point est moins courante, mais elle est plus agréable que celle de (1..10-1).to_a

Answer 3

Les documents de l'API décrivent maintenant ce comportement :

Les gammes construites à l'aide de .. se déroulent du début à la fin de manière inclusive. Ceux créés à l'aide de ... exclure la valeur finale.

-- http://ruby-doc.org/core-2.1.3/Range.html

En d'autres termes :

2.1.3 :001 > ('a'...'d').to_a
 => ["a", "b", "c"] 
2.1.3 :002 > ('a'..'d').to_a
 => ["a", "b", "c", "d"]

Answer 4

a...b exclut la valeur finale, tandis que a..b comprend la valeur finale.

Lorsque vous travaillez avec des nombres entiers, a...b se comporte comme a..b-1 .

>> (-1...3).to_a
=> [-1, 0, 1, 2]

>> (-1..2).to_a
=> [-1, 0, 1, 2]

>> (-1..2).to_a == (-1...3).to_a
=> true

Mais en réalité, les gammes diffèrent sur un ligne des nombres réels .

>> (-1..2) == (-1...3)
=> false

Vous pouvez voir cela lorsque vous incrémentez par pas fractionnaires.

>> (-1..2).step(0.5).to_a
=> [-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0]

>> (-1...3).step(0.5).to_a
=> [-1.0, -0.5, 0.0, 0.5, 1.0, 1.5, 2.0, 2.5]

Answer 5

... et ... indiquent une gamme.

Il suffit de le voir dans l'irb :

ruby-1.9.2-p290 :032 > (1...2).each do puts "p" end
p
 => 1...2 
ruby-1.9.2-p290 :033 > (1..2).each do puts "p" end
p
p