如何使用 for 循环找到对象中的最大数？

Question

这是我的数据集：

let items = [
  {
    itemName: "Effective Programming Habits",
    type: "book",
    price: 13.99
  },
  {
    itemName: "Creation 3005",
    type: "computer",
    price: 299.99
  },
  {
    itemName: "Finding Your Center",
    type: "book",
    price: 15.00
  }
]

我正在尝试使用 for 循环查找并返回此对象中的最大数字。我知道可能有更简单、更有效的路线，但我专门研究 for 循环。

我不想简单地返回最高价格，而是希望返回最高价格项目的 itemName。我的代码目前只返回最大价格：299.99，而不是 itemName“Creation 3005”。我将如何使用 for 循环返回此信息？这是我目前所拥有的。

function mostExpensiveItemName(items) {
  let expensive = items[0].price || null; 
  let number = null;
  let name = null;
  for (let i = 0; i < items.length; i++) {
    number = items[i].price;
    expensive = Math.max(expensive, number); 
    }
   return expensive;
  }

Answer 1

function mostExpensiveItemName(items) {
   let expensive = items[0]; 
   let number = null;
   let name = null;
   for (let i = 0; i < items.length; i++) {
      number = items[i];
      expensive = expensive.price < number.price ? number:;
   }
   return expensive;
}

Answer 2

我会做这样的事情。它更简洁、更具表现力，而且您不会将两个不同的问题混为一谈：

• 找到最贵的商品，然后
• 确定其名称

function mostExpensiveItemName(items) {
  let item = mostExpensiveItem(items);
    return item ? item.Name : undefined;
}

function mostExpensiveItem(items) {
  let max;

  for ( const item of items ) {
     max = !item                  ? item   // 1st item in list
         : item.price > max.price ? item   // replace existing w/new most-expensive item
         :                          max  ; // keep existing
  }

  return max ;
}

Answer 3

如果您决定寻找for 循环的替代方案，使用reduce 可以非常容易地解决这些问题。

const selectHigherPrice = (state, item) => state.price > item.price ? state : item

const initialState = items[0]

items.reduce(selectHigherPrice, initialState)

// One line
items.reduce((state, item) => state.price > item.price ? state : item)

• state 被初始化为items 列表中的第一项
• 为数组中的每个项目调用selectHigherPrice 函数
• 如果当前state.price 属性大于item.price 属性：
  • state 返回
  • 否则，item 将被返回并在列表中的下一项调用 selectHigherPrice 时成为 state 变量。

如果您确定您的列表将包含项目，您可以省略第二个参数

Answer 4

我会这样做：

function mostExpensive(objArray){
  const m = objArray.map(o=>o.price);
  return objArray[m.indexOf(Math.max(...m))];
}
let items = [
  {
    itemName: "Effective Programming Habits",
    type: "book",
    price: 13.99
  },
  {
    itemName: "Creation 3005",
    type: "computer",
    price: 299.99
  },
  {
    itemName: "Finding Your Center",
    type: "book",
    price: 15.00
  }
];
const me = mostExpensive(items);
console.log(me); console.log(me.price);

Answer 5

你可以像这样使用forEach

let items = [
  {
    itemName: "Effective Programming Habits",
    type: "book",
    price: 13.99
  },
  {
    itemName: "Creation 3005",
    type: "computer",
    price: 299.99
  },
  {
    itemName: "Finding Your Center",
    type: "book",
    price: 15.00
  }
]

let maxPrice = 0, product;
items.forEach(el => {
  if(el.price > maxPrice){ 
     maxPrice = el.price;
     product = Object.assign({}, el); // for make sure you made a new copy not a reference 
  }
});

console.log(product, maxPrice)

Answer 6

仅当您迭代的商品价格较高时才重新分配外部变量：

let items = [
  {
    itemName: "Effective Programming Habits",
    type: "book",
    price: 13.99
  },
  {
    itemName: "Creation 3005",
    type: "computer",
    price: 299.99
  },
  {
    itemName: "Finding Your Center",
    type: "book",
    price: 15.00
  }
];
function mostExpensiveItemName(items) {
  let highestPriceSoFar = 0;
  let nameOfHighestPriceSoFar;
  for (const { itemName, price } of items) {
    if (price > highestPriceSoFar) {
      highestPriceSoFar = price;
      nameOfHighestPriceSoFar = itemName;
    }
  }
  console.log(nameOfHighestPriceSoFar);
}
mostExpensiveItemName(items);