Differenza tra ".." (doppio punto) e "..." (triplo punto) nella generazione dell'intervallo?

Ho appena iniziato a imparare Ruby e Ruby on Rails e mi sono imbattuto in codice di convalida che utilizza intervalli:

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

All'inizio pensavo che la differenza fosse nell'inclusione degli endpoint, ma nei documenti API che ho esaminato, non sembrava importare se fosse ..o ...: includeva sempre gli endpoint.

Tuttavia, ho eseguito alcuni test in irb e sembrava indicare che ..include entrambi gli endpoint, mentre ...includeva solo il limite inferiore ma non quello superiore. È corretto?

La documentazione per Range ^† dice questo:

Intervalli costruiti utilizzando la ..corsa dall'inizio alla fine in modo inclusivo. Quelli creati utilizzando ...escludono il valore finale.

Così a..bè come a <= x <= b, mentre a...bè come a <= x < b.

Nota che, mentre to_asu un intervallo di interi fornisce una raccolta di numeri interi, un intervallo non è un insieme di valori, ma semplicemente una coppia di valori di inizio / fine:

(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

^{† I documenti non lo includevano, richiedendo invece la lettura della sezione del piccone sui Ranges . Grazie a @MarkAmery ( vedi sotto ) per aver notato questo aggiornamento.}

È corretto.

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 sintassi a tre punti è meno comune, ma è più gradevole di (1..10-1).to_a

I documenti dell'API ora descrivono questo comportamento:

Intervalli costruiti utilizzando la ..corsa dall'inizio alla fine in modo inclusivo. Quelli creati utilizzando ...escludono il valore finale.

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

In altre parole:

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

a...b esclude il valore finale, mentre a..b include il valore finale.

Quando si lavora con numeri interi, a...bsi comporta come 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

Ma in realtà gli intervalli differiscono su una linea di numeri reali .

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

Puoi vederlo quando si incrementa in passaggi frazionari.

>> (-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]

.. e ... denotano un intervallo.

Basta vederlo in 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