Javascript 下划线'；s类似的函数：u.contains vs.some和u.map vs.each

是否有理由使用一个而不是另一个？看起来u.some和u.map更容易使用或适用于更多情况（根据我有限的经验），但从阅读它的过程中，它们听起来似乎应该做同样的事情。我肯定还有其他的例子，我正在全神贯注地学习一些比较。

与
\uu。一些


如果列表中存在值，则返回
true
。如果列表是数组，则在内部使用
indexOf
。使用
fromIndex
从给定索引开始搜索


如果列表中的任何值通过谓词真值测试，则返回
true
。如果找到真实元素，则短路并停止遍历列表

.some
和
.contains
之间的主要区别在于，
contains
检查给定列表中是否存在给定项，
some
检查列表中的任何元素是否满足传递的谓词。所以，他们都在做不同的任务

\uu.每个
与
地图


迭代元素列表，依次生成一个iteratee函数


通过转换函数（iteratee）映射列表中的每个值，生成一个新的值数组

使用列表中的每个元素调用传递的函数（
iteratee
），以创建新的数组对象，但只使用每个元素调用传递的函数（
iteratee
）（注意：这不会创建数组）

基本上是
。每个
都是（var i=0；i
的
的函数等价物。同样，他们做的工作也不一样。
我认为@thefourtheye的答案已经足够解释了，但我认为添加一个例子也可能有所帮助

\包含
与
\部分
这里最大的区别是，
.contains
允许您提供值和索引，而
.some
允许您提供谓词

因此，例如，假设我们有一个包含前10个数字的数组
[1,2,3,4,5,6,7,8,9,10]
，我们如何检查数组是否包含数字5

我们可以使用
\包含
功能：

_.contains([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5); // True

我们也可以使用
。
函数，但它有点长：

_.some([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  return num === 5;
}); // True

但是，假设我们需要检查数组是否包含偶数？使用
\uu0.contains
很难做到这一点，但使用
\u0.contains可以做到以下几点：

_.some([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  return num % 2 === 0;
});

var newCollection = [];
_.each([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  newCollection.push(num * 2);
});
console.log(newCollection);

是的，这里有一个区别，
.contains
主要用于检查数组是否包含特定元素，
.some
可用于检查数组是否包含具有特定要求的元素

\uu.每个
与
地图
这两个函数都在整个数组中循环，但它们都有不同的含义。使用
。
每个都非常简单，您可以通过数组循环：

_.each([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  console.log(num); // Will print each number
});

另一方面，
.
函数允许您返回一些内容，它允许您将数组映射到新数组。假设你想要一个每个数字的数组，乘以2，你可以用
.map
：

var newCollection = _.map([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  return num * 2;
});
console.log(newCollection); // Will contain the numbers 2, 4, 6, 8, ...

是的，您可以通过一个
\来实现。每个
循环也可以通过以下方式实现：

_.some([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  return num % 2 === 0;
});

var newCollection = [];
_.each([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], function(num) {
  newCollection.push(num * 2);
});
console.log(newCollection);

但是
.map
只是一种简单易行的方法。
1）包含vs.some

我认为，可以说，contains是some的特例。
就是

_.contains( list, value ) 

这是一条捷径

_.some( list, function ( el ) { return value == 3; })

第二个变体太冗长了

在这种情况下，许多功能都会显示有用的快捷方式，例如：

var users = [
    { 'user': 'barney', 'age': 36, 'active': true },
    { 'user': 'fred',   'age': 40, 'active': false }
];

_.contains({ 'user': 'fred', 'age': 40 }, 'fred');

或

2）\地图与每个地图的对比

这些功能完全不同。用于集合转换的映射。如果输入的大小为N，则0.map的结果的大小也为N。换句话说，0.map是表达式-当需要转换输入集合的每个元素时使用它。
_.每个都只是for循环的快捷方式。它很有用，因为您不需要像中那样计算数组的长度

for (var i = 0, len = myArray.length; i < len; i++ ) {
}

for（变量i=0，len=myArray.length；i

当您正确使用u.map或u.each时，您将明确声明您的意图
 看看这些函数的返回值，它们是不一样的。我从使用中注意到了这一点。我并不总是很清楚为什么会这样，尽管我开始深入研究源代码以了解更多。我真的很想知道您是否可以帮助概括性能或有利于其中一种的情况。所有这些函数都是不同类型循环和递归的抽象。差异可能很微妙，但它们都有一个特定的用例，即使对于某些东西，您可以互换使用它们。这里没有任何问题不能通过阅读文档来回答——无需深入研究其源代码。除了重复文档之外，很难看到如何回答这个问题，这基本上就是这里的答案。谢谢！这就是我要找的，像这样的细节。map创建一个数组和0。每个数组和0都不创建，您可以使用0.contains和0.contains从索引中搜索，其中有些是谓词比较。任何其他细节都是好的。实际上，我只是在构建/测试我的代码时了解到了这一点。有些已经足够简单了，但按照我写的方式，contains不起作用。后来，我不得不将一个值与一个数组进行比较，结果显示了contains是多么的简单和有益，于是我又回去更改了389;。一些版本也需要处理类似的情况