如何在对象数组中找到保存最高值的对象？

Question

我有一个数组，其中包含名为学生的几个对象，每个对象的学生有几个属性，其中之一是一个名为成绩的数组。

我需要创建一个循环遍历学生数组并查找哪个学生对象在其成绩数组内部具有最高成绩的函数。

目前我能够找到最高分，但无法理解如何追溯到它属于哪个学生。

这里的功能看起来像一个片段：

function bestStudent() { 
    var bestGrade = 0; 
    var student; 
    for(i=0; i < studentArr.length; i++) { 
     var student = studentArr[i]; 
     grades = student.grades; 
     for(g = 0; g <grades.length; g++){ 
      if(grades[g] > bestGrade) { 
       bestGrade = grades[g];  
      } 
     } 

    }  
} 

Answer 1

的总体思路是：您可以将您的学生与他们的成绩排列第一映射到学生的阵列及其档次最高为了方便使用并避免多次查找最大分数计算，然后查找最大的学生最高分数。

只是一个例子：

var students = [ 
 
    { 
 
    name: "Student 1", 
 
    grades: [ 65, 61, 67, 70 ] 
 
    }, 
 
    { 
 
    name: "Student 2", 
 
    grades: [ 50, 51, 53, 90 ] 
 
    }, 
 
    { 
 
    name: "Student 3", 
 
    grades: [ 0, 20, 40, 60 ] 
 
    } 
 
]; 
 
    
 
var highestGrades = students.map(function(stud, ind) { 
 
    // return a student's name and his highest grade (1) 
 
    return { 
 
    name: stud.name, 
 
    highestGrade: Math.max.apply(Math, stud.grades) // get a student's highest grade 
 
    }; 
 

 
    // or return index and use it to access original value: (2) 
 
    // return { 
 
    // index: ind, 
 
    // highestGrade: Math.max.apply(Math, stud.grades) 
 
    // }; 
 

 
    // or return the whole student: (3) 
 
    // return { 
 
    // student: stud, 
 
    // highestGrade: Math.max.apply(Math, stud.grades) 
 
    // }; 
 

 
    // or just add 'highestGrade' property to object without modifying 
 
    // if it's ok for you to have intermediate properties in your object: (4) 
 
    // stud.highestGrade = Math.max.apply(Math, stud.grades); 
 
    // return stud; 
 
}); 
 

 
// this can be done in O(n), not in O(N * logN) if required: 
 
var bestStudent = highestGrades.sort(function(a, b) { 
 
    return b.highestGrade - a.highestGrade; 
 
})[0]; // sort by highest grade desc and return the first (the best) one 
 

 
// Here we have bestStudent with his name according to map function: 
 
console.log(bestStudent.name + " has the highest score of " + bestStudent.highestGrade); // (1) 
 
// console.log(students[bestStudent.index].name + " has the highest score of " + bestStudent.highestGrade); // (2) 
 
// console.log(bestStudent.student.name + " has the highest score of " + bestStudent.highestGrade); // (3) 
 
// console.log(bestStudent.name + " has the highest score of " + bestStudent.highestGrade); // (4)

，使其返回整个学生作为结果，或它的索引，或者其特定的属性可以重写该代码。如果您的对象具有额外的中间属性，那么也可以将highestGrade属性添加到原始对象。这取决于你，这个想法并没有改变:)

这段代码很长，但它是可读的，使算法清晰的想法，这是非常重要的，因为你是一个初学者。
如果你和你的团队是更短但更复杂代码的粉丝，那么你可以轻松地重写它。
只是这样的事情：

var students = [ 
 
    { 
 
    name: "Student 1", 
 
    grades: [ 65, 61, 67, 70 ] 
 
    }, 
 
    { 
 
    name: "Student 2", 
 
    grades: [ 50, 51, 53, 90 ] 
 
    }, 
 
    { 
 
    name: "Student 3", 
 
    grades: [ 0, 20, 40, 60 ] 
 
    } 
 
]; 
 

 
var bestStudent = students.map(function(stud) { 
 
    stud.highestGrade = Math.max.apply(Math, stud.grades); 
 
    return stud; 
 
}).sort(function(a, b) { 
 
    return b.highestGrade - a.highestGrade; 
 
})[0]; 
 

 
console.log(bestStudent);

Answer 2

通过使用相同的功能，可以存储位置或适当的领域

function bestStudent() { 
     var bestStudent = {}; 
     bestStudent.bestGrade = 0; 
     var student; 
     for(i=0; i < studentArr.length; i++) { 
      var student = studentArr[i]; 
      grades = student.grades; 
      for(g = 0; g <grades.length; g++){ 
      if(grades[g] > bestStudent.bestGrade) { 
       bestStudent.bestGrade = grades[g]; 
       bestStudent.name = studentArr[i].name;  
      } 
      } 

     } 

     return bestStudent; 
    } 

Answer 3

\t var students = [ 
 
\t \t { 
 
\t \t \t name: "Student 1", 
 
\t \t \t grades: [ 
 
\t \t \t \t 90, 98, 80 
 
\t \t \t ], 
 
\t \t \t getMyHighest: function(){ 
 
\t \t \t \t return Math.max.apply(Math, this.grades); 
 
\t \t \t } 
 
\t \t }, 
 
\t \t { 
 
\t \t \t name: "Student 2", 
 
\t \t \t grades: [ 
 
\t \t \t \t 75, 85, 79 
 
\t \t \t ], 
 
\t \t \t getMyHighest: function(){ 
 
\t \t \t \t return Math.max.apply(Math, this.grades); 
 
\t \t \t } 
 
\t \t } 
 
\t \t , 
 
\t \t { 
 
\t \t \t name: "Student 3", 
 
\t \t \t grades: [ 
 
\t \t \t \t 75, 85, 99 
 
\t \t \t ], 
 
\t \t \t getMyHighest: function(){ 
 
\t \t \t \t return Math.max.apply(Math, this.grades); 
 
\t \t \t } 
 
\t \t } 
 
\t ]; 
 
\t 
 
\t var student = students.sort(function(f, l) { 
 
\t return l.getMyHighest() - f.getMyHighest(); 
 
\t })[0]; 
 

 
console.log(student);

Answer 4

使用lodash.js做事情容易:)

var students=[{Grades:[1,2,3]},{Grades:[5,4,3]},{Grades:[7,77,4]}]; 


var studentWithBestGrade=_.map(students,function(student,position){ 

       return [position,_.max(student.Grades)]; 

}); 


console.log(studentWithBestGrade) //[[0,3],[1,5],[2,77]] 

发现JSFIDDLE

Answer 5

我的解决办法是用减少JS

只有一次学生：

var bestStudent = students.reduce(function(a, student){ 
    return Math.max.apply(null, student.grades) > 
      Math.max.apply(null, a.grades) ? 
      student : a;}, students[0]); 

console.log('Best student is: ' + bestStudent.name + ' with score: ' 
      + Math.max.apply(null, bestStudent.grades)); 

例子： https://jsfiddle.net/ahx8jh5g/

在情况下，你想获得具有最佳年级所有学生，让我们将其存储在一个数组：

var bestStudents = students.reduce(function(a, student){ 
    var maxGradeStu = Math.max.apply(null, student.grades), 
     maxGradeCur = a.length > 0 ? Math.max.apply(null, a[0].grades) : 0; 

     if (maxGradeStu === maxGradeCur) { 
      return a.concat(student); 
     } 
     return maxGradeStu > maxGradeCur ? [student] : a; 
}, []) 
bestStudents.forEach(bestStudent => console.log('Best student is: ' bestStudent.name + ' with score: ' 
      + Math.max.apply(null, bestStudent.grades))); 

更多的细节，你可以看到降低的位置：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

Answer 6

你可以使用一个数组对于成绩最好的学生，如果你有不止一个。

然后检查maxGrade是否与bestGrade相同，然后将实际学生推送到结果集并计数for循环。

如果maxGrade大于bestGrade，则存储将实际学生放在新数组中的值。

function bestStudents(studentArr) { 
 
    var bestGrade = 0, 
 
     bestStudents = [], 
 
     i, 
 
     maxGrade; 
 

 
    for (i = 0; i < studentArr.length; i++) { 
 
     maxGrade = Math.max.apply(null, studentArr[i].grades); 
 
     if (maxGrade === bestGrade) { 
 
      bestStudents.push(studentArr[i]); 
 
      continue; 
 
     } 
 
     if (maxGrade > bestGrade) { 
 
      bestGrade = maxGrade; 
 
      bestStudents = [studentArr[i]]; 
 
     } 
 
    } 
 
    return bestStudents; 
 
} 
 

 
var students = [{ name: "Student 1", grades: [90, 98, 99] }, { name: "Student 2", grades: [75, 85, 79] }, { name: "Student 3", grades: [75, 85, 99] }]; 
 

 
console.log(bestStudents(students)); 
 

.as-console-wrapper { max-height: 100% !important; top: 0; }