Introdução
Intervalos representam o intervalo entre dois valores.
Os tipos mais comuns que suportam intervalos são Integer e String.
Podem ser usados para muitas coisas, como criar rapidamente uma coleção, fatiar strings, verificar se um valor está dentro de um intervalo e iterar.
São criados com o operador de intervalo .. ou ... (inclusivo e exclusivo, respetivamente).
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]
A razão para existirem dois operadores de intervalo é permitir criar intervalos que incluem ou excluem o valor final, o que pode ser útil quando, por exemplo, trabalhas com índices baseados em zero.
Os intervalos também podem ser criados com o construtor Range, o new.
Range.new(1, 5) # A range containing 1, 2, 3, 4, 5
Quando crias um intervalo em Ruby com os operadores de intervalo .. ou ... e queres chamar um método ao intervalo, tens de envolver o intervalo em parênteses.
Isto acontece porque, caso contrário, o método será chamado sobre o segundo argumento do operador de intervalo.
(1..5).sum # => 15
1..5.sum # => Error: undefined method `sum' for 5:Integer (NoMethodError)
Obter substrings
Quando queres fatiar uma string, podes usar o operador de intervalo para obter uma substring.
Ou seja, criando um intervalo com o índice inicial e final da substring.
"Hello World"[0..4] # => "Hello"
"Hello World"[6..10] # => "World"
Também podes usar índices negativos para obter a substring a partir do fim da string.
"Hello World"[-5..-1] # => "World"
"Hello World"[6..-4] # => "Wo"
Métodos dos intervalos
Os intervalos têm um conjunto de métodos que podes usar para trabalhar com eles.
Por exemplo, estes métodos podem ser usados para obter a soma de todos os valores do intervalo ou para verificar se o intervalo inclui um valor.
| Method |
Description |
Example |
sum |
Devolve a soma de todos os valores do intervalo |
(1..5).sum # => 15 |
size |
Devolve o tamanho do intervalo |
(1..5).size # => 5 |
include? |
Devolve true se o intervalo incluir o valor indicado, caso contrário false
|
(1..5).include?(3) # => true |
Intervalos sem fim e sem início
Um intervalo pode ser sem fim e sem início.
Nos intervalos sem fim ou sem início, o valor inicial ou final é nil, mas ao definir o intervalo esse nil pode ser omitido.
Usar intervalos sem início e sem fim é útil quando queres, por exemplo, fatiar uma string a partir do início ou até ao fim.
"Hello World"[0..] # => "Hello World"
"Hello World"[4..] # => "o World"
"Hello World"[..5] # => "Hello "
Se não for usado numa coleção, o intervalo sem fim pode originar uma sequência sem fim, caso não seja usado com cuidado.
Intervalos de strings
As strings também podem ser usadas em intervalos e permitem obter um intervalo de strings entre duas strings.
O seu comportamento pode ser um pouco inesperado com certas strings, por isso usa-o com cuidado.
("aa".."az").to_a # => ["aa", "ab", "ac", ..., "az"]
Instruções
Como entusiasta de xadrez, gostarias de escrever a tua própria versão do jogo.
Sim, já deve haver por aí imensas implementações de xadrez disponíveis online, mas a tua vai ser única!
Começas por implementar um sistema básico de movimento das peças.
O jogo de xadrez vai ser jogado num tabuleiro com 8 casas de largura e 8 casas de comprimento.
As casas são identificadas por uma letra e um número.
1. Define o intervalo de filas e colunas
O jogo vai ter de guardar as filas do tabuleiro.
As filas são as linhas do tabuleiro e são numeradas de 1 a 8.
O jogo também vai ter de guardar as colunas do tabuleiro.
As colunas são as linhas verticais do tabuleiro e são identificadas pelas letras de A a H.
Define as constantes Chess::RANKS e Chess::FILES, que guardam, respetivamente, o intervalo das filas e das colunas.
Chess::RANKS
# => 1..8
Chess::FILES
# => 'A'..'H'
2. Verifica se uma casa é válida
O jogo vai ter de verificar se uma casa é válida.
Uma casa é válida se a fila e a coluna estiverem dentro dos intervalos das filas e das colunas.
Define o método Chess.valid_square?, que recebe os argumentos rank, que contém um número inteiro correspondente à fila, e file, que contém um caráter correspondente à coluna.
O método deve devolver true se a fila e a coluna estiverem dentro dos intervalos das filas e das colunas e devolver false caso contrário.
Chess.valid_square?(1, 'A')
# => true
3. Obtém a alcunha do jogador
O jogo vai ter de obter a alcunha do jogador.
A alcunha é formada pelos 2 primeiros carateres do primeiro nome do jogador e pelos 2 últimos carateres do apelido do jogador.
A alcunha deve ser escrita em maiúsculas.
Define o método Chess.nickname, que recebe os argumentos first_name, que contém uma string com o primeiro nome do jogador, e last_name, que contém uma string com o apelido do jogador.
O método deve devolver a alcunha do jogador como uma string em maiúsculas.
Chess.nickname("John", "Doe")
# => "JOOE"
4. Cria a mensagem de uma jogada
O jogo vai ter de criar uma mensagem para uma jogada, indicando que jogador se moveu para que casa.
A mensagem deve usar a alcunha do jogador e a casa para onde ele se moveu.
O jogo também tem de determinar se a jogada é válida, verificando se a coluna e a fila da casa estão dentro dos intervalos das colunas e das filas.
Se a jogada for válida, a mensagem deve ser: "{nickname} moved to {square}"
Se a jogada for inválida, a mensagem deve ser: "{nickname} attempted to move to {square}, but that is not a valid square"
Define o método Chess.move_message, que recebe os argumentos first_name, que contém uma string com o primeiro nome do jogador, last_name, que contém uma string com o apelido do jogador, e square, que contém uma string com a casa para onde o jogador se moveu.
O método deve devolver a mensagem da jogada como uma string.
Chess.move_message("John", "Doe", "A1")
# => "JOOE moved to A1"
Exercício de aprendizagem
