JavaScript：如何对包含 NaN 的数组进行排序

Question

我正在尝试对有时具有

Infinity

或

NaN

的数组进行排序。当我使用标准 JavaScript

array.sort()

时，它似乎会进行排序，直到达到

NaN

，然后我会得到随机结果。

var array =[.02,.2,-.2,Nan,Infinity,20];

有没有办法仍然对其进行排序，以便最终结果从负到正，并且最后仍然有

NaN

或

Infinity

。

-.2,.02,.2,20,NaN,Infinity

Answer 1

如果您只想以随机顺序将它们放到最后：

var arr = [-1, 0, 1, 10, NaN, 2, NaN, 0, -1, NaN, 5, Infinity, 0, -Infinity];

arr.sort(function(a,b){
    if( !isFinite(a) && !isFinite(b) ) {
        return 0;
    }
    if( !isFinite(a) ) {
        return 1;
    }
    if( !isFinite(b) ) {
        return -1;
    }
    return a-b;
});
//[-1, -1, 0, 0, 0, 1, 2, 5, 10, NaN, NaN, NaN, Infinity, -Infinity]

如果您还想在最后对无穷大进行排序：

var arr = [-1, 0, 1, 10, NaN, 2, NaN, 0, -1, NaN, 5, Infinity, 0, -Infinity];

arr.sort(function(a,b){
    if( !isFinite(a) && !isFinite(b) ) {
        return ( isNaN(a) && isNaN(b) )
            ? 1
            : a < b
                ? -1
                : a === b
                    ? 0
                    : 1;
    }
    if( !isFinite(a) ) {
        return 1;
    }
    if( !isFinite(b) ) {
        return -1;
    }
    return a-b;
});

//[-1, -1, 0, 0, 0, 1, 2, 5, 10, -Infinity, Infinity, NaN, NaN, NaN]

这里的顺序是

-Infinity

<

Infinity

<

NaN

Answer 2

负无穷大在逻辑上应该排在第一位，因为它实际上小于所有其他数字。

我会这样做：

const cmp = (a,b) => a-b || isNaN(a)-isNaN(b);

// Example
const arr = [Infinity, NaN, Infinity, -Infinity, NaN, 1, 0, NaN, -1, -0];
console.log(arr.sort(cmp));

这里 -0 和 0 被认为是相等的，并且可以以任何相对顺序出现。

如果你想确保 -0 在 0 之前排序，那么：

const cmp = (a,b) => a-b || isNaN(a)-isNaN(b) || Object.is(b, -0) - Object.is(a, -0);

// Example
const arr = [Infinity, NaN, Infinity, -Infinity, NaN, 1, 0, NaN, -1, -0];
console.log(arr.sort(cmp));

请注意，堆栈片段不会保留

-0

...请参阅浏览器控制台。

Answer 3

对于这些情况，您可以使用 JavaScript 的内置实用函数捕获

NaN

和

Infinity

：

let array = [Infinity, -1, 6, 1, 0, NaN, 0, -1, 2, 5, 10, -Infinity, NaN, Infinity, NaN]



//sort -Infinity, NaN, Infinity to the end in random order
array.sort(function(a,b){
  if(isFinite(a-b)) {
    return a-b; 
  } else {
    return isFinite(a) ? -1 : 1;
  }
});

//[-1,-1,0,0,1,2,5,6,10,NaN,Infinity,Infinity,NaN,-Infinity,NaN]
console.log(array);



//sort -Infinity<0<Infinity<NaN
function(a,b){
  if(isNaN(a)) { 
    return isNaN(b) ? 1 : b;
  } else {
    return isNaN(b) ? -1 : a-b; 
  }
}

//[-Infinity,-1,-1,0,0,1,2,5,6,10,Infinity,Infinity,NaN,NaN,NaN]
console.log(array);

Answer 4

有这样的事吗？

var arr = [-1, 0, 1, 10, NaN, 2, NaN, 0, -1, NaN, 5, Infinity, 0];
function sortInf (a, b) {
    a = parseFloat(a);
    b = parseFloat(b);
    if ((!a || a === -Infinity) && a !== 0) {
        return 1;
    } else if ((!b || b === -Infinity) && b !== 0) {
        return -1;
    } else return a - b;
}
alert(arr.sort(sortInf));

Answer 5

一种简单快速的方法，没有条件或函数开销：

var r=[1,9,NaN,3,4,5,0,-4, NaN , 4, Infinity, 7, 2];
 r.sort(function(a,b,c){return  a-b || (a||Infinity)-(b||Infinity) || 0 });
 alert(r) // == -4,0,1,2,3,4,4,5,7,9,NaN,NaN,Infinity

编辑：根据反馈进行更新以避免 NaN 返回。

它的执行速度比其他答案快约 20 倍，因此如果您需要性能，那么它是理想的选择，并且排序是性能通常很重要的一个领域...