Javascript 这个Array.prototype.find（）是如何工作的？

我不理解的是函数及其参数

fruit

，因为它没有被传递任何东西

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

…因为它什么都没有通过

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

它被传递了一些东西，你只是看不到代码在做它，它在

数组.prototype.find

方法的代码中。记住，这一行：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

console.log(inventory.find(findCherries));

…将

findCherries

（函数引用）的值传递到

find

，它不调用

findCherries

find

为数组中的每个条目执行一次，提供三个参数（其中只有一个

findCherries

使用）。第一个参数是该调用的数组项

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

Array.prototype.find

的完整polyfill有助于阅读技巧，因此让我们做一些类似但更简单的事情，以便您可以看到调用：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

// A bit like Array.prototype.find, but **not** the same; much simplified
function fakeFind(callback) {
  for (var index = 0; index < this.length; ++index) {
    var entry = this[index];
    //  vvvvvvvvvvvvvvvvvvvvvvvvvvvv---- This is where findCherries is called
    if (callback(entry, index, this)) {
      return entry;
    }
  }
  return undefined;
}

//有点像Array.prototype.find，但**不**相同；简化得多
函数fakeFind（回调）{
对于（var指数=0；指数

实时复制：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

//有点像Array.prototype.find，但**不**相同；简化得多
函数fakeFind（回调）{
对于（var指数=0；指数
…因为它什么都没有通过

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

它被传递了一些东西，你只是看不到代码在做它，它在
数组.prototype.find
方法的代码中。记住，这一行：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

console.log(inventory.find(findCherries));

…将
findCherries
（函数引用）的值传递到
find
，它不调用
findCherries
find
为数组中的每个条目执行一次，提供三个参数（其中只有一个
findCherries
使用）。第一个参数是该调用的数组项

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

Array.prototype.find
的完整polyfill有助于阅读技巧，因此让我们做一些类似但更简单的事情，以便您可以看到调用：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

// A bit like Array.prototype.find, but **not** the same; much simplified
function fakeFind(callback) {
  for (var index = 0; index < this.length; ++index) {
    var entry = this[index];
    //  vvvvvvvvvvvvvvvvvvvvvvvvvvvv---- This is where findCherries is called
    if (callback(entry, index, this)) {
      return entry;
    }
  }
  return undefined;
}

//有点像Array.prototype.find，但**不**相同；简化得多
函数fakeFind（回调）{
对于（var指数=0；指数

实时复制：

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));


//有点像Array.prototype.find，但**不**相同；简化得多
函数fakeFind（回调）{
对于（var指数=0；指数console.log（inventory.fakeFind（findCherries））如果您扩展函数，使其使用匿名函数，则更有意义

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

如果你看一下下面的代码片段，它会稍微解释一下

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));


var库存=[
{名称：'苹果'，数量：2}，
{名称：'香蕉'，数量：0}，
{名称：'樱桃'，数量：5}
];
函数查找鲱鱼（水果）{
return fruit.name==‘cherries’；
}
//除了额外的匿名函数外，这类函数也执行相同的操作
//但在这里你可以看到这个正在通过的“项目”
console.log（inventory.find(
函数（项）{返回findCherries（项）；}
));
//因为在上面的例子中，匿名函数具有相同的
//签名，它被重新命名，所以我们也可以
//直接打电话给findCherries。。
console.log（inventory.find（findCherries））如果您扩展函数，使其使用匿名函数，则更有意义

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

如果你看一下下面的代码片段，它会稍微解释一下

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));


var库存=[
{名称：'苹果'，数量：2}，
{名称：'香蕉'，数量：0}，
{名称：'樱桃'，数量：5}
];
函数查找鲱鱼（水果）{
return fruit.name==‘cherries’；
}
//除了额外的匿名函数外，这类函数也执行相同的操作
//但在这里你可以看到这个正在通过的“项目”
console.log（inventory.find(
函数（项）{返回findCherries（项）；}
));
//因为在上面的例子中，匿名函数具有相同的
//签名，它被重新命名，所以我们也可以
//直接打电话给findCherries。。
console.log（inventory.find（findCherries））
如果数组中有元素，则find（）方法返回数组中的值
数组满足提供的测试功能。否则未定义
返回

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

在您的代码片段中，
fruit
是原始数组中的一个项，i其值是数组中的一个项。
findCherries
将比较数组中的每个元素是否与属性
name
匹配（这是提供的测试函数）

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

您的
findCherries
回调将对数组中的每个值执行。当找到匹配项时，将返回结果

var inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

function findCherries(fruit) { 
  return fruit.name === 'cherries';
}

console.log(inventory.find(findCherries));

如果数组中有元素，则find（）方法返回数组中的值
数组satis