Erlang中的迭代

August 5, 2024

在Erlang中，循环的概念与传统的命令式编程语言中的循环有所不同。由于Erlang是一种函数式编程语言，它没有像for、while或do-while这样的传统循环结构。相反，Erlang使用递归和列表推导式等函数式编程技术来实现循环的功能。

以下是Erlang中实现循环的几种常见方法：

1. 递归

递归是Erlang中实现循环的主要方式。通过函数调用自身，可以模拟循环的行为。

1
2
3
4
5
6
7
8


% 计算列表中所有元素的和
sum_list(L) ->
    sum_list(L, 0).

sum_list([], Sum) ->
    Sum;
sum_list([H|T], Sum) ->
    sum_list(T, Sum + H).

在这个例子中，sum_list/2是一个递归函数，它接收一个列表和一个累计求和的值。当列表为空时，返回累计的和；否则，将列表的头元素加到累计和上，然后递归调用自身处理列表的其余部分。

2. 列表推导式

列表推导式是Erlang中另一种常见的循环结构，它允许你从一个列表生成另一个列表。

1
2
3


% 生成0到N-1的平方数列表
squares(N) ->
    [X * X || X <- lists:seq(1, N)].

在这个例子中，使用lists:seq/2生成从1到N的序列，然后使用列表推导式计算每个元素的平方。

3. `foreach`函数

Erlang标准库中的lists:foreach/2函数可以用来遍历列表并对每个元素执行一个函数。

1
2
3


% 打印列表中的每个元素
print_list(L) ->
    lists:foreach(fun(Elem) -> io:fwrite("~p~n", [Elem]) end, L).

在这个例子中，print_list/1函数使用lists:foreach/2遍历列表L，并对每个元素调用打印函数。

4. `map`函数

类似于foreach，lists:map/2函数可以用来遍历列表，并对每个元素应用一个函数，返回一个新的列表。

1
2
3


% 将列表中的每个元素加倍
double_list(L) ->
    lists:map(fun(Elem) -> Elem * 2 end, L).

5. `fold`函数

lists:foldl/3或lists:foldr/3函数可以用来遍历列表，并对列表中的元素进行累积处理。

1
2
3


% 使用fold计算列表的总和
sum_list_fold(L) ->
    lists:foldl(fun(Elem, Acc) -> Elem + Acc end, 0, L).

在这个例子中，sum_list_fold/1函数使用lists:foldl/3对列表L进行左折叠，累加每个元素的值。

6. `recursion`库

Erlang的recursion库提供了一些尾递归优化的循环结构，例如loop/3和recur/2。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


-module(loop_example).
-compile([{nowarn_unused_function}]).
-export([start/0]).

start() ->
    recursion:loop(
        fun loop/1,
        fun done/1,
        0
    ).

loop(Count) ->
    receive
        stop -> done(Count);
        _    -> io:fwrite("Count: ~p~n", [Count]),
                loop(Count + 1)
    end.

done(Count) ->
    io:fwrite("Done with count: ~p~n", [Count]).

在这个例子中，使用recursion:loop/3创建了一个循环，根据接收到的消息来决定是否停止循环。

通过这些方法，Erlang能够有效地实现循环逻辑，同时保持代码的清晰和函数式编程的特点。

Erlang中的递归和迭代器（或称为循环）在概念和实现方式上有一些显著的区别：

递归

递归是一种函数式编程范式，其中一个函数调用自身来重复执行任务或分解问题。在Erlang中，递归非常常见，因为它既简洁又表达力强。

递归的特点:

定义简单：递归函数通常只需要定义基本情形（base case）和递归情形（recursive case）。
自然表达：对于某些问题，递归提供了一种自然而直观的解决方案，如遍历树结构或处理列表。
栈安全：Erlang对尾递归进行了优化，即使在大量递归调用时也能保持栈空间的稳定。
可能的栈溢出：如果递归深度过大且不是尾递归，可能会导致栈溢出错误。

递归示例:

1
2


factorial(0) -> 1;
factorial(N) when N > 0 -> N * factorial(N - 1).

迭代器（循环）

在Erlang中，传统的迭代器如for、while等不存在。但是，可以使用其他方法来模拟迭代器的行为，例如使用递归或库函数。

迭代器的特点:

显式迭代：虽然Erlang没有传统意义上的迭代器，但可以使用递归或lists:foreach、lists:map等函数来实现迭代。
列表推导式：提供了一种简洁的方式来创建基于现有列表的新列表，通过应用一个函数到每个元素上。
高阶函数：如lists:foldl/foldr，可以用来在遍历列表的同时累积结果。
避免栈溢出：使用迭代器模式（如循环模拟）不会导致栈溢出，因为它们不依赖于调用栈。

迭代器模拟示例: 使用lists:foreach模拟迭代器：

1
2


print_list(L) ->
    lists:foreach(fun(Elem) -> io:fwrite("~p~n", [Elem]) end, L).

区别

语法和风格：递归是函数式编程的一部分，通常更简洁；迭代器则需要使用其他结构或函数来模拟。
内存和性能：递归（非尾递归）可能增加内存使用并有栈溢出的风险；迭代器模式通常对内存使用更友好。
适用场景：递归适合于可以自然分解为子问题的问题，迭代器适合于需要逐步处理集合元素的场景。

在Erlang中，推荐优先使用递归，特别是尾递归，因为它们更符合函数式编程的风格，同时也利用了Erlang的优化。然而，对于某些特定情况，使用迭代器模式可能更为合适。

1. 递归

2. 列表推导式

3. foreach函数

4. map函数

5. fold函数

6. recursion库

递归

迭代器（循环）

区别

3. `foreach`函数

4. `map`函数

5. `fold`函数

6. `recursion`库