0Pricing
Elixir & Phoenix: Scalable Backend Development · Lección

Trabajo con colecciones enumerables

Descubra cómo manipular eficazmente listas, mapas y otros enumerables mediante el módulo `Enum` de Elixir.

Trabajo con colecciones enumerables es una lección gratuita de Elixir & Phoenix: Scalable Backend Development en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Elixir & Phoenix: Scalable Backend Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en 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.

Preguntas frecuentes

¿La lección «Trabajo con colecciones enumerables» es gratis?

Sí — el texto completo de «Trabajo con colecciones enumerables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Elixir & Phoenix: Scalable Backend Development, actualiza a CoddyKit PRO. El curso de Elixir & Phoenix: Scalable Backend Development incluye 4 lecciones en total.

¿Qué aprenderé en «Trabajo con colecciones enumerables»?

Descubra cómo manipular eficazmente listas, mapas y otros enumerables mediante el módulo `Enum` de Elixir. Practicas Elixir & Phoenix: Scalable Backend Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Elixir & Phoenix: Scalable Backend Development?

No se requiere experiencia previa. Elixir & Phoenix: Scalable Backend Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Trabajo con colecciones enumerables»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Elixir & Phoenix: Scalable Backend Development?

Sí. Cada lección de Elixir & Phoenix: Scalable Backend Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Funciones, módulos y encadenamiento con pipes
  2. Trabajo con colecciones enumerables
  3. Recursividad y funciones de orden superior
  4. Evaluación perezosa con el módulo Stream
← Volver a Elixir & Phoenix: Scalable Backend Development