如何用 C# 中的函数语句替换 for 循环？

Question

一位同事曾经说过，每次我写一个 for 循环时，上帝都在杀死一只小猫。

当被问及如何避免 for 循环时，他的答案是使用函数式语言。但是，如果您陷入非函数式语言（例如 C#）的困境，有哪些技术可以避免 for 循环或通过重构消除它们？也许使用 lambda 表达式和 LINQ？如果是这样，怎么办？

问题

所以问题归结为：

1. 为什么 for 循环不好？或者，在什么情况下需要避免 for 循环以及为什么？
2. 您能否提供 C# 代码示例来说明它之前（即使用循环）和之后不使用循环的情况？

Answer 1

当您操作某些数据集并想要转换、过滤或聚合元素时，函数构造通常比 for 循环更清楚地表达您的意图。

当您想要重复执行某些操作时，循环非常合适。

---

例如，比

int x = array.Sum();

以下更清楚地表达您的意图

int x = 0;
for (int i = 0; i < array.Length; i++)
{
    x += array[i];
}

Answer 2

为什么 for 循环不好？或者说，在什么情况下
上下文是要避免的 for 循环
为什么？

如果您的同事有函数式编程，那么他可能已经熟悉避免 for 循环的基本原因：

折叠/映射/过滤涵盖了列表遍历的大多数用例，并且非常适合函数组合。 For 循环不是一个好的模式，因为它们不可组合。

大多数时候，您会遍历列表来折叠（聚合）、映射或过滤列表中的值。这些高阶函数已经存在于每种主流函数式语言中，因此您很少看到函数式代码中使用 for 循环习惯用法。

高阶函数是函数组合的基础，这意味着您可以轻松地将简单的函数组合成更复杂的函数。

举一个重要的例子，请考虑命令式语言中的以下内容：

let x = someList;
y = []
for x' in x
    y.Add(f x')

z = []
for y' in y
    z.Add(g y')

在函数式语言中，我们会编写 map g (map fx)，或者我们可以使用 消除中间列表地图（f.g）x。现在，原则上我们可以从命令式版本中消除中间列表，这会有所帮助，但效果不大。

命令式版本的主要问题在于 for 循环是实现细节。如果你想改变这个函数，你就改变它的实现——最终你会修改很多代码。

举个例子，您将如何强制编写 map g (filter fx) ？好吧，由于您无法重用原始的映射和映射代码，因此您需要编写一个新的函数来进行过滤和映射。如果你有 50 种映射方式和 50 种过滤方式，你如何需要 50^50 个函数，或者你需要使用命令模式模拟将函数作为第一类参数传递的能力（如果你曾经尝试过函数式编程）在 Java 中，你就会明白这将是一场多么可怕的噩梦）。

回到功能宇宙，您可以概括 map g (map fx)，让您可以用 filter 或 filter 替换 map code>fold 根据需要：

let apply2 a g b f x = a g (b f x)

并使用 apply2 map g filter f 或 apply2 map g map f 或 apply2 filter g filter f 调用它代码> 或任何你需要的东西。现在，您可能永远不会在现实世界中编写这样的代码，您可能会使用以下方法来简化它：

let mapmap g f = apply2 map g map f
let mapfilter g f = apply2 map g filter f

高阶函数和函数组合为您提供了命令式代码无法获得的抽象级别。

抽象出循环的实现细节可以让您无缝地将一个循环替换为另一个循环。

请记住，for 循环是一种实现细节。如果需要更改实现，则需要更改每个 for 循环。

映射/折叠/过滤抽象掉循环。因此，如果您想更改循环的实现，可以在这些函数中更改它。

现在您可能想知道为什么要抽象出循环。考虑将项目从一种类型映射到另一种类型的任务：通常，项目一次映射一个，顺序且独立于所有其他项目。大多数时候，像这样的映射是并行化的主要候选者。

不幸的是，顺序映射和并行映射的实现细节不可互换。如果您的代码中有大量顺序映射，并且希望将它们替换为并行映射，那么您有两种选择：在代码库中复制/粘贴相同的并行映射代码，或者将映射逻辑抽象为两个函数map 和 pmap。一旦你选择了第二条路，你就已经深入函数式编程领域了。

如果您了解函数组合的目的并抽象出实现细节（甚至像循环这样琐碎的细节），您就可以开始理解函数式编程如何以及为何如此强大。

Answer 3

1. For 循环还不错。保留 for 循环有很多非常充分的理由。
2. 您通常可以通过在 C# 中使用 LINQ 重新设计 for 循环来“避免”for 循环，LINQ 提供了更具声明性的语法。根据具体情况，这可能是好是坏：

比较以下内容：

var collection = GetMyCollection();
for(int i=0;i<collection.Count;++i)
{
     if(collection[i].MyValue == someValue)
          return collection[i];
}

与 foreach：

var collection = GetMyCollection();
foreach(var item in collection)
{
     if(item.MyValue == someValue)
          return item;
}

与 LINQ： 就

var collection = GetMyCollection();
return collection.FirstOrDefault(item => item.MyValue == someValue);

我个人而言，所有三个选项都有自己的位置，我都使用它们。这是使用最适合您的场景的选项的问题。

Answer 4

for 循环没有任何问题，但以下是人们可能更喜欢函数式/声明式方法（如 LINQ）的一些原因，在这种方法中，您可以声明您想要的内容，而不是如何获得它：-

1. 函数式方法可能更容易使用 PLINQ 手动并行化或由编译器。随着 CPU 转向更多内核，这可能会变得更加重要。

2. 函数式方法可以更轻松地在多步骤过程中实现延迟求值，因为您可以将中间结果作为尚未完全求值的简单变量传递到下一步，而不是完全求值第一步然后传递下一步的集合（或者不使用单独的方法和yield语句来实现相同的程序）。

3. 函数式方法通常更短且更易于阅读。

4. 函数式方法通常会消除 for 循环中的复杂条件体（例如 if 语句和“继续”语句），因为您可以将 for 循环分解为逻辑步骤 - 选择所有匹配的元素，对它们执行操作，.. .

Answer 5

For 循环不会杀人（或小猫、小狗或小东西）。人们杀人。
For 循环本身并不坏。然而，就像其他事情一样，使用它们的方式可能会很糟糕。

Answer 6

有时你不只杀死一只小猫。

for (int i = 0; i < kittens.Length; i++)
{
小猫[i].Kill();
}

你会把他们都杀掉。

Answer 7

您可以充分重构代码，这样您就不会经常看到它们。一个好的函数名肯定比 for 循环更具可读性。

以 AndyC 中的示例：

Loop

// mystrings is a string array
List<string> myList = new List<string>();
foreach(string s in mystrings)
{
    if(s.Length > 5)
    {
        myList.add(s);
    }
}

Linq

// mystrings is a string array
List<string> myList = mystrings.Where<string>(t => t.Length > 5)
                               .ToList<string();

无论您在函数中使用第一个还是第二个版本，它都更容易阅读

var filteredList = myList.GetStringLongerThan(5);

现在这是一个过于简单的示例，但您明白我的意思。

Answer 8

你同事的说法不对。 For 循环本身并不坏。它们干净、可读并且不太容易出错。

Answer 9

你的同事关于 for 循环在所有情况下都很糟糕的观点是错误的，但正确的是它们可以在功能上重写。

假设您有一个如下所示的扩展方法：

void ForEach<T>(this IEnumerable<T> collection, Action <T> action)
{
    foreach(T item in collection)
    {
        action(item)
    }
}

然后您可以编写一个如下所示的循环：

mycollection.ForEach(x => x.DoStuff());

这现在可能不是很有用。但是，如果您随后将 ForEach 扩展方法的实现替换为使用多线程方法，那么您将获得并行性的优势。

这显然并不总是有效，这种实现仅在循环迭代完全相互独立时才有效，但它可能很有用。

另外：永远要警惕那些说某些编程结构总是错误的人。

Answer 10

一个简单的（实际上毫无意义的）示例：

Loop

// mystrings is a string array
List<string> myList = new List<string>();
foreach(string s in mystrings)
{
    if(s.Length > 5)
    {
        myList.add(s);
    }
}

Linq

// mystrings is a string array
List<string> myList = mystrings.Where<string>(t => t.Length > 5).ToList<string>();

在我的书中，第二个看起来更整洁和简单，尽管第一个没有任何问题。

Answer 11

有时，如果存在更有效的替代方案，则 for 循环会很糟糕。例如搜索，对列表进行排序然后使用快速排序或二进制排序可能会更有效。或者当您迭代数据库中的项目时。在数据库中使用基于集合的操作通常比迭代项目更有效。

否则，如果 for 循环，尤其是 for-each 最有意义并且可读，那么我会选择它，而不是将其分解为不那么直观的东西。我个人不相信这些听起来很宗教的“总是这样做，因为这是唯一的方法”。相反，最好有指导方针，并了解在什么情况下适合应用这些指导方针。你问“为什么”是件好事！

Answer 12

可以说，For 循环是“糟糕的”，因为它意味着 CPU 中的分支预测，并且当分支预测失败时，性能可能会下降。

但是 CPU（分支预测准确度为 97%）和具有循环展开等技术的编译器，使得循环性能的降低可以忽略不计。

Answer 13

如果直接抽象 for 循环，您会得到：

void For<T>(T initial, Func<T,bool> whilePredicate, Func<T,T> step, Action<T> action)
{
    for (T t = initial; whilePredicate(t); step(t))
    {
        action(t);
    }
}

从函数式编程的角度来看，我遇到的问题是 void 返回类型。它本质上意味着 for 循环不能很好地与任何东西组合。因此，我们的目标不是从 for 循环到某个函数的 1-1 转换，而是从功能角度思考并避免做不组合的事情。不要考虑循环和行动，而是考虑整个问题以及您要映射的内容和映射到的内容。

Answer 14

for 循环始终可以替换为不涉及使用循环的递归函数。递归函数是一种更具功能性的编程方式。

但如果你盲目地用递归函数代替 for 循环，那么小猫和小狗都会死亡数以百万计，你也会被迅猛龙杀死。

好的，这是一个例子。但请记住，我不主张进行此更改！

for 循环

for (int index = 0; index < args.Length; ++index)
    Console.WriteLine(args[index]);

可以更改为递归函数调用

WriteValuesToTheConsole(args, 0);


static void WriteValuesToTheConsole<T>(T[] values, int startingIndex)
{
    if (startingIndex < values.Length)
    {
        Console.WriteLine(values[startingIndex]);
        WriteValuesToTheConsole<T>(values, startingIndex + 1);
    }
}

这对于大多数值来说应该是一样的，但它不太清晰，效率较低，并且如果数组太大，可能会耗尽堆栈。

Answer 15

您的同事可能会建议，在涉及数据库数据的某些情况下，最好在查询时使用聚合 SQL 函数，例如 Average() 或 Sum()，而不是在 ADO .NET 中在 C# 端处理数据。应用。

否则，如果使用得当，for 循环会非常有效，但要意识到，如果您发现自己将它们嵌套到三个或更多顺序，则可能需要一种更好的算法，例如涉及递归、子例程或两者的算法。例如，冒泡排序在最坏情况（逆序）情况下的运行时间为 O(n^2)，但递归排序算法仅为 O(n log n)，这要好得多。

希望这有帮助。

• 吉姆

Answer 16

任何语言中的任何构造都是有原因的。它是用来完成任务的工具。意味着结束。在每种情况下，都有适当使用它的方式，即以清晰简洁的方式并在语言的精神范围内和滥用它的方式。这适用于严重错位的 goto 语句以及 for 循环难题，以及 while、do-while、switch/case、if-then-else 等。如果 for 循环是适合您的工具在做时，使用它，你的同事将需要接受你的设计决策。

Answer 17

这取决于循环中的内容，但他/她可能指的是递归函数

    //this is the recursive function
    public static void getDirsFiles(DirectoryInfo d)
    {
        //create an array of files using FileInfo object
        FileInfo [] files;
        //get all files for the current directory
        files = d.GetFiles("*.*");

        //iterate through the directory and print the files
        foreach (FileInfo file in files)
        {
            //get details of each file using file object
            String fileName = file.FullName;
            String fileSize = file.Length.ToString();
            String fileExtension =file.Extension;
            String fileCreated = file.LastWriteTime.ToString();

            io.WriteLine(fileName + " " + fileSize + 
               " " + fileExtension + " " + fileCreated);
        }

        //get sub-folders for the current directory
        DirectoryInfo [] dirs = d.GetDirectories("*.*");

        //This is the code that calls 
        //the getDirsFiles (calls itself recursively)
        //This is also the stopping point 
        //(End Condition) for this recursion function 
        //as it loops through until 
        //reaches the child folder and then stops.
        foreach (DirectoryInfo dir in dirs)
        {
            io.WriteLine("--------->> {0} ", dir.Name);
            getDirsFiles(dir);
        }

    }

Answer 18

问题是循环是否会改变状态或引起副作用。如果是这样，请使用 foreach 循环。如果没有，请考虑使用 LINQ 或其他函数结构。

请参阅“foreach”与“ForEach” 在 Eric Lippert 的博客上。