Question

我被赋予了一项任务，我一定错过了一些东西。提供的代码不是原始问题，而是相似的。我必须计算数组中有16岁或以上的人数。我已经试过了，但是无法解决。请，有人可以解释我在做什么错吗？

在任务中，我得到了一个对象数组：

var people = [{name:'Emma', age:15},{name:'Matt', age: 16}, {name:'Janet', age:17}]

我需要完成一项功能来计算16岁或16岁以上的人数。函数的开头已给出（即function correctAge(people){ //Complete }）

“示例代码”是我一直在玩的一些基本代码。 “不正确的尝试”是我的尝试，是我不断返回的代码，或者它的变体也是正确的...

请帮助

不正确的尝试：

var people = [
  {name: "Emma", age: 15},
  {name: "Matt", age: 16},
  {name: "Tom", age: 17}
];

function correctAge(array) {
  // Complete the function to return how many people are age 16+
  var count = 0;

  for (let i = 0; i < array.length; i++) {
    var obj = array.length[i];
    for (prop in obj) {
      if (prop[obj] >= 16) {
        count++;
      }
    }
    return count;
  }
}

console.log(correctAge(people));

示例代码：

var people = [
  {name: "Emma", age: 15},
  {name: "Matt", age: 16},
  {name: "Tom", age: 17}
];

function correctAge(people) {
  // Complete the function to return how many people are age 16+
}

Answer 1

您需要使用索引来拿走物体。

obj = array[i];

然后，您可以直接获取属性，而无需循环所有属性。

if (obj.age >= 16) {
    count++;
}

您可以将这两个部分放在一起进行检查，而无需使用其他变量obj。

if (array[i].age >= 16) {
    count++;
}

.age是对象的property accessor。

{
    name: 'Emma',
    age: 15       // <--
}

如果您喜欢单行方法，则可以减少数组并计算发生次数。

return array.reduce((count, { age }) => count + (age >= 16), 0);

Answer 2

使用数组的filter方法会简单得多：

function correctAge(people = [], age = 16){

    return people.filter( person => person.age > age ).length
}

Answer 3

df['Unnamed: 1'] = df['Unnamed: 1'].fillna(df['Top Holdings'].str.rsplit(n=1).str[0])

print (df)
   Top Holdings Unnamed: 1
0   aaa bb cc d  aaa bb cc
1   aaa bb cc d  aaa bb cc
2   aaa bb cc d  aaa bb cc
3   aaa bb cc d  aaa bb cc
4   aaa bb cc d  aaa bb cc
5   aaa bb cc d  aaa bb cc
6   aaa bb cc d  aaa bb cc
7   aaa bb cc d          s
8   aaa bb cc d          d
9   aaa bb cc d          f
10  aaa bb cc d  aaa bb cc

将上述代码行添加到函数中。

Answer 4

遍历数组，检查元素的属性是否与参数匹配并增加一个计数器。

下面的代码示例，名称和属性已更改，以保护无辜者。

const cars = [
  { make: 'Nissan', country: 'Japan' },
  { make: 'Ford', country: 'USA' },
  { make: 'Chevy', country: 'USA' },
  { make: 'Volvo', country: 'Sweden' },
  { make: 'Mitsubishi', country: 'Japan' },
];

function fromCountry(cars, country) {
  let count = 0;
  for(let i = 0; i < cars.length; i++) {
    if (cars[i].country === country) {
      count++;
    }
  }
  return count;
}

const fromCountry2 = (cars, country) => cars.reduce((count, car) => {
  car.country === country && count++;
  return count;
}, 0);

console.log(fromCountry(cars, 'Japan')); // 2
console.log(fromCountry(cars, 'Sweden')); // 1
console.log(fromCountry(cars, 'USA')); // 2
console.log(fromCountry(cars, 'Canada')); // 0

console.log(fromCountry2(cars, 'Japan')); // 2
console.log(fromCountry2(cars, 'Sweden')); // 1
console.log(fromCountry2(cars, 'USA')); // 2
console.log(fromCountry2(cars, 'Canada')); // 0

Answer 5

尝试此操作，您将获得结果；

var people = [{name:'Emma', age:15},{name:'Matt', age: 16}, {name:'Janet', age:17}];

const correctAge = function(age) {
 return people.filter(x => x.age < age).length;
}

console.log(correctAge(16));

Answer 6

Array.reduce()是对此的一种优雅解决方案-

function correctAge(array) {
  return array.reduce((total, person) => {
      return person.age >= 16 ? ++total : total;
    }, 0)
}

对于问题中的示例，它返回值2。

Answer 7

这里的大多数答案都集中在Array.filter()或Array.reduce()（我认为这是最合适的方法）的使用上。但是，我想指出如何修改您的“错误尝试”以使其真正起作用。这是我采取的一些纠正措施：

删除道具循环。您在这里只关心age属性，因此无需检查其他道具。（无论如何，prop[obj]实际上是向后的。应该是obj[prop]）
将return count;移动到外部for循环之外。
将array.length[i]替换为array[i]。 .length数组属性是整数，而不是数组或对象。

var people = [
  {name: "Emma", age: 15},
  {name: "Matt", age: 16},
  {name: "Tom", age: 17}
];

function correctAge(people) {
  // Complete the function to return how many people are age 16+
  var count = 0;

  for (let i = 0; i < people.length; i++) {
    var obj = people[i]; // <-- instead of array.length[i]
    if (obj.age >= 16) { // <-- obj.age instead of obj[prop]
      count++;
    }
  }
  return count; // <-- moved outside the loop
}

console.log(correctAge(people));

再次，但是使用Array.reduce()，这是一个很棒的汇总工具：

var people = [
  {name: "Emma", age: 15},
  {name: "Matt", age: 16},
  {name: "Tom", age: 17}
];

function correctAge(people) {
  // start at 0, then add 1 when obj.age >= 16, 0 otherwise
  return people.reduce(
    (acc, obj) => acc + (obj.age >= 16 ? 1 : 0), 0
  );
}

console.log(correctAge(people));

Array.filter()是最易读的方法imo：

var people = [
  {name: "Emma", age: 15},
  {name: "Matt", age: 16},
  {name: "Tom", age: 17}
];

function correctAge(people) {
  return people.filter(obj => obj.age >= 16).length;
}

console.log(correctAge(people));

...，最后，还有其他一些建议，这些建议可能不符合您当前的标准，但是为了将来的可读性/可维护性（尤其对于较大的代码库）而言，了解这些建议很重要：

我看到您在示例中使用的是let，这意味着您可以访问const。我鼓励您use const instead of let as much as possible。另外，由于const和let的工作方式不同于var（block-scoping），因此，我将完全停止使用var，以避免造成混淆。 const也可以在函数上使用，以防止被替换。
遵循一致的编码样式也有助于提高时间的可读性。如果您不了解它们，Standard或Airbnb之类的样式指南会特别有用，因为它们指向推理以及可用于执行这些规则的其他工具。（例如，我对const的看法最初来自Airbnb）
如功能编程范式immutability is also important中所鼓励。即使我们无法访问JS中的不可变对象（至少在没有库或Object.freeze()的帮助下），简单地将值视为不可变的习惯也具有相同的好处-和const通常会阻止您进行重新分配，从而使您半途而废。
命名很困难，但值得付出努力。例如，person比obj更具描述性。同样，correctAge本身的描述性还不够-如果不查找功能并查看其定义，您将不知道“正确的年龄”是什么。对于这个示例来说，这不是问题，因为它很小，但是像其他建议一样，最好在这样的较小示例上养成良好的习惯，这样您以后就不必再考虑了。
使用数组/可迭代方法时，我认为最好定义回调而不是数组包装器。这样可以使功能更加composable-也就是说，您可以轻松地混合/匹配它们。

...这导致了我的最终摘要：

const people = [
  {name: 'Matt', age: 15},
  {name: 'Emma', age: 15},
  {name: 'Matt', age: 16},
  {name: 'Tom', age: 17},
  {name: 'Matt', age: 37}
]

const personHasName = (name, person) => person.name === name
const personIsOfAge = (age, person) => person.age >= age

// Composition of personHasName and personIsOfAge
const mattsOver16 = person =>
    personHasName('Matt', person) && personIsOfAge(16, person)

console.log(
  people.filter(mattsOver16).length
)

JavaScript函数-计算对象数组中某个值的出现

7 个答案: