Javascript 使用具有条件的对象数组

这里我们有一个对象数组：

var slides = [
{ id: 1, performance: 20, guided_phrases: ["I was sent", "I don't know"] },
{ id: 2, performance: 30, guided_phrases: ["to earth"] },
{ id: 3, performance: 40, guided_phrases: ["to protect you"] },
{ id: 4, performance: 15, guided_phrases: ["I was sent"] },
{ id: 5, performance: 50, guided_phrases: ["I was sent"] }
];

我想找到幻灯片的

id

，它的

引导短语
包含一个
性能最低的特定字符串（在
短语变量
中表示）

因此，如果我们有
让短语=“我被发送”然后输出应该是幻灯片id4，因为性能在幻灯片1、4和5中最低

我尝试过这段代码，但我需要一只手来找出记录id的简单方法：

let phrase = "I was sent";
let contain = [];
for(let i = 0; i < slides.length; i++){

   if(slides[i].guided_phrases.includes(phrase)){

     contain.push(slides[i].performance)
     console.log(contain)
     let max = Math.min.apply(null, contain); 
     console.log(max)
   }
}

让短语=“我被发送”；
让包含=[]；
for（设i=0；i
以下是使用一些ES6的可能解决方案：


var幻灯片=[
{id:1，性能：20，引导短语：[“我被派来”，“我不知道”]}，
{id:2，performance:30，引导短语：[“to earth”]}，
{id:3，性能：40，引导短语：[“保护你”]}，
{id:4，性能：15，引导短语：[“我被发送”]}，
{id:5，性能：50，引导短语：[“我被发送”]}
];
让短语“我被派去”；
const findLowestId=（arr）=>slides.filter（x=>{
const reg=new RegExp（短语）
返回x.u短语。查找（y=>y.match（reg））
}).sort（（a，b）=>a.performance>b.performance）[0]。id
console.log（findLowestId（slides））
我会选择：

const slides = [
{ id: 1, performance: 20, guided_phrases: ["I was sent", "I don't know"] },
{ id: 2, performance: 30, guided_phrases: ["to earth"] },
{ id: 3, performance: 40, guided_phrases: ["to protect you"] },
{ id: 4, performance: 15, guided_phrases: ["I was sent"] },
{ id: 5, performance: 50, guided_phrases: ["I was sent"] }
];

const logID = (phrase) => {
  console.log(slides.filter(x => x.performance === Math.min(...slides.filter(slide => slide.guided_phrases.includes(phrase)).map(x => x.performance)))[0].id);
}

logID('I was sent');


让短语=“我被发送”；
让contain=null；
设id=null；
for（设i=0；i幻灯片[i]。性能）{
包含=幻灯片[i]。性能；
id=slides[i].id；
}
}
}
}
console.log（id）；
我只使用了一个循环


var幻灯片=[
{id:1，性能：20，引导短语：[“我被派来”，“我不知道”]}，
{id:2，performance:30，引导短语：[“to earth”]}，
{id:3，性能：40，引导短语：[“保护你”]}，
{id:4，性能：15，引导短语：[“我被发送”]}，
{id:5，性能：50，引导短语：[“我被发送”]}
];
const search='我被发送'；
设结果=-1；
让性能=0；
slides.forEach（（幻灯片，索引）=>{
if（幻灯片引导的内容包括（搜索）>-1&&performancelog（'Result:'，Result）如果您想要一个可读且易于理解的函数，我会这样做：

const lowestPerformance = (slides, phrase) => {
    let currLowest = null;

    for (let i = 0; i < slides.length; i++) {
        let slide = slides[i];

        if (slide.guided_phrases.includes(phrase)) {
            currLowest =  ((currLowest === null) || slide.performance < (currLowest.performance)) ? slide : currLowest;
        }
    }

    return currLowest;
}

const lowestPerformance=（幻灯片、短语）=>{
设currLowest=null；
for（设i=0；i
您是否可以按性能对
进行排序，然后使用
查找
？处理它…关闭投票者，请提供原因…您不需要将性能存储在
包含
数组中。您应该只在变量中存储最后一个对象（或其索引），然后在找到性能优于最后一个的匹配对象时更新该对象。然后记录它的id。你要多次搜索
短语吗？如果是，您可以创建一个对象或
映射
，每个唯一短语作为键，最低
性能
的
id
作为其值。现在，只需
mappingObject[phrase]
const lowestPerformance = (slides, phrase) => {
    let currLowest = null;

    for (let i = 0; i < slides.length; i++) {
        let slide = slides[i];

        if (slide.guided_phrases.includes(phrase)) {
            currLowest =  ((currLowest === null) || slide.performance < (currLowest.performance)) ? slide : currLowest;
        }
    }

    return currLowest;
}