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 = $("<tr/>"),
				c = $("<th/>").prependTo(b);
			$("<td/>", {
				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 }

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
<table><tbody></tbody></table>

Antwoord 17

Probeer deze 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>

Antwoord 18

Probeer deze code zoals hieronder

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

Antwoord 19

Dit is de reeds voorgestelde en geaccepteerde oplossing als methode op het Array-prototype:

Array.prototype.sortNumeric = function () {
    return this.sort((a, b) => a - b);
};
Array.prototype.sortNumericDesc = function () {
    return this.sort((a, b) => b - a);
};

Antwoord 20

TypeScript-variant

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

Antwoord 21

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

Antwoord 22

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;
    })

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

Antwoord 23

Als iemand niet begrijpt hoe Array.sort()werkt met gehele getallen, lees dan dit antwoord.

Alfabetische volgorde:

Standaard sorteert de methode sort() de waarden als tekenreeksen in alfabetische en oplopende volgorde.

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

Oplopende volgorde met array.sort(compareFunction):

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

Uitleg van w3schools:

compareFunctiondefinieert een alternatieve sorteervolgorde. De functie moet een negatieve, nul of positieve waarde retourneren, afhankelijk van de argumenten, zoals:
functie(a, b){return a-b}
Wanneer de methode sort() twee waarden vergelijkt, verzendt deze de waarden naar de vergelijkingsfunctie en sorteert de waarden volgens de geretourneerde (negatieve, nul, positieve) waarde.

Voorbeeld:

Bij het vergelijken van 40 en 100 roept de sort()-methode de vergelijking aan
functie(40.100).

De functie berekent 40-100, en retourneert -60 (een negatieve waarde).

De sorteerfunctie sorteert 40 als een waarde lager dan 100.

Aflopende volgorde met array.sort(compareFunction):

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

Deze keer hebben we berekend met b - a(d.w.z. 100-40), wat een positieve waarde oplevert.

Antwoord 24

Arrays met objecten sorteren. Matrix[{obj}, [obj]]

const arrNames = [
    { name: 'Andrzej' },
    { name: 'Mikolaj' },
    { name: 'Witalik' },
    { name: 'Iwan' },
    { name: 'Kasia' },
    { name: 'Joanna' },
    { name: 'Zuzanna' },
    { name: 'Anatol' },
  ];
 arrNames.sort(function (a, b): number {
   const x = a.name.toUpperCase();
   const y = b.name.toUpperCase();
   return x === y ? 0 : +(x > y) || -1; // change ">" for sorting
 });

of kort:

arrNames.sort((a, b) => a.name.localeCompare(b.name));
arrNames.sort((a, b) => b.name.localeCompare(a.name));

Arrays-nummers sorteren:

const arrNum = [1, 80, 3, 2, 4, 6, 5, 12, 20, 100000];
arrNum.sort((a, b) => a - b);
arrNum.sort((a, b) => b - a);

Deze functie sorteert Arrays [getallen en tekenreeksen]

[arrNames or arrNum].sort((a, b) => (a === b ? 0 : +(a > b) || -1));

Antwoord 25

U kunt de hoogte en het laagste aantal eenvoudig verkrijgen door de ingebouwde functie max()en min()te gebruiken

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

Als u in oplopende of aflopende volgorde wilt sorteren

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

Meer weten

Antwoord 26

Het geaccepteerde antwoord, numArray.sort((a,b) => a - b), is geweldig als de array alleen getallen bevat zonder oneindigheden of NaN. Het kan worden uitgebreid om oneindigheden en NaN aan te kunnen, zoals:

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

Dit sorteert NaN (of een niet-getal, zoals ‘foo’ of {}) alsof het 0 is. De laatste || 0is nodig om het geval te behandelen waarin a en b gelijke oneindigheden zijn.

Antwoord 27

As sort-methode zet Array-elementen om in string. Dus, onderstaande manier werkt ook prima met decimale getallen met array-elementen.

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

En geeft je het verwachte resultaat.

Antwoord 28

Sorteer gehele getallen > 0, denk buiten de kaders:

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))
})

const num=[13,17,14,19,16];
let temp;
for(let i=0;i<num.length;i++){
    for(let j=i+1;j<num.length;j++){
        if(num[i]>num[j]){
            temp=num[i]
            num[i]=num[j]
            num[j]=temp
        }
    }
}
console.log(num);

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

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