aço-enfeitiçado

Em programação, a iteração refere-se ao processo de repetir um bloco de código várias vezes. Isto pode ser feito com conceitos como ciclos while e ciclos until. Também pode ser feito com recursão, que é uma função que se chama a si própria.

No entanto, na maioria das vezes queres iterar sobre uma coleção de itens, como um Array, um Range ou uma String. Tanto a classe Array como a classe Range em Crystal incluem o módulo Enumerable, que fornece vários métodos para iterar sobre os elementos. Entretanto, a classe String tem o seu próprio conjunto de métodos para iterar sobre os carateres.

Crystal também não tem nenhuma instrução for como outras linguagens. Em vez disso, tem vários métodos que podes usar para iterar.

Iterar

A forma mais comum de iterar sobre uma coleção é usar o método each, que passa cada elemento da coleção a um bloco. Isto faz-se facilmente com um Range. Imagina que queres fazer um ciclo entre 1 e 3: podes usar o método each para iterar sobre o intervalo.

(1..3).each do |n|
  puts n
end

# Output:
# 1
# 2
# 3

Ainda mais simples: se só quiseres iterar um certo número de vezes, podes usar o método times, que existe na classe Int.

3.times do |n|
  puts n
end

# Output:
# 0
# 1
# 2

Iterar sobre uma String

Uma String é uma sequência de carateres e não pertence ao módulo Enumerable, o que significa que tem o seu próprio conjunto de métodos para iterar sobre os carateres. A forma mais comum de iterar sobre uma String é usar o método each_char, que passa cada caráter da String a um bloco.

str = "hello"
str.each_char { |char| puts char }

# Output:
# h
# e
# l
# l
# o

Outra forma de iterar sobre uma String é usar o método each_line. Este método é usado sobretudo quando se lê um ficheiro linha a linha.

str = "hello\nworld"
str.each_line do |line|
  puts line
end

# Output:
# hello
# world

Iterar sobre um objeto que inclui o módulo Enumerable

O módulo Enumerable fornece vários métodos para iterar sobre os elementos de uma coleção. As coleções que incluem o módulo Enumerable são Array, Range, Hash, Set, entre outras; estas últimas serão abordadas em conceitos posteriores.

A forma mais comum de iterar sobre um Array é usar o método each, que passa cada elemento do Array a um bloco.

arr = [5, 2, 3]
arr.each do |element|
  puts element
end

# Output:
# 5
# 2
# 3

Map

O método map é outra forma de iterar sobre um Array; devolve um novo Array que contém os resultados de aplicar o bloco a cada elemento. É semelhante ao método each, mas devolve um novo Array com os elementos transformados. A transformação é muito útil quando queres aplicar uma função a cada elemento da coleção, o que é uma operação comum.

arr = [1, 2, 3]
new_arr = arr.map do |element|
  element * 2
end

new_arr
# => [2, 4, 6]

Com um fluxo de controlo como o if, também podes filtrar quais os elementos a transformar.

arr = [1, 2, 3]
new_arr = arr.map do |element|
  if element.odd?
    element * 2
  else
    element
  end
end

new_arr
# => [2, 2, 6]

Com índice

Por vezes precisas de saber o índice do elemento sobre o qual estás a iterar; para isso, podes usar o método each_with_index ou map_with_index. Ele passa cada elemento e o respetivo índice a um bloco, e o método também aceita um argumento opcional para especificar o índice inicial.

arr = [1, 2, 3]
arr.each_with_index(4) do |element, index|
  puts "Element: #{element}, Index: #{index}"
end

# Output:
# Element: 1, Index: 4
# Element: 2, Index: 5
# Element: 3, Index: 6

Repara que o método each_char_with_index também está disponível para objetos String.

sum

O método sum devolve a soma de todos os elementos da coleção; também aceita um bloco opcional para transformar os elementos antes de os somar. Também aceita um argumento opcional para especificar o valor inicial da soma.

arr = [1, 2, 3]
arr.sum
# => 6

arr.sum(2) { |n| n * 2 }
# => 14

reduce

reduce, ou fold como é conhecido noutras linguagens, é um método que combina todos os elementos da coleção, usando um método de combinação e um valor inicial. O método reduce tem um acumulador que é passado ao bloco; o acumulador é o resultado da iteração anterior. Isto torna-se um processo recursivo que combina todos os elementos da coleção.

arr = [1, 2, 3]
arr.reduce(0) do |acc, n|
  acc + n
end
# => 6

reduce pode parecer semelhante a sum, mas reduce é mais flexível, porque te permite especificar o valor inicial do acumulador e o método de combinação. reduce pode ser usado para implementar sum, count e outros métodos.