Javascript中的排序方法在for循环中不起作用吗？

我正在做一个代码挑战，我试图将排序数组中的每个数字与另一个数字进行比较，因为它们不匹配。我很难完成这个挑战，因为即使在for循环中使用排序后的数组之前，控制台日志正确地打印了该数组，但一旦在for循环中使用该数组，该数组似乎会保留其原始（未排序）顺序。代码如下：

function minMinMax(array) {
    let minAbsent = 0 
    // sort the array from smallest to largest
    let smallestToLargest = array.sort((a, b) => a - b)
    console.log(smallestToLargest)
    const smallest = smallestToLargest[0]
    // sort the array from largest to smallest
    let largestToSmallest = array.sort((a, b) => b - a)
    const largest = largestToSmallest[0]
    // use second smallest number as starting point for loop, then after each number check 
    // to see if that number is in the array, if not then add the value to our array
    for (i = 1, j = smallestToLargest[1]; i < smallestToLargest.length; i++, j++) {
      if (j !== smallestToLargest[i]) {
        minAbsent = j
        }
        console.log(smallestToLargest[i])
        console.log('this is the min absent ' + minAbsent)
      }
    return [smallest, minAbsent, largest]
  }

函数最小值（数组）{
设minAbsent=0
//将数组从最小到最大排序
让smallestolargest=array.sort（（a，b）=>a-b）
console.log（最小到最大）
常数最小=最小到最大[0]
//将数组从最大到最小排序
让largestToSmallest=array.sort（（a，b）=>b-a）
常数最大=最大到最小[0]
//使用第二个最小的数字作为循环的起点，然后在每次数字检查之后
//要查看该数字是否在数组中，如果不在，则将该值添加到数组中
对于（i=1，j=smallestToLargest[1]；i

当第二个console.log打印时，它读回给定的数组（使用原始的数字顺序，而不是排序的顺序）。那么是什么原因呢

let descend = Object.assign([], array);

上面的行不会通过引用复制数组

function minMinMax(array) {
  let minAbsent = 0;
  let descend = Object.assign([], array);
  // sort the array from smallest to largest
  let smallestToLargest = array.sort((a, b) => a - b)
  console.log(smallestToLargest)
  const smallest = smallestToLargest[0]
  // sort the array from largest to smallest
  let largestToSmallest = descend.sort((a, b) => b - a)
  const largest = largestToSmallest[0]
  // use second smallest number as starting point for loop, then after each number check 
  // to see if that number is in the array, if not then add the value to our array
  for (i = 1, j = smallestToLargest[1]; i < smallestToLargest.length; i++, j++) {
    if (j !== smallestToLargest[i]) {
      minAbsent = j
    }
    console.log(smallestToLargest[i])
    console.log('this is the min absent ' + minAbsent)
  }
  return [smallest, minAbsent, largest]
}

函数最小值（数组）{
设minAbsent=0；
让下降=Object.assign（[]，数组）；
//将数组从最小到最大排序
让smallestolargest=array.sort（（a，b）=>a-b）
console.log（最小到最大）
常数最小=最小到最大[0]
//将数组从最大到最小排序
让最大到最小=下降。排序（（a，b）=>b-a）
常数最大=最大到最小[0]
//使用第二个最小的数字作为循环的起点，然后在每次数字检查之后
//要查看该数字是否在数组中，如果不在，则将该值添加到数组中
对于（i=1，j=smallestToLargest[1]；i

我想这样行得通

上面的行不会通过引用复制数组

function minMinMax(array) {
  let minAbsent = 0;
  let descend = Object.assign([], array);
  // sort the array from smallest to largest
  let smallestToLargest = array.sort((a, b) => a - b)
  console.log(smallestToLargest)
  const smallest = smallestToLargest[0]
  // sort the array from largest to smallest
  let largestToSmallest = descend.sort((a, b) => b - a)
  const largest = largestToSmallest[0]
  // use second smallest number as starting point for loop, then after each number check 
  // to see if that number is in the array, if not then add the value to our array
  for (i = 1, j = smallestToLargest[1]; i < smallestToLargest.length; i++, j++) {
    if (j !== smallestToLargest[i]) {
      minAbsent = j
    }
    console.log(smallestToLargest[i])
    console.log('this is the min absent ' + minAbsent)
  }
  return [smallest, minAbsent, largest]
}

函数最小值（数组）{
设minAbsent=0；
让下降=Object.assign（[]，数组）；
//将数组从最小到最大排序
让smallestolargest=array.sort（（a，b）=>a-b）
console.log（最小到最大）
常数最小=最小到最大[0]
//将数组从最大到最小排序
让最大到最小=下降。排序（（a，b）=>b-a）
常数最大=最大到最小[0]
//使用第二个最小的数字作为循环的起点，然后在每次数字检查之后
//要查看该数字是否在数组中，如果不在，则将该值添加到数组中
对于（i=1，j=smallestToLargest[1]；i

---

我认为这很好。

问题在于，尽管有三个单独的指针，“数组”、“最小到最大”和“最大到最小”，但它们都引用了相同的实际数组对象。“array.sort（…）”对调用方法的数组进行排序，并返回对同一数组的引用

如果在创建largestToSmallest后尝试将smallestToLargest记录到控制台，您将看到smallestToLargest将按降序打印——因为在调用第二个array.sort时，它将按降序排序

let smallestToLargest = array.sort((a, b) => a - b)
console.log(smallestToLargest);
const smallest = smallestToLargest[0]
// sort the array from largest to smallest
let largestToSmallest = array.sort((a, b) => b - a)
console.log(smallestToLargest);

在随机阵列上进行测试，得出：

[1, 3, 14, 29, 311, 323]
[323, 311, 29, 14, 3, 1]

要保留“最小到最大”数组，您可以使用“切片（0）”克隆它

试试这个：

function minMinMax(array) {
    let minAbsent = 0 
    // sort the array from smallest to largest
    let smallestToLargest = array.sort((a, b) => a - b).slice(0);
    console.log(smallestToLargest);
    const smallest = smallestToLargest[0]
    // sort the array from largest to smallest
    let largestToSmallest = array.sort((a, b) => b - a).slice(0);
    console.log(smallestToLargest);
    const largest = largestToSmallest[0]
    // use second smallest number as starting point for loop, then after each number check 
    // to see if that number is in the array, if not then add the value to our array
    for (i = 1, j = smallestToLargest[1]; i < smallestToLargest.length; i++, j = smallestToLargest[i]) {
      if (j !== smallestToLargest[i]) {
        minAbsent = j
        }
        console.log(smallestToLargest[i])
        console.log('this is the min absent ' + minAbsent)
      }
  console.log(smallestToLargest);
    return [smallest, minAbsent, largest]
  };

函数最小值（数组）{
设minAbsent=0
//将数组从最小到最大排序
设smallestolargest=array.sort（（a，b）=>a-b.slice（0）；
控制台日志（从小到大）；
常数最小=最小到最大[0]
//将数组从最大到最小排序
让largestToSmallest=array.sort（（a，b）=>b-a.slice（0）；
控制台日志（从小到大）；
常数最大=最大到最小[0]
//使用第二个最小的数字作为循环的起点，然后在每次数字检查之后
//要查看该数字是否在数组中，如果不在，则将该值添加到数组中
对于（i=1，j=smallestToLargest[1]；i

问题似乎在于，尽管有三个单独的指针，“数组”、“最小到最大”和“最大到最小”，但它们都引用了相同的实际数组对象。“array.sort（…）”对调用方法的数组进行排序，并返回对同一数组的引用

如果在创建largestToSmallest后尝试将smallestToLargest记录到控制台，您将看到smallestToLargest将按降序打印——因为在调用第二个array.sort时，它将按降序排序

let smallestToLargest = array.sort((a, b) => a - b)
console.log(smallestToLargest);
const smallest = smallestToLargest[0]
// sort the array from largest to smallest
let largestToSmallest = array.sort((a, b) => b - a)
console.log(smallestToLargest);

在随机阵列上进行测试，得出：

[1, 3, 14, 29, 311, 323]
[323, 311, 29, 14, 3, 1]

要保留“最小到最大”数组，您可以使用“切片（0）”克隆它

试试这个：

function minMinMax(array) {
    let minAbsent = 0 
    // sort the array from smallest to largest
    let smallestToLargest = array.sort((a, b) => a - b).slice(0);
    console.log(smallestToLargest);
    const smallest = smallestToLargest[0]
    // sort the array from largest to smallest
    let largestToSmallest = array.sort((a, b) => b - a).slice(0);
    console.log(smallestToLargest);
    const largest = largestToSmallest[0]
    // use second smallest number as starting point for loop, then after each number check 
    // to see if that number is in the array, if not then add the value to our array
    for (i = 1, j = smallestToLargest[1]; i < smallestToLargest.length; i++, j = smallestToLargest[i]) {
      if (j !== smallestToLargest[i]) {
        minAbsent = j
        }
        console.log(smallestToLargest[i])
        console.log('this is the min absent ' + minAbsent)
      }
  console.log(smallestToLargest);
    return [smallest, minAbsent, largest]
  };

函数最小值（数组）{
设minAbsent=0
//将数组从最小到最小排序