递归与高阶函数
理解递归这一函数式编程的基本概念，并探索用于抽象行为的高阶函数。
递归与高阶函数 是 CoddyKit 上的免费 Elixir & Phoenix: Scalable Backend Development 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Elixir & Phoenix: Scalable Backend Development 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Meet Recursion in Elixir
Welcome to recursion! In functional programming, recursion is a powerful technique where a function calls itself to solve a problem.
Instead of using loops (like for or while in other languages), Elixir often relies on recursion to iterate over data or repeat actions. It's a core concept you'll use a lot!
The Two Pillars of Recursion
Every recursive function needs two main parts to work correctly:
- Base Case: This is the stopping condition. It defines when the function should stop calling itself and return a direct result. Without it, your function would run forever!
- Recursive Step: This is where the function calls itself again, but with a smaller or simpler version of the original problem. Each call moves closer to the base case.
Recursion in Action: Factorial
Let's see recursion with a classic example: calculating the factorial of a number. The factorial of n (written as n!) is the product of all positive integers less than or equal to n. For example, 5! = 5 * 4 * 3 * 2 * 1 = 120.
Notice how factorial(n) calls factorial(n - 1) until it hits the base case of 0.
defmodule Math do
def factorial(0), do: 1
def factorial(n) when n > 0, do: n * factorial(n - 1)
end
IO.puts "Factorial of 5: #{Math.factorial(5)}"Efficient Recursion: Tail Calls
While recursion is great, naive recursion can sometimes lead to performance issues or 'stack overflows' for very deep calls.
Elixir (and the Erlang VM) offers Tail Call Optimization (TCO). If the recursive call is the very last operation in a function, the VM can optimize it, preventing new stack frames from being created. This makes tail-recursive functions as efficient as loops!
Optimizing with Tail Recursion
To achieve TCO, we often use an accumulator. This is an extra argument passed to the function that collects the result as the recursion progresses.
Compare this version to the previous one. The recursive call factorial(n - 1, n * acc) is the last thing happening in the function, making it tail-recursive.
defmodule Math do
# Public interface, calls the private tail-recursive function
def factorial(n), do: factorial(n, 1)
# Private tail-recursive function with accumulator
defp factorial(0, acc), do: acc
defp factorial(n, acc) when n > 0, do: factorial(n - 1, n * acc)
end
IO.puts "Tail factorial of 5: #{Math.factorial(5)}"Functions as First-Class Citizens
Now, let's explore Higher-Order Functions (HOFs). In Elixir, functions are 'first-class citizens'. This means you can:
- Pass functions as arguments to other functions.
- Return functions as results from other functions.
- Assign functions to variables.
HOFs enable powerful abstractions, making your code more concise, flexible, and reusable.
Transforming Lists with Enum.map
Enum.map/2 is one of the most common HOFs. It takes an enumerable (like a list) and a function. It applies that function to each element and returns a new list with the transformed elements.
It never modifies the original list, embracing Elixir's immutability.
numbers = [1, 2, 3, 4]
doubled_numbers = Enum.map(numbers, fn n -> n * 2 end)
IO.puts "Original: #{inspect numbers}"
IO.puts "Doubled: #{inspect doubled_numbers}"Filtering Lists with Enum.filter
Another handy HOF is Enum.filter/2. It takes an enumerable and a function that should return a boolean (true or false).
It returns a new list containing only the elements for which the function returned true. It's perfect for selecting specific items from a collection.
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = Enum.filter(numbers, fn n -> rem(n, 2) == 0 end)
IO.puts "Original: #{inspect numbers}"
IO.puts "Even: #{inspect even_numbers}"Aggregating with Enum.reduce
Enum.reduce/3 is perhaps the most powerful HOF for working with enumerables. It takes an enumerable, an initial accumulator value, and a function.
It iterates through the collection, applying the function to each element and the current accumulator, eventually reducing the entire collection to a single value.
numbers = [1, 2, 3, 4]
sum = Enum.reduce(numbers, 0, fn n, acc -> n + acc end)
product = Enum.reduce(numbers, 1, fn n, acc -> n * acc end)
IO.puts "Numbers: #{inspect numbers}"
IO.puts "Sum: #{sum}"
IO.puts "Product: #{product}"Anonymous Functions and HOFs
You've seen fn n -> n * 2 end. These are anonymous functions (or lambdas). Elixir provides a shorthand for simple anonymous functions:
&1refers to the first argument.&2refers to the second argument, and so on.&(&1 + &2)is equivalent tofn a, b -> a + b end.
This makes HOF calls even more concise!
numbers = [1, 2, 3, 4]
doubled_short = Enum.map(numbers, &(&1 * 2))
even_short = Enum.filter(numbers, &(rem(&1, 2) == 0))
IO.puts "Doubled (short): #{inspect doubled_short}"
IO.puts "Even (short): #{inspect even_short}"Test Your HOF Knowledge
Higher-Order Functions are a cornerstone of functional programming in Elixir. Let's check your understanding.
Recursion & HOFs: Key Takeaways
Great job! In this lesson, you've grasped two fundamental concepts in functional Elixir:
- Recursion: A function calling itself, defined by a base case and a recursive step.
- Tail Call Optimization (TCO): An important Elixir feature for efficient, stack-safe recursion, often achieved with an accumulator.
- Higher-Order Functions (HOFs): Functions that take other functions as arguments or return them, like
Enum.map,Enum.filter, andEnum.reduce. - Anonymous Functions: Concise ways to define functions inline, often used with HOFs, including the
&1shorthand.
These tools are essential for writing expressive and powerful Elixir code. Keep practicing!
常见问题解答
「递归与高阶函数」课时是免费的吗？
是的 — 「递归与高阶函数」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Elixir & Phoenix: Scalable Backend Development 课程的其余内容，请升级到 CoddyKit PRO。 Elixir & Phoenix: Scalable Backend Development 课程共包含 4 节课。
「递归与高阶函数」这节课中我会学到什么？
理解递归这一函数式编程的基本概念，并探索用于抽象行为的高阶函数。 你通过在浏览器中直接运行的动手代码来练习 Elixir & Phoenix: Scalable Backend Development，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Elixir & Phoenix: Scalable Backend Development 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Elixir & Phoenix: Scalable Backend Development 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「递归与高阶函数」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Elixir & Phoenix: Scalable Backend Development 课中编写并运行代码吗？
能。每节 Elixir & Phoenix: Scalable Backend Development 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。