javascript - 计算对象属性给出与点表示法不同的结果

Question

我正在使用合并排序函数。当我对要使用的属性使用点符号时，它会正确对它们进行排序。我决定希望能够在其他属性上重用排序功能，因此我决定将该属性作为函数中的参数，而不是对其进行硬编码。问题是当我向它传递相同的属性时，项目的排序不同。不确定为什么会发生这种情况。

这是我根据“points”属性排序的对象数组。

[ { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 },
  { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 } ]

工作合并排序功能:

*注意合并的if语句中的.points

  function mergeSort(arr){
   var len = arr.length;
   if(len <2)
      return arr;
   var mid = Math.floor(len/2),
       left = arr.slice(0,mid),
       right =arr.slice(mid);
   //send left and right to the mergeSort to break it down into pieces
   //then merge those
   return merge(mergeSort(left),mergeSort(right));
}


function merge(left, right){
  var result = [],
      lLen = left.length,
      rLen = right.length,
      l = 0,
      r = 0;
  while(l < lLen && r < rLen){
     if(left[l].points < right[r].points){
       result.push(left[l++]);
     }
     else{
       result.push(right[r++]);
    }
  }  
  //remaining part needs to be addred to the result
  return result.concat(left.slice(l)).concat(right.slice(r));
}

调用给了我预期的结果:

let rankArr = mergeSort(Teams).reverse();
console.log(rankArr);
//outputs:

[ { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 },
  { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 } ]

const Teams = [ { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 },
  { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 } ]
  
function mergeSort(arr) {
  var len = arr.length;
  if (len < 2)
    return arr;
  var mid = Math.floor(len / 2),
    left = arr.slice(0, mid),
    right = arr.slice(mid);
  //send left and right to the mergeSort to break it down into pieces
  //then merge those
  return merge(mergeSort(left), mergeSort(right));
}


function merge(left, right) {
  var result = [],
    lLen = left.length,
    rLen = right.length,
    l = 0,
    r = 0;
  while (l < lLen && r < rLen) {
    if (left[l].points < right[r].points) {
      result.push(left[l++]);
    } else {
      result.push(right[r++]);
    }
  }
  //remaining part needs to be addred to the result
  return result.concat(left.slice(l)).concat(right.slice(r));
}
let rankArr = mergeSort(Teams).reverse();
console.log(rankArr);

这是具有动态属性的归并排序

  function mergeSort(arr, prop){
   var len = arr.length;
   if(len <2)
      return arr;
   var mid = Math.floor(len/2),
       left = arr.slice(0,mid),
       right =arr.slice(mid);
   //send left and right to the mergeSort to break it down into pieces
   //then merge those
   return merge(mergeSort(left),mergeSort(right), prop);
}


function merge(left, right, prop){
  var result = [],
      lLen = left.length,
      rLen = right.length,
      l = 0,
      r = 0;
  while(l < lLen && r < rLen){
     if(left[l][prop] < right[r][prop]){
       result.push(left[l++]);
     }
     else{
       result.push(right[r++]);
    }
  }  
  //remaining part needs to be addred to the result
  return result.concat(left.slice(l)).concat(right.slice(r));
}

//invoked
  let rankArr = mergeSort(Teams,"points").reverse();

输出:

[ { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 },
  { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 } ]

const Teams = [ { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 },
  { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 } ]
  
function mergeSort(arr, prop) {
  var len = arr.length;
  if (len < 2)
    return arr;
  var mid = Math.floor(len / 2),
    left = arr.slice(0, mid),
    right = arr.slice(mid);
  //send left and right to the mergeSort to break it down into pieces
  //then merge those
  return merge(mergeSort(left), mergeSort(right), prop);
}


function merge(left, right, prop) {
  var result = [],
    lLen = left.length,
    rLen = right.length,
    l = 0,
    r = 0;
  while (l < lLen && r < rLen) {
    if (left[l][prop] < right[r][prop]) {
      result.push(left[l++]);
    } else {
      result.push(right[r++]);
    }
  }
  //remaining part needs to be addred to the result
  return result.concat(left.slice(l)).concat(right.slice(r));
}

//invoked
console.log(mergeSort(Teams, "points").reverse());

Answer 1

您的动态mergeSort需要第二个参数，即prop。最初调用它时，参数会正确传递:

let rankArr = mergeSort(Teams,"points").reverse();

但是您还需要将其传递给递归调用。改变

return merge(mergeSort(left),mergeSort(right), prop);

至

return merge(mergeSort(left, prop),mergeSort(right, prop), prop);

否则，在递归过程中，它将是未定义，并且不会发生合理的排序。

const Teams = [ { teamNum: 0, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 1, points: 2, GD: -2, goals: 3, rank: 0 },
  { teamNum: 2, points: 1, GD: -3, goals: 2, rank: 0 },
  { teamNum: 3, points: 4, GD: 1, goals: 4, rank: 0 },
  { teamNum: 4, points: 5, GD: 4, goals: 5, rank: 0 },
  { teamNum: 5, points: 4, GD: 2, goals: 6, rank: 0 } ];

function mergeSort(arr, prop){
   var len = arr.length;
   if(len <2)
      return arr;
   var mid = Math.floor(len/2),
       left = arr.slice(0,mid),
       right =arr.slice(mid);
   //send left and right to the mergeSort to break it down into pieces
   //then merge those
   return merge(mergeSort(left, prop),mergeSort(right, prop), prop);
}


function merge(left, right, prop){
  var result = [],
      lLen = left.length,
      rLen = right.length,
      l = 0,
      r = 0;
  while(l < lLen && r < rLen){
     if(left[l][prop] < right[r][prop]){
       result.push(left[l++]);
     }
     else{
       result.push(right[r++]);
    }
  }  
  //remaining part needs to be addred to the result
  return result.concat(left.slice(l)).concat(right.slice(r));
}

//invoked
  let rankArr = mergeSort(Teams,"points").reverse();
  console.log(rankArr);