用ChatGPT解决这个技术问题 Extra ChatGPT

How to sort an array of integers correctly

Trying to get the highest and lowest value from an array that I know will contain only integers seems to be harder than I thought.

var numArray = [140000, 104, 99]; numArray = numArray.sort(); console.log(numArray)

I'd expect this to show 99, 104, 140000. Instead it shows 104, 140000, 99. So it seems the sort is handling the values as strings.

Is there a way to get the sort function to actually sort on integer value?

BTW, if you're sorting lots and lots of integers it will be advantages to use an integer sort algorithm like counting sort. The time counting sort will take to run scales linearly with the size of your array: O(n). Whereas all solutions here use comparison sort which is less efficient: O(n * log n).
@Web_Designer Counting sort is linear regarding the number range, not the array. For example, sorting [1,1000000] will take more than 2 steps, since the algorithm will have to scan each array index between 1 to 1000000 to see which cell's value is greater than 0.
@yters Using a hashmap, you can only pay attention to the integers that show up in the array being sorted. This makes the sort linear wrt the array size.
the quickest way is to use the isomorphic sort-array module which works natively in both browser and node, supporting any type of input, computed fields and custom sort orders.
It's pretty insane that JS still has this bug...

M
Machavity

By default, the sort method sorts elements alphabetically. To sort numerically just add a new method which handles numeric sorts (sortNumber, shown below) -

var numArray = [140000, 104, 99]; numArray.sort(function(a, b) { return a - b; }); console.log(numArray);

Documentation:

Mozilla Array.prototype.sort() recommends this compare function for arrays that don't contain Infinity or NaN. (Because Infinity - Infinity is NaN, not 0).

Also examples of sorting objects by key.

Nice. But is there really no out-of-the-box way to get a numerical sort from javascript?
ahah this is out of the box! But if you're really impractical you can bind functions to the array class class at the very beginning of your javascript: // Array.prototype.sortNormal = function(){return this.sort(function(a,b){return a - b})} // Now calling .sortNormal() on any array will sort it numerically
Why a-b and not a>b. I suggest the last one in order to avoid operation machine errors
@Velthune The compare function should return -1, 0 or +1. a>b will only return true or false.
This code can be shortened using an Arrow Function. numberArray.sort((a, b) => (a - b)); Yay! I think this is close to the out-of-the-box way. Note: check if your JS engine supports Arrow Functions.
M
Machavity

Just building on all of the above answers, they can also be done in one line like this: 

var numArray = [140000, 104, 99];
numArray = numArray.sort(function (a, b) {  return a - b;  });

//outputs: 99, 104, 140000
I think you mean in one expression.
@bodyflex Fixed: var arr = [140000, 104, 99].sort(function(a,b) { return a-b; });. Or more compact, in ES6 let arr = [140000, 104, 99].sort((a,b) => a-b);
d
dy_

I am surprised why everyone recommends to pass a comparator function to sort(), that makes sorting really slow!

To sort numbers, just create any TypedArray:

var numArray = new Float64Array([140000, 104, 99]); numArray = numArray.sort(); console.log(numArray)

Using a TypedArray speeds up sort by about 5X. If you want to go even faster hpc-algorithms npm package implements Radix Sort and Counting Sort that several answers here suggest.
I tried this with negative numbers and had a strange result: > new Uint32Array([ -4, -7, 1, 4 ]).sort() returned Uint32Array(4) [ 1, 4, 4294967289, 4294967292 ].
@Nikolay D those are unsigned. You can use Int32Array.
sure sorting a typed array is faster. But if you have a regular array, converting it to a typed array to sort it is not a good solution (speed and memory)
@Gio not sure that is true. Memory requirement is only O(2n) which is only a couple megabytes for an array of million items. As for speed - converting array to typedarray, sorting and converting back is still faster than sorting an array with a function.
P
Paul Dixon

array.sort does a lexicographic sort by default, for a numeric sort, provide your own function. Here's a simple example: 

function compareNumbers(a, b)
{
    return a - b;
}

numArray.sort(compareNumbers);

Also note that sort works "in place", there's no need for the assignment.

I didn't understand above code, how does "return a - b" does the ascending sorting ?
if a < b, compareNumbers returns a negative number. If a > b, it will be positive. If equal, it returns 0.
@AliMertCakar because it only returns true or false, and the comparison function needs to return either a negative number, zero or a positive number.
P
Peter Mortensen

This answer is equivalent to some of the existing answers, but ECMAScript 6 arrow functions provide a much more compact syntax that allows us to define an inline sort function without sacrificing readability: 

numArray = numArray.sort((a, b) => a - b);

It is supported in most browsers today.

B
Black

The reason why the sort function behaves so weird

From the documentation:

[...] the array is sorted according to each character's Unicode code point value, according to the string conversion of each element.

If you print the unicode point values of the array then it will get clear.

console.log("140000".charCodeAt(0)); console.log("104".charCodeAt(0)); console.log("99".charCodeAt(0)); //Note that we only look at the first index of the number "charCodeAt( 0 )"

This returns: "49, 49, 57". 

49 (unicode value of first number at 140000)
49 (unicode value of first number at 104)
57 (unicode value of first number at 99)

Now, because 140000 and 104 returned the same values (49) it cuts the first index and checks again:

console.log("40000".charCodeAt(0)); console.log("04".charCodeAt(0)); //Note that we only look at the first index of the number "charCodeAt( 0 )" 

52 (unicode value of first number at 40000)
40 (unicode value of first number at 04)

If we sort this, then we will get: 

40 (unicode value of first number at 04)
52 (unicode value of first number at 40000)

so 104 comes before 140000.

So the final result will be:

var numArray = [140000, 104, 99]; numArray = numArray.sort(); console.log(numArray)

104, 140000, 99

Conclusion:

sort() does sorting by only looking at the first index of the numbers. sort() does not care if a whole number is bigger than another, it compares the value of the unicode of the digits, and if there are two equal unicode values, then it checks if there is a next digit and compares it as well.

To sort correctly, you have to pass a compare function to sort() like explained here.

Hint: This is only my explanation, I did not actually looked up the code. So don't fully trust this answer.
n
norbekoff

just do .sort((a, b) => a - b) instead of .sort() itself

var numArray = [140000, 104, 99]; numArray.sort((a, b) => a - b); console.log(numArray)

Was very helpful!
u
user3587638

I agree with aks, however instead of using 

return a - b;

You should use 

return a > b ? 1 : a < b ? -1 : 0;
Can you explain why anyone should use your more unreadable ternary operation? As far as I can tell it would have the same result.
This answer also takes equal values into consideration and leaves them in the same place.
"return a-b" may be adequate for the particular case of this question (javascript, and all input items known to be ints), but personally I prefer the ternary form because it's more canonical-- it works in more cases, in more programming languages, with more data types. E.g. in C, a-b can overflow, leading to the sort endless looping, corrupting memory, crashing, etc. That said, even the ternary form isn't going to work sanely if there are NaNs or mixed types involved.
The > and < still compare a and b as strings.
@stefannew There is one case where this answer returns the correct evaluation for numbers where a - b doesnt. Where a = b = -Infinity, a - b = NaN, but the ternary returns 0. But this doesn't seem to affect the sort, it still does it perfectly. (a > b) - (a < b) is a shorter version that is equivalent to this ternary.
R
R.M. Reza

Ascending 

arr.sort((a, b) => a - b);

Descending 

arr.sort((a, b) => b - a);

Just for fun:

Descending = Ascending + Reverse 

arr.sort((a, b) => a - b).reverse();
P
Peter Mortensen

In JavaScript the sort() method's default behaviour is to sort values in an array alphabetically.

To sort by number you have to define a numeric sort function (which is very easy): 

...
function sortNumber(a, b)
{
  return a - b;
}

numArray = numArray.sort(sortNumber);
C
Commercial Suicide

The question has already been answered, the shortest way is to use sort() method. But if you're searching for more ways to sort your array of numbers, and you also love cycles, check the following

Insertion sort

Ascending:

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length; i++) { var target = numArray[i]; for (var j = i - 1; j >= 0 && (numArray[j] > target); j--) { numArray[j+1] = numArray[j]; } numArray[j+1] = target } console.log(numArray);

Descending:

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length; i++) { var target = numArray[i]; for (var j = i - 1; j >= 0 && (numArray[j] < target); j--) { numArray[j+1] = numArray[j]; } numArray[j+1] = target } console.log(numArray);

Selection sort:

Ascending:

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length - 1; i++) { var min = i; for (var j = i + 1; j < numArray.length; j++) { if (numArray[j] < numArray[min]) { min = j; } } if (min != i) { var target = numArray[i]; numArray[i] = numArray[min]; numArray[min] = target; } } console.log(numArray);

Descending:

var numArray = [140000, 104, 99]; for (var i = 0; i < numArray.length - 1; i++) { var min = i; for (var j = i + 1; j < numArray.length; j++) { if (numArray[j] > numArray[min]) { min = j; } } if (min != i) { var target = numArray[i]; numArray[i] = numArray[min]; numArray[min] = target; } } console.log(numArray);

Have fun

Are any of these actually faster for tiny arrays than using sort() on a TypedArray like this answer suggests. Certainly they won't be faster for medium to large arrays because these are O(n^2) algorithms.
P
Peter Mortensen

Array.prototype.sort() is the go to method for sorting arrays, but there are a couple of issues we need to be aware of.

The sorting order is by default lexicographic and not numeric regardless of the types of values in the array. Even if the array is all numbers, all values will be converted to string and sorted lexicographically.

So should we need to customize the sort() and reverse() method like below.

Referred URL

For sorting numbers inside the array 

numArray.sort(function(a, b)
{
    return a - b;
});

For reversing numbers inside the array 

numArray.sort(function(a, b)
{
    return b - a;
});

Referred URL

s
stackphish

The function 'numerically' below serves the purpose of sorting array of numbers numerically in many cases when provided as a callback function: 

function numerically(a, b){
    return a-b;
}

array.sort(numerically);

But in some rare instances, where array contains very large and negative numbers, an overflow error can occur as the result of a-b gets smaller than the smallest number that JavaScript can cope with.

So a better way of writing numerically function is as follows: 

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}
JavaScript numbers are floating-point. IEEE754 defines overflow and underflow rules, including overflow to +-Infinity, and underflow to subnormal or +-0.0. I don't think subtraction of two numbers can underflow to +-0.0 even if they're both large and nearby equal. The difference between two doubles is always representable as another non-zero double (unless it overflows, like DBL_MIN - DBL_MAX) but underflow isn't possible. Catastrophic cancellation makes the result imprecise, losing most of its "significant digits", but a-b will always be non-zero and have the right sign for a!=b.
A
Ali Khosro

to handle undefined, null, and NaN: Null behaves like 0, NaN and undefined goes to end. 

array = [3, 5, -1, 1, NaN, 6, undefined, 2, null]
array.sort((a,b) => isNaN(a) || a-b)
// [-1, null, 1, 2, 3, 5, 6, NaN, undefined]
The language spec requires that the compare function always return a number other than NaN when called on any two elements of the array. This function returns NaN when b is NaN or undefined, and when a and b are both Infinity or both -Infinity.
The idea to check for NaN is not bad but this code doesn't put NaNs to the end
G
Grant Miller

While not required in JavaScript, if you would like the sort() compareFunction to strictly return -1, 0, or 1 (similar to how the spaceship operator works in PHP), then you can use Math.sign().

The compareFunction below strictly returns -1, 0, or 1: 

numArray.sort((a, b) => Math.sign(a - b));

Note: Math.sign() is not supported in Internet Explorer.

U
Umesh

For a normal array of elements values only: 

function sortArrayOfElements(arrayToSort) {
    function compareElements(a, b) {
        if (a < b)
            return -1;
        if (a > b)
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareElements);
}

e.g. 1:
var array1 = [1,2,545,676,64,2,24]
**output : [1, 2, 2, 24, 64, 545, 676]**

var array2 = ["v","a",545,676,64,2,"24"]
**output: ["a", "v", 2, "24", 64, 545, 676]**

For an array of objects: 

function sortArrayOfObjects(arrayToSort, key) {
    function compareObjects(a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    }

    return arrayToSort.sort(compareObjects);
}

e.g. 1: var array1= [{"name": "User4", "value": 4},{"name": "User3", "value": 3},{"name": "User2", "value": 2}]

**output : [{"name": "User2", "value": 2},{"name": "User3", "value": 3},{"name": "User4", "value": 4}]**
S
SpYk3HH

Update! Scroll to bottom of answer for smartSort prop additive that gives even more fun! Sorts arrays of anything!

My personal favorite form of this function allows for a param for Ascending, or Descending: 

function intArraySort(c, a) {
    function d(a, b) { return b - a; }
    "string" == typeof a && a.toLowerCase();
    switch (a) {
        default: return c.sort(function(a, b) { return a - b; });
        case 1:
                case "d":
                case "dc":
                case "desc":
                return c.sort(d)
    }
};

Usage as simple as: 

var ara = function getArray() {
        var a = Math.floor(Math.random()*50)+1, b = [];
        for (i=0;i<=a;i++) b.push(Math.floor(Math.random()*50)+1);
        return b;
    }();

//    Ascending
intArraySort(ara);
console.log(ara);

//    Descending
intArraySort(ara, 1);
console.log(ara);

//    Ascending
intArraySort(ara, 'a');
console.log(ara);

//    Descending
intArraySort(ara, 'dc');
console.log(ara);

//    Ascending
intArraySort(ara, 'asc');
console.log(ara);

jsFiddle

Or Code Snippet Example Here!

function intArraySort(c, a) { function d(a, b) { return b - a } "string" == typeof a && a.toLowerCase(); switch (a) { default: return c.sort(function(a, b) { return a - b }); case 1: case "d": case "dc": case "desc": return c.sort(d) } }; function tableExample() { var d = function() { var a = Math.floor(50 * Math.random()) + 1, b = []; for (i = 0; i <= a; i++) b.push(Math.floor(50 * Math.random()) + 1); return b }, a = function(a) { var b = $(""), c = $("").prependTo(b); $("", { text: intArraySort(d(), a).join(", ") }).appendTo(b); switch (a) { case 1: case "d": case "dc": case "desc": c.addClass("desc").text("Descending"); break; default: c.addClass("asc").text("Ascending") } return b }; return $("tbody").empty().append(a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1), a(), a(1)) }; tableExample(); table { border-collapse: collapse; } th, td { border: 1px solid; padding: .25em .5em; vertical-align: top; } .asc { color: red; } .desc { color: blue }

.smartSort('asc' | 'desc')

Now have even more fun with a sorting method that sorts an array full of multiple items! Doesn't currently cover "associative" (aka, string keys), but it does cover about every type of value! Not only will it sort the multiple values asc or desc accordingly, but it will also maintain constant "position" of "groups" of values. In other words; ints are always first, then come strings, then arrays (yes, i'm making this multidimensional!), then Objects (unfiltered, element, date), & finally undefineds and nulls!

"Why?" you ask. Why not!

Now comes in 2 flavors! The first of which requires newer browsers as it uses Object.defineProperty to add the method to the Array.protoype Object. This allows for ease of natural use, such as: myArray.smartSort('a'). If you need to implement for older browsers, or you simply don't like modifying native Objects, scroll down to Method Only version. 

/* begin */
/* KEY NOTE! Requires EcmaScript 5.1 (not compatible with older browsers) */
;;(function(){if(Object.defineProperty&&!Array.prototype.smartSort){var h=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a>b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("a");b instanceof Array&&b.smartSort("a");if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("a"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("a"),a.id==e[0]?1:-1;e=[a.tagName, b.tagName].smartSort("a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("a"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d"); return a[d].tagName==c[0]?1:-1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]>g[1]},k=function(a,b){if(null== a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.smartSort("d");b instanceof Array&&b.smartSort("d");if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=e.concat(g).smartSort("a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=[a[c],b[c]].smartSort("d"),a[c]==d[0]?-1:1;var f=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=[a.id,b.id].smartSort("d"),a.id==e[0]?-1:1;e=[a.tagName,b.tagName].smartSort("d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);e.concat(g).smartSort("a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=[a[d].id,b[f].id].smartSort("d"),a[d].id==c[0]?-1:1;c=[a[d].tagName,b[f].tagName].smartSort("d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=[a[d],b[f]].smartSort("d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1;if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=[a[Object.keys(a)[0]],b[Object.keys(b)[0]]].smartSort("d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]};Object.defineProperty(Array.prototype,"smartSort",{value:function(){return arguments&& (!arguments.length||1==arguments.length&&/^a([sc]{2})?$|^d([esc]{3})?$/i.test(arguments[0]))?this.sort(!arguments.length||/^a([sc]{2})?$/i.test(arguments[0])?h:k):this.sort()}})}})();
/* end */

jsFiddle Array.prototype.smartSort('asc|desc')

Use is simple! First make some crazy array like: 

window.z = [ 'one', undefined, $('<span />'), 'two', null, 2, $('<div />', { id: 'Thing' }), $('<div />'), 4, $('<header />') ];
z.push(new Date('1/01/2011'));
z.push('three');
z.push(undefined);
z.push([ 'one', 'three', 'four' ]);
z.push([ 'one', 'three', 'five' ]);
z.push({ a: 'a', b: 'b' });
z.push({ name: 'bob', value: 'bill' });
z.push(new Date());
z.push({ john: 'jill', jack: 'june' });
z.push([ 'abc', 'def', [ 'abc', 'def', 'cba' ], [ 'cba', 'def', 'bca' ], 'cba' ]);
z.push([ 'cba', 'def', 'bca' ]);
z.push({ a: 'a', b: 'b', c: 'c' });
z.push({ a: 'a', b: 'b', c: 'd' });

Then simply sort it! 

z.smartSort('asc'); // Ascending
z.smartSort('desc'); // Descending

Method Only

Same as the preceding, except as just a simple method! 

/* begin */
/* KEY NOTE! Method `smartSort` is appended to native `window` for global use. If you'd prefer a more local scope, simple change `window.smartSort` to `var smartSort` and place inside your class/method */
window.smartSort=function(){if(arguments){var a,b,c;for(c in arguments)arguments[c]instanceof Array&&(a=arguments[c],void 0==b&&(b="a")),"string"==typeof arguments[c]&&(b=/^a([sc]{2})?$/i.test(arguments[c])?"a":"d");if(a instanceof Array)return a.sort("a"==b?smartSort.asc:smartSort.desc)}return this.sort()};smartSort.asc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return a-b;if(/^stringstring$/ig.test(e))return a> b;if(/(string|number){2}/ig.test(e))return/string/i.test(c)?1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.asc);b instanceof Array&&b.sort(smartSort.asc);if(a instanceof Date&&b instanceof Date)return a-b;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c], b[c]],"a"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"a"),a.id==e[0]?1:-1;e=smartSort([a.tagName,b.tagName],"a");return a.tagName==e[0]?1:-1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g), "a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&&b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"a"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"a");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"a"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1; if(b.hasOwnProperty(f)&&b[f]instanceof Element||!a.hasOwnProperty(d))return-1;if(!b.hasOwnProperty(d))return 1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"a");return a[Object.keys(a)[0]]==c[0]?1:-1}g=[a,b].sort();return g[0]>g[1]};smartSort.desc=function(a,b){if(null==a||void 0==a)return 1;if(null==b||void 0==b)return-1;var c=typeof a,e=c+typeof b;if(/^numbernumber$/ig.test(e))return b-a;if(/^stringstring$/ig.test(e))return b>a;if(/(string|number){2}/ig.test(e))return/string/i.test(c)? 1:-1;if(/number/ig.test(e)&&/object/ig.test(e)||/string/ig.test(e)&&/object/ig.test(e))return/object/i.test(c)?1:-1;if(/^objectobject$/ig.test(e)){a instanceof Array&&a.sort(smartSort.desc);b instanceof Array&&b.sort(smartSort.desc);if(a instanceof Date&&b instanceof Date)return b-a;if(a instanceof Array&&b instanceof Array){var e=Object.keys(a),g=Object.keys(b),e=smartSort(e.concat(g),"a"),d;for(d in e)if(c=e[d],a[c]!=b[c])return d=smartSort([a[c],b[c]],"d"),a[c]==d[0]?-1:1;var f=smartSort([a[Object.keys(a)[0]], b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==f[0]?-1:1}if(a instanceof Element&&b instanceof Element){if(a.tagName==b.tagName)return e=smartSort([a.id,b.id],"d"),a.id==e[0]?-1:1;e=smartSort([a.tagName,b.tagName],"d");return a.tagName==e[0]?-1:1}if(a instanceof Date||b instanceof Date)return a instanceof Date?1:-1;if(a instanceof Array||b instanceof Array)return a instanceof Array?-1:1;e=Object.keys(a);g=Object.keys(b);smartSort(e.concat(g),"a");for(c=0;20>c;c++){d=e[c];f=g[c];if(a.hasOwnProperty(d)&& b.hasOwnProperty(f)){if(a[d]instanceof Element&&b[f]instanceof Element){if(a[d].tagName==b[f].tagName)return c=smartSort([a[d].id,b[f].id],"d"),a[d].id==c[0]?-1:1;c=smartSort([a[d].tagName,b[f].tagName],"d");return a[d].tagName==c[0]?-1:1}if(a[d]instanceof Element||b[f]instanceof Element)return a[d]instanceof Element?1:-1;if(a[d]!=b[f])return c=smartSort([a[d],b[f]],"d"),a[d]==c[0]?-1:1}if(a.hasOwnProperty(d)&&a[d]instanceof Element)return 1;if(b.hasOwnProperty(f)&&b[f]instanceof Element)return-1; if(!a.hasOwnProperty(d))return 1;if(!b.hasOwnProperty(d))return-1}c=smartSort([a[Object.keys(a)[0]],b[Object.keys(b)[0]]],"d");return a[Object.keys(a)[0]]==c[0]?-1:1}g=[a,b].sort();return g[0]<g[1]}
/* end */

Use: 

z = smartSort(z, 'asc'); // Ascending
z = smartSort(z, 'desc'); // Descending

jsFiddle Method smartSort(Array, "asc|desc")

P
Peter Mortensen

Try this code:

HTML: 

<div id="demo"></div>

JavaScript code: 

<script>
    (function(){
        var points = [40, 100, 1, 5, 25, 10];
        document.getElementById("demo").innerHTML = points;
        points.sort(function(a, b){return a-b});
        document.getElementById("demo").innerHTML = points;
    })();
</script>
M
Marek Urbanowicz

Try this code as below 

var a = [5, 17, 29, 48, 64, 21];
function sortA(arr) {
return arr.sort(function(a, b) {
return a - b;
})
;} 
alert(sortA(a));
C
Chris Kobrzak

TypeScript variant 

const compareNumbers = (a: number, b: number): number => a - b

myArray.sort(compareNumbers)
A
Adam M. Costello

The accepted answer and equivalents like numArray.sort((a,b) => a - b) are great when the array contains only numbers without infinities or NaN. They can be extended to handle infinities and NaN like so: 

numArray.sort((a,b) => (+a || 0) - (+b || 0) || 0);

This sorts NaN (or any non-number, like 'foo' or {}) as if it were 0. The final || 0 is needed to handle the case where a and b are equal infinities.

C
Coffezilla

In order to create this kind of sort, you have to pass a function that will check which comes first.

define inside the function which value do you wanna check: a.id - a.id

const myJson = [ { id: 1, name: 'one'}, { id: 4, name: 'four'}, { id: 2, name: 'two'}, { id: 3, name: 'three'} ]; // provide the sort method to check const myNewSort = myJson.sort(function(a, b) { return a.id - b.id; }); console.log('my new sort',myNewSort)

f
fcdt

You can sort number array simply by

const num=[13,17,14,19,16]; let temp; for(let i=0;inum[j]){ temp=num[i] num[i]=num[j] num[j]=temp } } } console.log(num);

Question is how to sort numbers using array method sort().
b
bortunac

sort_mixed 

Object.defineProperty(Array.prototype,"sort_mixed",{
    value: function () { // do not use arrow function
        var N = [], L = [];
        this.forEach(e => {
            Number.isFinite(e) ? N.push(e) : L.push(e);
        });
        N.sort((a, b) => a - b);
        L.sort();
        [...N, ...L].forEach((v, i) => this[i] = v);
        return this;
    })

try a =[1,'u',"V",10,4,"c","A"].sort_mixed(); console.log(a)

M
Mejan

If anyone doesn't understand how Array.sort() works with integers, read this answer.

Alphabetical order:

By default, the sort() method sorts the values as strings in alphabetical and ascending order. 

const myArray = [104, 140000, 99];
myArray.sort();
console.log(myArray); // output is [104, 140000, 99]

Ascending order with array.sort(compareFunction): 

const myArray = [104, 140000, 99];
myArray.sort(function(a, b){
  return a - b;
});
console.log(myArray); // output is [99, 104, 140000]

Explanation from w3schools:

compareFunction defines an alternative sort order. The function should return a negative, zero, or positive value, depending on the arguments, like: function(a, b){return a-b} When the sort() method compares two values, it sends the values to the compare function, and sorts the values according to the returned (negative, zero, positive) value. Example: When comparing 40 and 100, the sort() method calls the compare function(40,100). The function calculates 40-100, and returns -60 (a negative value). The sort function will sort 40 as a value lower than 100.

Descending order with array.sort(compareFunction): 

const myArray = [104, 140000, 99];
myArray.sort(function(a, b){
  return b - a;
});
console.log(myArray); // output is [140000, 104, 99]

This time we calculated with b - a(i.e., 100-40) which returns a positive value.

M
MD SHAYON

You can get height and lowest number simply by using max() and min() in-built function 

var numArray = [140000, 104, 99];
console.log(Math.max(...numArray));
console.log(Math.min(...numArray));

If you want to sort in ascending or descending order 

numArray.sort((a, b)=> a - b);

Know more

T
Tesla

If you need to calculate and sort the largest charCodeAt from a list of string this is the right way. 

const arrayLines = '1.1.1.1\n1.0.1.1\n1.1.1.2\n1.1.1.0'.split('\n');

// Response: (4) ['1.0.1.1', '1.1.1.0', '1.1.1.1', '1.1.1.2']
arrayLines.sort((a, b) => {
    let a_charCodeSize = 0,
        b_charCodeSize = 0;

    // Loop true a & b characters and calculate the charCodeAt size.
    for (const aChar of a) a_charCodeSize += aChar.charCodeAt(0);
    for (const bChar of b) b_charCodeSize += bChar.charCodeAt(0);

    return a_charCodeSize - b_charCodeSize;
});
why the need to write any implementation, javascript sort natively does exactly same thing, it compares strings by their character code from starting index and moves forward. arrayLines.sort() responses same way, without passing any custom function
@SajidAli Natively sort does not compare all characters one by one but instead evaluate the whole value given. Which will not result in a correct response in that scenario.
try native sort in above example and see... sort() sorts the elements of array in place and returns sorted array. Default sort order is ascending, built upon converting the elements into strings, then comparing their sequences of UTF-16 code units values If function is not supplied, all non-undefined array elements are sorted by converting them to strings and comparing strings in UTF-16 code units order. For example, "banana" comes before "cherry". In a numeric sort, 9 comes before 80, but because numbers are converted to strings, "80" comes before "9" in the Unicode order. ref: MDN
@SajidAli i tried it but it doesn't produce the desired output. sort using a-b is returning ['1.1.1.1', '1.0.1.1', '1.1.1.2', '1.1.1.0'] which makes no sense.
that's your problem right there. no need to add a-b at all, just use sort without passing any callback function. arrayLines.sort(), and it will show you same result as you got by implementing your own custom callback method
A
Anshul Chaurasia

As sort method converts Array elements into string. So, below way also works fine with decimal numbers with array elements. 

let productPrices = [10.33, 2.55, 1.06, 5.77];
console.log(productPrices.sort((a,b)=>a-b));

And gives you the expected result.

“As sort method converts Array elements into string.” — No, it doesn’t.
P
Putzi San

Sort integers > 0, think outside the box:

function sortArray(arr) { return new Promise((resolve) => { const result = [] arr.forEach((item) => { setTimeout(() => { result.push(item) if (result.length === arr.length) resolve(result) }, item) }) }) } sortArray([4, 2, 42, 128, 56, 2]).then((result) => { document.write(JSON.stringify(result)) })

Note that this should not be used productively, .sort() is better suited for this, check the other answers

Can you explain why to use asynchronous call to sort numbers?
2
2 revs

Ascending const movements = [200, 450, -400, 3000, -650, -130, 70, 1300];

If we return something < 0 then A will be before B If we return something > 0 then B will be before A 

 movements.sort((a, b) => {
      if (a > b) return 1; //- (Switch order)
      if (a < b) return -1; //- (Keep order)
    });

a - current value, b - the next value.

Descending movements.sort((a, b) => { if (a > b) return -1; // - (Keep) if (a < b) return 1; // - (Switch) });

! Improve, best solution ! 

movements.sort ((a, b) => a - b); // Same result!

If a < b it's negative number(Switch) If a < b it's negative number(Keep)

Your last bit has a typo, leading to a oxymoron. Your first bit does not address the situation where a==b. To format inline code, isurrounded it by single backtics.

关注公众号,不定期副业成功案例分享
Follow WeChat

Success story sharing

Want to stay one step ahead of the latest teleworks?

Subscribe Now

HuntsBot,a one-stop outsourcing task, remote job, product ideas sharing and subscription platform, which supports DingTalk, Lark, WeCom, Email and Telegram robot subscription. The platform will push outsourcing task requirements, remote work opportunities, product ideas to every subscribed user with timely, stable and reliable.

简体中文 English

Platform

Support

Links

Contact US

Any questions or suggestions during use, you can contact us in the following ways:

Email: huntsbot@xinbeitime.com

Copyright© 2022-2023 www.huntsbot.com 浙ICP备2022000860号-4 All Rights Reserved.