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

Question

Ho appena iniziato l'apprendimento Ruby e Ruby on Rails e mi sono imbattuto il codice di convalida che utilizza gamme:

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

In un primo momento ho pensato che la differenza era l'inclusione di punti finali, ma nella documentazione API Ho guardato in , non sembrava importare se fosse .. o ...: includeva sempre gli endpoint.

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

Answer 1

Il documentation for Range^† dice questo:

Gamme costruiti utilizzando .. corsa dall'inizio alla fine inclusivo. Quelli creati utilizzando ... escludono il valore finale.

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

---

Si noti che, mentre to_a su una serie di numeri interi dà un insieme di numeri interi, un Range è 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 utilizzati per non includerlo, richiedevano invece la lettura dello Pickaxe’s section on Ranges. Grazie a @MarkAmery (see below) per aver notato questo aggiornamento.}

Answer 2

Ciò è 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 tripla-dot è meno comune, ma è più bello di (1..10-1).to_a

Answer 3

.. 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 

Answer 4

la documentazione API ora descrivere questo comportamento:

intervalli costruiti utilizzando .. corsa dall'inizio alla fine inclusivamente. 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"] 

Answer 5

a...besclude il valore finale, mentre a..binclude il valore finale.

Quando si lavora con numeri interi, a...b si 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 un real number line.

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

Si può vedere questo quando avanzamento a scatti 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]