Question

我有一个对象数组，其中包含学生的姓名和分数。像下面一样

我该如何计算每个学生的“平均”分数并比较“平均”分数以获得最高的学生。我不想使用ES6

var Students = [{
    name: "Bob",
    marks: [78, 80, 89, 90, 68]
  },
  {
    name: "Alin",
    marks: [87, 60, 59, 70, 68]
  },
  {
    name: "bikash",
    marks: [82, 60, 79, 60, 80]
  }
];


var average;
var newArray = [];
for (let i = 0; i < Students.length; i++) {
  var marks = Students[i]["marks"];
  var total = 0;
  console.log(marks);
  for (var j = 0; j < marks.length; j++) {
    total += marks[j];
  }
  average = total / marks.length;
  newArray.push(average)
  var msg = Students[i]["name"] + " has average mark: " + average;
  console.log(msg)

}

console.log(newArray)

我想在对象中插入平均值以及类似的名称 [{name：“ Bob”，平均：89.4}，{name：“ Alin”，平均：87.2}，{name：“ Bikash”，平均：89.4}] 对对象进行排序。

最后，我想拥有console.log，因为鲍勃是最好的学生要么阿林和鲍勃是最聪明的学生（如果他们的平均数相同）

Answer 1

不要将平均值推入新数组，将其添加为Students[i]和Students[i].average = average;的属性。

然后，您可以使用该属性对数组进行排序，并从排序后的数组中将其打印给学生。

var Students = [{
    name: "Bob",
    marks: [78, 80, 89, 90, 68]
  },
  {
    name: "Alin",
    marks: [87, 60, 59, 70, 68]
  },
  {
    name: "bikash",
    marks: [82, 60, 79, 60, 80]
  }
];


var average;
for (let i = 0; i < Students.length; i++) {
  var marks = Students[i]["marks"];
  var total = 0;
  for (var j = 0; j < marks.length; j++) {
    total += marks[j];
  }
  average = total / marks.length;
  Students[i].average = average;
  var msg = Students[i]["name"] + " has average mark: " + average;
  console.log(msg)

}
Students.sort((s1, s2) => s2.average - s1.average);
var topAvg = Students[0].average;
var topStudents = Students.filter(s => s.average == topAvg).map(s => s.name).join(", ");
console.log(`Top Students are ${topStudents} with mark ${topAvg}`);

Answer 2

我使用了非ES6功能，而是传统的for loop和其他功能。请为您的三个问题找到答案：

以以下格式创建对象列表/数组：[{名称：'Alin'，平均：68.8}，..]
使用平均值排序列表/数组

获得平均成绩最高的学生。

     const Students = [{
     name: 'Bob',
     marks: [78, 80, 89, 90, 68],
 },
     {
         name: 'Alin',
         marks: [87, 60, 59, 70, 68],
     },
     {
         name: 'bikash',
         marks: [82, 60, 79, 60, 80],
     },
     {
         name: 'Doston',
         marks: [78, 80, 89, 90, 68],
     },
 ];

 var average;
 var data = [];
 for (var i = 0; i < Students.length; i++){
     var marks = Students[i]["marks"];
     var total = 0;
     console.log(marks);
     for (var j = 0; j < marks.length; j++ ) {
         total += marks[j];
     }
     average = total / marks.length;

     var msg = Students[i]["name"] + " has average mark: " + average;
     console.log(msg);

     // Answer for the first question:
     var item = {"name": Students[i]["name"], "average": average};
     data.push(item);

 }

 function compareAndSort(a,b) {
     return parseInt(a.average, 10) - parseInt(b.average, 10);
 }

 data.sort(compareAndSort);

 // Answer for the second question: sort [ { name: 'Alin', average: 68.8 }, ..]
 console.log(data);

 // Answer for the third question - getting students who has highest mark is last since it is sorted
 var bestStudent = data[data.length - 1];
 console.log(bestStudent.name + " has got the highest mark: " + bestStudent.average);

 var bestStudents = [bestStudent];

 // check if there is only one person with this highest mark
 for (var i = 0; i < data.length; i ++) {
     if (data[i].average >= bestStudent.average && data[i].name !== bestStudent.name) {
         bestStudents.push(data[i]);
     }
 }

 // all best students
 console.log(bestStudents);

我已经在JSON输入中添加了一些数据，以便您得到两个最好的学生

Answer 3

我没有使用循环，而是使用了内置的数组方法，这些方法通常更具可读性（尽管如果使用ES6语法，它们的可读性也更高）。

我使用Array.prototype.map方法将标记列表转换为平均值。为了找到该平均值，我使用Array.prototype.reduce将所有值相加，然后除以marks数组的长度。然后，我使用Array.prototype.sort对数组进行排序。

为了获得排名靠前的学生，我使用Array.prototype.filter来选择仅学生将获得的平均成绩等于排名靠前的平均得分，由于对averages数组进行了排序，因此它们将是{ {1}}。

averages[0].average

Answer 4

您不需要其他数组。从理论上讲，调用sort的效率不如在循环中聚集最优秀的学生。

所以：

var students = [{name: "Bob",marks: [78,80,89,90,68] },{name: "Alin",marks: [87,60,59,70,68]},{name: "bikash",marks: [82,60,79,60,80]}];

var topAverage = -1; 
var topStudents = [];
var newArray = [];
for (let i = 0; i < students.length; i++){
    var marks = students[i].marks;
    var total = 0;
    for (var j = 0; j < marks.length; j++ ) {
        total += marks[j];
    }
    var average = total / marks.length;
    // Keep topAverage & topStudents up to date:
    if (average >= topAverage) {
        if (average > topAverage) {
            topStudents.length = 0; // clear previous content
            topAverage = average;
        }
        topStudents.push(students[i].name);
    }
}

console.log("Top student(s): " + topStudents + " with an average of " + topAverage);

Answer 5

var Students = [{
    name: "Bob",
    marks: [78, 80, 89, 90, 68]
  },
  {
    name: "Alin",
    marks: [87, 60, 59, 70, 68]
  },
  {
    name: "bikash",
    marks: [82, 60, 79, 60, 80]
  }
];

console.log (
  Students.map (
    student => (
      {
        name: student.name,
        average:
          student.marks.reduce ((a, m) => a + m, 0) /
          student.marks.length
      }
    )
  ).sort ((a, b) => b.average - a.average)
);

Answer 6

将平均值存储到学生对象中，然后执行以下操作：

array.sort(function(a, b){return b.average-a.average});

排名靠前的学生将是数组[0] .name

这将按从大到小的顺序对平均值进行排序，并检查顶级学生是否具有相同的平均值，您可以简单地遍历数组：

let top_students = []
for(let i=0; i<array.length; i++){
  if(array[i].average==array[0].average)
     top_students.push(array[i].name)
}

在对象数组中插入新元素并对数组进行排序

6 个答案: