下面是一个Scala中使用列表的例子:map返回列表，foreach不返回任何内容。

def map(f: Int ⇒ Int): List[Int]
def foreach(f: Int ⇒ Unit): Unit

map返回函数f作用于每个列表元素后得到的列表:

scala> val list = List(1, 2, 3)
list: List[Int] = List(1, 2, 3)

scala> list map (x => x * 2)
res0: List[Int] = List(2, 4, 6)

Foreach只是对每个元素应用f:

scala> var sum = 0
sum: Int = 0

scala> list foreach (sum += _)

scala> sum
res2: Int = 6 // res1 is empty

如果你特别谈论Javascript，区别在于map是一个循环函数，而forEach是一个迭代器。

当您希望对列表的每个成员应用操作并将结果作为新列表返回时，使用map，而不影响原始列表。

当您想在列表的每个元素的基础上做一些事情时，请使用forEach。例如，您可能正在向页面添加内容。从本质上讲，当你想要“副作用”时，它是很好的。

其他区别:forEach不返回任何内容(因为它实际上是一个控制流函数)，传入函数获得对索引和整个列表的引用，而map返回新的列表，只传入当前元素。

不同。

Foreach遍历一个列表，并对每个列表成员执行一些具有副作用的操作(例如将每个成员保存到数据库中)

Map遍历一个列表，转换该列表的每个成员，并返回另一个具有已转换成员的相同大小的列表(例如将字符串列表转换为大写)

简单的回答:map和forEach是不同的。另外，非正式地说，map是forEach的严格超集。

长回答:首先，让我们提出forEach和map的一行描述:

forEach遍历所有元素，在每个元素上调用所提供的函数。 Map遍历所有元素，在每个元素上调用所提供的函数，并通过记住每个函数调用的结果来生成转换后的数组。

在许多语言中，forEach通常被称为each。下面的讨论使用JavaScript仅供参考。它真的可以是任何其他语言。

现在，让我们分别使用这些函数。

使用forEach:

任务1:编写printSquares函数，该函数接受数字数组arr，并打印其中每个元素的平方。

解决方案1:

var printSquares = function (arr) {
    arr.forEach(function (n) {
        console.log(n * n);
    });
};

使用地图:

任务2:编写一个函数selfDot，它接受一个数字数组arr，并返回一个数组，其中每个元素都是arr中相应元素的平方。

旁白:在这里，在俚语中，我们试图平方输入数组。正式地说，我们试着计算它与自身的点积。

解决方案2:

var selfDot = function (arr) {
    return arr.map(function (n) {
        return n * n;
    });
};

map如何是forEach的超集?

您可以使用map来解决任务1和任务2。但是，您不能使用forEach来解决任务2。

在解决方案1中，如果简单地用map替换forEach，解决方案仍然有效。然而，在解决方案2中，用forEach替换map将破坏之前的工作解决方案。

在map方面实现forEach:

实现map优势的另一种方法是根据map实现forEach。由于我们是优秀的程序员，我们不会沉迷于名称空间污染。我们将调用forEach。

Array.prototype.each = function (func) {
    this.map(func);
};

现在，如果你不喜欢毫无意义的原型，你可以这样做:

var each = function (arr, func) {
    arr.map(func); // Or map(arr, func);
};

所以,嗯. .forEach为什么会存在?

答案是效率。如果您对将一个数组转换为另一个数组不感兴趣，为什么要计算转换后的数组呢?只是为了把它扔掉?当然不是!如果你不想做变换，你就不应该做变换。

因此，虽然map可以用于解决任务1，但它可能不应该使用。因为每个人都是正确的候选人。

---

最初的回答:

虽然我在很大程度上同意@madlep的回答，但我想指出map()是forEach()的严格超集。

是的，map()通常用于创建一个新数组。但是，它也可以用来改变当前数组。

这里有一个例子:

var a = [0, 1, 2, 3, 4], b = null;
b = a.map(function (x) { a[x] = 'What!!'; return x*x; });
console.log(b); // logs [0, 1, 4, 9, 16] 
console.log(a); // logs ["What!!", "What!!", "What!!", "What!!", "What!!"]

在上面的例子中，a被方便地设置为a[i] === i对于i < a.length。尽管如此，它还是展示了map()的强大功能。

下面是map()的官方描述。注意map()甚至可能改变调用它的数组!冰雹(地图)。

希望这对你有所帮助。

---

编辑2015年11月10日:增加详细说明。

array . prototype .map方法和array . prototype . foreach方法都非常相似。

运行如下代码:http://labs.codecademy.com/bw1/6#:workspace

var arr = [1, 2, 3, 4, 5];

arr.map(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
});

console.log();

arr.forEach(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
});

它们给出了完全相同的结果。

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

但当你运行以下代码时，扭转就来了:-

这里我只是简单地分配了map和forEach方法返回值的结果。

var arr = [1, 2, 3, 4, 5];

var ar1 = arr.map(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
    return val;
});

console.log();
console.log(ar1);
console.log();

var ar2 = arr.forEach(function(val, ind, arr){
    console.log("arr[" + ind + "]: " + Math.pow(val,2));
    return val;
});

console.log();
console.log(ar2);
console.log();

现在的结果有些棘手!

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

[ 1, 2, 3, 4, 5 ]

arr[0]: 1
arr[1]: 4
arr[2]: 9
arr[3]: 16
arr[4]: 25

undefined

结论

array .prototype.map返回一个数组，但array .prototype. foreach不返回。因此，您可以在传递给map方法的回调函数中操作返回的数组，然后返回它。

foreach只遍历给定的数组，所以你可以在遍历数组时做你的事情。

最“明显”的区别是map将结果累积到一个新的集合中，而foreach仅用于执行本身。

但这里有一些额外的假设:因为map的“目的”是新的值列表，所以执行顺序并不重要。事实上，一些执行环境会生成并行代码，甚至引入一些记忆来避免调用重复值，或者引入惰性来避免调用一些值。

另一方面，Foreach是专门用于副作用的;因此顺序很重要，而且通常不能并行。