Question

我想创建一个接受数字数组作为参数的函数。如果数字数组是升序，则应返回true，否则应返回false。

arr = [2, 10, 99, 150]

function areOrdered(arr) {
  let sortedArray = arr.sort((a, b) => (a - b));

  if (arr === sortedArray) {
    return true
  }
}

Answer 1

您可以遍历数组，检查每个值是否大于前一个值。像这样：

const one = [2, 10, 99, 150];
const two = [2, 1, 3, 4];

const isAscending = (arr) => {
  for (let i = 0; i < arr.length; i++) {
     if (i > 0 && arr[i - 1] > arr[i]) {
       return false;
     }
  }
  return true;
}

console.log(one, isAscending(one));
console.log(two, isAscending(two));

Answer 2

您可以使用.every()来检测升序：

const data1 = [2, 10, 99, 150];
const data2 = [10, 2, 99, 150];

const isAscending = arr => arr.every((v, i, a) => (i == 0 || v >= a[i - 1]));

console.log(isAscending(data1));
console.log(isAscending(data2));

Answer 3

您可以对数组进行字符串化，然后进行比较。由于sort对数组进行了突变，因此您需要使用[...arr]创建一个新的克隆，然后进行排序

function areOrdered(arr) {
  let sortedArray = [...arr].sort((a, b) => a - b);
  return JSON.stringify(arr) === JSON.stringify(sortedArray)
}

console.log(areOrdered([2, 10, 99, 150]))
console.log(areOrdered([2, 100, 99]))

但是检查数组是否已排序的最好方法是使用简单的for并与下一个索引进行比较

function areOrdered(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] > arr[i + 1]) {
      return false;
    }
  }
  
  return true
}

console.log(areOrdered([2, 10, 99, 150]))
console.log(areOrdered([2, 100, 99]))

Answer 4

我认为这可行（我们可以使用.some来检查是否有两个连续的元素违反了升序规则）-：

let checkIfAscendingArr = (arr) => !arr.some((item,i) => {
  if(i > 0){
    return (arr[i-1] > item)
  }
})

Answer 5

如果数组中有一个或更少的项目（数组未通过for循环中的条件），则此函数返回true
如果数组中有多个项目，它将检查要与前一项进行迭代的值。如果前一个数字大于当前数字，则该函数将返回false（从而结束循环）。
如果所有数字都以升序循环遍历数组，则该函数返回true。

function isAscending( array ) {

  for( let i = 1; i < array.length; i++ ){
   if( array[i-1] > array[i] )
     return false;
  }
  
  return true;
}

// example tests
let array1 = [1,2,5,5,8]; // true
let array2 = [1,2,7,5,8]; // false
let array3 = [-10]; // true
const result1 =  isAscending( array1 );
const result2 =  isAscending( array2 );
const result3 =  isAscending( array3 );
console.log( result1 );
console.log( result2 );
console.log( result3 );

Answer 6

我认为，最简洁的解决方案是使用Array.every，在此您可以通过索引检查当前元素和下一个元素。在这种情况下，如果索引用完了，我们将与x+1进行比较。

let isOrdered = arr => arr.every((x,i,a) => x < (a[i+1] || x+1))

console.log(isOrdered([2, 10, 99, 150]))
console.log(isOrdered([21, 10, 99, 150]))

Answer 7

这里是使用Array.reduce的单个衬纸。我知道-单个内衬会影响可读性。但这只是为了好玩。

var isAscending = [1, 2, 3, 4].reduce((p, c, i, a) => {return p === false ? false : c > p ? i === a.length - 1 ? true :c : false}, 0);

console.log(isAscending)

如果数组按升序返回true，否则返回false

7 个答案: