javascript 嵌套数组排序，基于变长内排序数组

Question

外部数组应根据每个学生的可变长度内部“测试”数组的排名组合进行排序，升序。 这是原始数据的简化版本。

[
    {
        "studentId": "A",
        "tests": [
            { 
                "testId": 100,
                "rank": 2
            },
            {  
                "testId": 101,
                "rank": 1
            },
            {  
                "testId": 102,
                "rank": 1
            }
        ]
    },
    {
        "studentId": "G",
        "tests": [
            { 
                "testId": 103,
                "rank": 3 
            },
            { 
                "testId": 104,
                "rank": 6
            },
            { 
                "testId": 105,
                "rank": 3
            },
            { 
                "testId": 106,
                "rank": 4
            },
            { 
                "testId": 107,
                "rank": 3
            }
        ]
    }
]

为简洁起见，这里有一个注释图来说明排序和打破平局的规则。 想象一下，以下每个代表每个学生的个人测试排名的预排序序列。 （请注意，testIds 无关紧要，除了保留它们之外。我们不关心比较单个测试，只关心每个学生的整体排名组合）：

StudentId : [ascending sequence of test ranks]

A : [ 1, 1, 2]              // A beats B due to 2nd element
B : [ 1, 2, 2]              // B beats C due to 1st element
C : [ 2, 3]                 // Let C beat D due to shorter length!
D : [ 2, 3, 3]              // D beats E due to 1st element
E : [ 3, 3, 3, 4, 5, 7]     // E beats F and G due to 5th element
F : [ 3, 3, 3, 4, 6]        // F and G are tied. Let F beat G due to studentId! (alphanumeric ascending)
G : [ 3, 3, 3, 4, 6]  

没有对原始数据进行排序。 完成 output 以包括排序的外部数组，每个学生的测试数组按排名排序。 如果有什么不清楚的地方请告诉我，谢谢。

Answer 1

所以，基本上，数组需要根据测试排名的sum按升序排序，是吗？

function sumTestRanks(students) {
  for(let student of students) {
    sumStudentTestRanks(student);
  }
}

function sumStudentTestRanks(student) {
  let testsRankTotal = 0;
  const tests = student.tests;
  for(let test of tests) {
    testsRankTotal += test.rank;
  }
  student.testsRankTotal = testsRankTotal;
}

function studentsSorter(studentA, studentB) {
  if(studentA.testsRankTotal < studentB.testsRankTotal) {
    return -1;
  }
  if(studentA.testsRankTotal > studentB.testsRankTotal) {
    return 1;
  }
  return studentA.studentId.localeCompare(studentB.studentId);
}

const students = [...];
sumTestRanks(students)

console.log(students.sort(studentsSorter));

更新：

在那种情况下，它是这样的：

1. 确定最小可比尺寸
2. 在该长度内进行比较
3. 如果是同等尺码以内的领带
   • 如果两个测试大小相同，则按 id 进行比较。
   • 最后按长度比较

function studentsSorter(studentA, studentB) {

  const studentATests = studentA.tests;
  const studentBTests = studentB.tests;

  const studentATestsLength = studentATests.length;
  const studentBTestsLength = studentBTests.length;

  let scanLength = studentATestsLength;

  if(scanLength > studentBTestsLength) {
    scanLength = studentBTestsLength;
  }

  for(let index = 0; index < scanLength; index++) {

    const studentATest = studentATests[index];
    const studentBTest = studentBTests[index];

     if(studentATest.rank === studentBTest.rank) {
        continue;
      }

      if(studentATest.rank < studentBTest.rank) {
        return -1;
      }
      else if(studentATest.rank > studentBTest.rank) {
        return 1;
      }

  }


  if(studentATestsLength === studentBTestsLength) {
    return studentA.studentId.localeCompare(studentB.studentId);
  }
  else if(studentATestsLength < studentBTestsLength) {
    return -1;
  }
  else {
    return 1;
  }
  
}

我提到这个答案是为了了解比较器在 JavaScript 中的工作原理。