0Pricing
Elixir & Phoenix: Scalable Backend Development · Aula

Trabalho com Coleções Enumeráveis

Descubra como manipular listas, mapas e outros enumeráveis com eficiência usando o módulo `Enum` do Elixir.

Trabalho com Coleções Enumeráveis é uma aula grátis de Elixir & Phoenix: Scalable Backend Development no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Elixir & Phoenix: Scalable Backend Development, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

What are Enumerable Collections?

In Elixir, an enumerable is a data structure that you can iterate over, element by element. Think of them as containers for multiple values.

Elixir's powerful Enum module provides many functions to work with these collections efficiently.

  • Lists: Ordered collections of any data type.
  • Maps: Key-value stores.
  • Ranges: Sequences of numbers.

Understanding enumerables is key to functional programming in Elixir.

Working with Elixir Lists

Lists are perhaps the most common enumerable. They are ordered and can hold mixed data types.

Let's see a simple list:

defmodule ListExample do
  def run do
    my_list = [1, "hello", :atom, 4.5]
    IO.puts "My list: #{inspect my_list}"
  end
end

ListExample.run()

Exploring Maps as Enums

Maps store data in key-value pairs. While their primary use is lookup, they are also enumerable, meaning you can iterate over their key-value pairs.

When you iterate a map, each element is a tuple {key, value}.

defmodule MapExample do
  def run do
    my_map = %{name: "Alice", age: 30}
    IO.puts "My map: #{inspect my_map}"
  end
end

MapExample.run()

Introducing the `Enum` Module

The Enum module is Elixir's standard library for working with all types of enumerables. It provides a consistent interface for common operations.

Instead of writing loops, you use Enum functions to transform, filter, and aggregate collections in an immutable, functional way.

  • No changing data in place.
  • Functions return new collections.
  • Promotes clear and concise code.

Performing Actions with `Enum.each`

Enum.each/2 is used when you want to perform a side effect for each element in an enumerable, like printing to the console. It always returns :ok.

It's similar to a for-each loop in other languages, but it's purely for side effects.

defmodule EachExample do
  def run do
    numbers = [1, 2, 3]
    IO.puts "Using Enum.each:"
    Enum.each(numbers, fn num -> IO.puts "Number: #{num}" end)
  end
end

EachExample.run()

Transforming Data with `Enum.map`

Enum.map/2 applies a given function to each element of an enumerable and collects the results into a new list. This is perfect for transforming data.

The original enumerable remains unchanged, sticking to functional programming principles.

defmodule MapTransformExample do
  def run do
    numbers = [1, 2, 3]
    doubled_numbers = Enum.map(numbers, fn num -> num * 2 end)
    IO.puts "Original: #{inspect numbers}"
    IO.puts "Doubled: #{inspect doubled_numbers}"
  end
end

MapTransformExample.run()

Selecting Elements with `Enum.filter`

Enum.filter/2 creates a new list containing only the elements for which a given function returns a "truthy" value (anything not false or nil).

Use it when you need to select a subset of elements from a collection.

defmodule FilterExample do
  def run do
    numbers = [1, 2, 3, 4, 5, 6]
    even_numbers = Enum.filter(numbers, fn num -> rem(num, 2) == 0 end)
    IO.puts "All numbers: #{inspect numbers}"
    IO.puts "Even numbers: #{inspect even_numbers}"
  end
end

FilterExample.run()

Reducing Collections with `Enum.reduce`

Enum.reduce/3 (or Enum.reduce/2) is one of the most powerful Enum functions. It "reduces" an enumerable to a single value by applying a function iteratively.

You provide an initial accumulator value and a function that takes the current element and the accumulator, returning a new accumulator.

defmodule ReduceExample do
  def run do
    numbers = [1, 2, 3, 4]
    sum = Enum.reduce(numbers, 0, fn num, acc -> num + acc end)
    IO.puts "Numbers: #{inspect numbers}"
    IO.puts "Sum: #{sum}"
  end
end

ReduceExample.run()

More `Enum` Functions to Know

The Enum module is vast! Here are a few more functions you'll find useful:

  • Enum.all?(enum, fun): Checks if all elements satisfy a condition.
  • Enum.any?(enum, fun): Checks if any element satisfies a condition.
  • Enum.take(enum, n): Returns the first n elements.
  • Enum.drop(enum, n): Returns all elements except the first n.
  • Enum.sort(enum): Sorts the elements.

Explore the official Elixir documentation for the full list!

Test Your `Enum` Knowledge

Consider the following Elixir code snippet:

defmodule QuestionCode do
  def run do
    data = [1, 2, 3, 4, 5]
    result_a = Enum.map(data, fn x -> x * 10 end)
    result_b = Enum.filter(data, fn x -> rem(x, 2) == 0 end)
    result_c = Enum.reduce(data, 0, fn x, acc -> x + acc end)
    IO.puts "A: #{inspect result_a}"
    IO.puts "B: #{inspect result_b}"
    IO.puts "C: #{inspect result_c}"
  end
end

QuestionCode.run()

Recap: Enumerable Power

Great job! You've learned the fundamentals of working with enumerable collections in Elixir.

  • Enumerables are data structures you can iterate over (lists, maps, ranges).
  • The Enum module provides powerful functions for consistent, immutable operations.
  • Key functions include each (side effects), map (transform), filter (select), and reduce (aggregate).

These functions are cornerstones of functional programming in Elixir, enabling clean and efficient data manipulation.

Perguntas Frequentes

A aula “Trabalho com Coleções Enumeráveis” é grátis?

Sim — o texto completo de “Trabalho com Coleções Enumeráveis” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Elixir & Phoenix: Scalable Backend Development, atualize para CoddyKit PRO. O curso de Elixir & Phoenix: Scalable Backend Development inclui 4 aulas no total.

O que vou aprender em “Trabalho com Coleções Enumeráveis”?

Descubra como manipular listas, mapas e outros enumeráveis com eficiência usando o módulo `Enum` do Elixir. Você pratica Elixir & Phoenix: Scalable Backend Development com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Elixir & Phoenix: Scalable Backend Development?

Nenhuma experiência prévia é necessária. Elixir & Phoenix: Scalable Backend Development no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Trabalho com Coleções Enumeráveis”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Elixir & Phoenix: Scalable Backend Development?

Sim. Cada aula de Elixir & Phoenix: Scalable Backend Development inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Funções, Módulos e Encadeamento
  2. Trabalho com Coleções Enumeráveis
  3. Recursão e Funções de Ordem Superior
  4. Avaliação Preguiçosa com o Módulo Stream
← Voltar para Elixir & Phoenix: Scalable Backend Development