Intervalles en

À propos de Intervalles

Les intervalles représentent un intervalle entre deux valeurs. Les types les plus courants qui prennent en charge les intervalles sont Integer et String. On peut les utiliser pour beaucoup de choses : créer rapidement une collection, découper des strings, vérifier qu'une valeur se trouve dans un intervalle, ou encore pour l'itération. On les crée avec l'opérateur d'intervalle .. ou ... (respectivement inclusif et exclusif).

1..5  # => 1..5
1...5 # => 1...5

(1..5).to_a # => [1, 2, 3, 4, 5]
(1...5).to_a # => [1, 2, 3, 4]

La raison d'avoir deux opérateurs d'intervalle est de pouvoir créer des intervalles qui incluent ou excluent la valeur de fin, ce qui peut être utile, par exemple, quand on travaille avec des indices qui commencent à zéro.

On peut aussi créer des intervalles avec l'initialiseur Range.

Range.new(1, 5) # A range containing 1, 2, 3, 4, 5

(1..5).sum # => 15
1..5.sum # => Error: undefined method `sum' for 5:Integer (NoMethodError)

Obtiens des sous-chaînes

Pour découper une string, tu peux utiliser l'opérateur d'intervalle pour en obtenir une sous-chaîne. Il suffit pour cela de créer un intervalle avec l'indice de début et l'indice de fin de cette sous-chaîne.

"Hello World"[0..4] # => "Hello"
"Hello World"[6..10] # => "World"

Tu peux aussi utiliser des indices négatifs pour obtenir la sous-chaîne à partir de la fin de la string.

"Hello World"[-5..-1] # => "World"
"Hello World"[6..-4] # => "Wo"

Méthodes des intervalles

Les intervalles disposent d'un ensemble de méthodes pour travailler avec eux. Par exemple, ces méthodes permettent d'obtenir la somme de toutes les valeurs de l'intervalle ou de vérifier si l'intervalle contient une valeur.

Intervalles sans fin et sans début

Un intervalle peut être sans fin ou sans début. Dans un intervalle sans fin ou sans début, la valeur de début ou de fin vaut nil, mais on peut omettre ce nil quand on définit l'intervalle.

Les intervalles sans début et sans fin sont utiles quand on veut, par exemple, découper une string depuis le début ou jusqu'à la fin.

"Hello World"[0..] # => "Hello World"
"Hello World"[4..] # => "o World"
"Hello World"[..5] # => "Hello "

Intervalles de chaînes de caractères

Les strings peuvent aussi servir dans les intervalles et permettent d'obtenir un intervalle de strings entre deux strings. Leur comportement peut être un peu inattendu avec certaines strings, il vaut donc mieux les utiliser avec prudence.

"aa".."az".to_a # => ["aa", "ab", "ac", ..., "az"]

Objets personnalisés dans les intervalles

class Foo
  include Comparable

  attr_reader :value

  def initialize(value)
    @value = value
  end

  def succ
    Foo.new(value + 1)
  end

  def <=>(other)
    value <=> other.value
  end
end

(Foo.new(1)..Foo.new(5))
# => #<Foo:0x7f3552bebe70 @value=1>, #<Foo:0x7f3552bebe50 @value=2>, #<Foo:0x7f3552bebe40 @value=3>, #<Foo:0x7f3552bebe30 @value=4>, #<Foo:0x7f3552bebe20 @value=5>