පූර්ණ සංඛ්‍යා පමණක් අඩංගු වන බව මා දන්නා අරාවකින් ඉහළම සහ අඩුම අගය ලබා ගැනීමට උත්සාහ කිරීම මා සිතුවාට වඩා දුෂ්කර බව පෙනේ.

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

මෙය පෙන්වනු ඇතැයි මම බලාපොරොත්තු වෙමි 99, 104, 140000. ඒ වෙනුවට එය පෙන්නුම් කරයි 104, 140000, 99. එබැවින් වර්ග කිරීම අගයන් නූල් ලෙස හසුරුවන බව පෙනේ.

නිඛිල අගය මත වර්ග කිරීම සඳහා වර්ග කිරීමේ ශ්‍රිතය ලබා ගැනීමට ක්‍රමයක් තිබේද?

පෙරනිමියෙන්, වර්ග කිරීමේ ක්‍රමය මූලද්‍රව්‍ය අකාරාදී පිළිවෙලට වර්ග කරයි. සංඛ්‍යාත්මකව වර්ග කිරීම සඳහා සංඛ්‍යාත්මක වර්ගයන් හසුරුවන නව ක්‍රමයක් එක් කරන්න (sortNumber, පහත පෙන්වා ඇත) -

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

console.log(numArray);

ඊඑස් 6 හි, ඊතල ශ්‍රිත සමඟ ඔබට මෙය සරල කළ හැකිය:

numArray.sort((a, b) => a - b); // For ascending sort
numArray.sort((a, b) => b - a); // For descending sort

ප්‍රලේඛනය:

Array.prototype.sort()අනන්තය හෝ NaN අඩංගු නොවන අරා සඳහා මෙම සංසන්දනාත්මක ශ්‍රිතය මොසිල්ලා නිර්දේශ කරයි. (මන්ද Inf - InfNaN මිස 0 නොවේ).

යතුරෙන් වස්තු වර්ග කිරීම සඳහා උදාහරණ ද ඇත.

ඉහත සියලු පිළිතුරු මත පදනම්ව, ඒවා එක පේළියකින් කළ හැකිය:

var numArray = [140000, 104, 99];

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

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

//outputs: 99, 104, 140000

array.sort සංඛ්‍යාත්මක වර්ග කිරීම සඳහා පෙරනිමියෙන් ශබ්දකෝෂ වර්ග කිරීමක් සිදු කරයි, ඔබේම ශ්‍රිතයක් සපයයි. මෙන්න සරල උදාහරණයක්:

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

numArray.sort(compareNumbers);

වර්ග කිරීම "තැනින් තැන" ක්‍රියාත්මක වන බව සලකන්න, පැවරුම අවශ්‍ය නොවේ.

මෙම පිළිතුර දැනට පවතින සමහර පිළිතුරු වලට සමාන වේ, නමුත් ECMAScript 6 ඊතල ශ්‍රිත මඟින් වඩාත් සංයුක්ත වාක්‍ය ඛණ්ඩයක් සපයන අතර එමඟින් කියවීමේ හැකියාව කැප නොකර පේළිගත කිරීමේ ශ්‍රිතයක් අර්ථ දැක්වීමට අපට ඉඩ සලසයි:

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

අද බොහෝ බ්‍රව්සර් වල එය සහය දක්වයි .

සංසන්දනාත්මක ශ්‍රිතයක් ලබා දීමට සියලු දෙනා නිර්දේශ කරන්නේ මන්දැයි මම පුදුම වෙමි sort() , එමඟින් වර්ග කිරීම සැබවින්ම මන්දගාමී වේ!

අංක වර්ග කිරීම සඳහා, ඕනෑම ටයිප්ඩ්ආරියක් සාදන්න :

var numArray = new Int32Array([140000, 104, 99]);
numArray = numArray.sort();
alert(numArray)

වර්ග කිරීමේ ක්‍රියාකාරිත්වය එතරම් අමුතු ලෙස හැසිරීමට හේතුව

සිට ප්රලේඛනය :

[...] අරාව එක් එක් අක්ෂරවල යුනිකෝඩ් කේත ලක්ෂ්‍ය අගය අනුව, එක් එක් මූලද්‍රව්‍යයේ නූල් පරිවර්තනයට අනුව වර්ග කර ඇත.

ඔබ අරාවෙහි යුනිකෝඩ් ලක්ෂ්‍ය අගයන් මුද්‍රණය කළහොත් එය පැහැදිලි වනු ඇත.

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

මෙය නැවත පැමිණේ: "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)

දැන්, 140000 සහ 104 එකම අගයන් ලබා දුන් නිසා (49) එය පළමු දර්ශකය කපා නැවත පරීක්ෂා කරයි:

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)

අපි මෙය වර්ග කළහොත් අපට ලැබෙනුයේ:

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

එබැවින් 104 පැමිණෙන්නේ 140000 ට පෙරය.

එබැවින් අවසාන ප්‍රති result ලය වනු ඇත්තේ:

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

104, 140000, 99

නිගමනය:

sort() සංඛ්‍යා වල පළමු දර්ශකය දෙස බැලීමෙන් පමණක් වර්ග කිරීම සිදු කරයි. sort()මුළු සංඛ්‍යාවක් තවත් සංඛ්‍යාවට වඩා විශාල නම් එය ගණන් නොගනී, එය ඉලක්කම්වල යුනිකෝඩයේ අගය සංසන්දනය කරයි, සහ සමාන යුනිකෝඩ් අගයන් දෙකක් තිබේ නම්, එය ඊළඟ ඉලක්කම් තිබේදැයි පරීක්ෂා කර එය සංසන්දනය කරයි.

නිවැරදිව වර්ග කිරීම සඳහා, මෙහිsort() විස්තර කර ඇති ආකාරයට සැසඳීමේ ශ්‍රිතයක් ඔබ විසින් සම්මත කළ යුතුය .

කෙසේ වෙතත් භාවිතා කිරීම වෙනුවට මම අක්ස් සමඟ එකඟ වෙමි

return a - b;

ඔබ භාවිතා කළ යුතුය

return a > b ? 1 : a < b ? -1 : 0;

නව ES6 ලෝකයේ වර්ග කිරීම පහසුය

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

ඔබට අවශ්‍ය වන්නේ එයයි :)

ජාවාස්ක්‍රිප්ට් හි වර්ග කිරීම () ක්‍රමයේ පෙරනිමි හැසිරීම වන්නේ අරා වල අගයන් අකාරාදී පිළිවෙලට තැබීමයි.

අංක අනුව වර්ග කිරීම සඳහා ඔබට සංඛ්‍යාත්මක වර්ග කිරීමේ ශ්‍රිතයක් අර්ථ දැක්විය යුතුය (එය ඉතා පහසුය):

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

numArray = numArray.sort(sortNumber);

Array.prototype.sort () යනු අරා වර්ග කිරීම සඳහා වන ක්‍රමයකි, නමුත් අප දැනුවත් විය යුතු කරුණු කිහිපයක් තිබේ.

වර්ග කිරීමේ අනුපිළිවෙල පෙරනිමියෙන් ශබ්දකෝෂයක් වන අතර අරාවෙහි ඇති අගයන් වර්ග නොසලකා සංඛ්‍යාත්මක නොවේ. අරාව සියලු සංඛ්‍යා වුවද, සියලු අගයන් නූල් බවට පරිවර්තනය කර ශබ්ද කෝෂ අනුව වර්ග කරනු ලැබේ.

එබැවින් පහත දැක්වෙන ආකාරයට වර්ග කිරීමේ () සහ ප්‍රතිලෝම () ක්‍රමය අභිරුචිකරණය කළ යුතුය.

යොමු කළ URL

අරාව තුළ අංක වර්ග කිරීම සඳහා

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

අරාව තුළ සංඛ්‍යා ආපසු හැරවීම සඳහා

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

යොමු කළ URL

ප්රශ්නයට දැනටමත් පිළිතුරු ලබා දී ඇත, කෙටිම sort()ක්රමය ක්රමය භාවිතා කිරීමයි . නමුත් ඔබ ඔබේ සංඛ්‍යා පෙළ වර්ග කිරීමට තවත් ක්‍රම සොයන්නේ නම් සහ ඔබ චක්‍රයටද ඇලුම් කරන්නේ නම්, පහත සඳහන් දෑ පරීක්ෂා කරන්න

ඇතුළත් කිරීමේ වර්ග කිරීම

නැගීම:

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

බැසයාම:

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

තෝරා ගැනීමේ වර්ග කිරීම:

නැගීම:

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

බැසයාම:

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

විනෝද වන්න

පහත දැක්වෙන 'සංඛ්‍යාත්මකව' ශ්‍රිතය ඇමතුම් ලබා ගැනීමේ ශ්‍රිතයක් ලෙස සපයන විට බොහෝ අවස්ථාවන්හි සංඛ්‍යා සංඛ්‍යා සංඛ්‍යාත්මකව වර්ග කිරීමේ අරමුණ ඉටු කරයි:

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

array.sort(numerically); 

නමුත් සමහර දුර්ලභ අවස්ථාවන්හි, අරාවෙහි ඉතා විශාල හා negative ණ සංඛ්‍යා අඩංගු වන විට, ජාවාස්ක්‍රිප්ට් සමඟ කටයුතු කළ හැකි කුඩාම සංඛ්‍යාවට වඩා ab හි ප්‍රති result ලය කුඩා වීම නිසා පිටාර ගැලීමේ දෝෂයක් සිදුවිය හැකිය.

එබැවින් සංඛ්‍යාත්මකව ක්‍රියා කිරීමට වඩා හොඳ ක්‍රමයක් පහත පරිදි වේ:

function numerically(a, b){
   if(a < b){
      return -1;
   } else if(a > b){
      return 1;
   } else {
      return 0;
   }
}

නිර්වචනය නොකළ, ශුන්‍ය සහ NaN හැසිරවීමට: ශුන්‍ය ලෙස හැසිරෙන්නේ 0, NaN සහ නිර්වචනය නොකළ අවසානය දක්වා ය.

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]

සාමාන්‍ය මූලද්‍රව්‍ය අගයන් සඳහා පමණක්:

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]**

වස්තු සමූහයක් සඳහා:

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}]**

ජාවාස්ක්‍රිප්ට් හි අවශ්‍ය නොවන අතර, -1, 0, හෝ 1 ( PHP හි අභ්‍යවකාශ නැව් ක්‍රියාකරු ක්‍රියා කරන ආකාරය හා සමාන) ආපසු ලබා දීමට ඔබ කැමති නම්, ඔබට භාවිතා කළ හැකිය .sort() compareFunctionMath.sign()

මෙම compareFunctionපහත දැඩි නැවත -1, 0, හෝ 1:

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

සටහන: Math.sign() ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි සහය නොදක්වයි.

යාවත්කාලීන කරන්න! smartSortඊටත් වඩා විනෝදයක් ලබා දෙන මුක්කු ආකලන සඳහා පිළිතුරේ පහළට අනුචලනය කරන්න !
අරා ආකාරයේ දෙයක් !

මෙම ශ්‍රිතයේ මගේ පුද්ගලික ප්‍රියතම ස්වරූපය නඟින්න, හෝ බැසයාම සඳහා පරාමිතියක් සඳහා ඉඩ ලබා දේ:

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

භාවිතය තරම් සරලයි:

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

හෝ කේත ස්නිපෙට් උදාහරණය මෙතැනින්!

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>

.smartSort ('asc' | 'desc')

බහුවිධ අයිතම වලින් පිරුණු පෙළක් වර්ග කරන වර්ග කිරීමේ ක්‍රමයක් සමඟ දැන් ඊටත් වඩා විනෝද වන්න! දැනට "ඇසෝසියේටිව්" (අකා, නූල් යතුරු) ආවරණය නොකරයි, නමුත් එය සෑම වර්ගයකම වටිනාකමක් ආවරණය කරයි! පමණක් නොව එය බහු වටිනාකම් පිළිවෙලට ascහෝdesc අනුව පමණක් නොව, “කණ්ඩායම්” වල නිරන්තර “පිහිටීම” ද පවත්වාගෙන යනු ඇත. වෙනත් විදිහකින්; ints සෑම විටම පළමුව, පසුව නූල්, පසුව අරා (ඔව්, මම මේ බහුමානීය සාදමි!), පසුව වස්තු (පෙර නොවූ, මූලද්‍රව්‍යය, දිනය), සහ අවසානයේ නිර්වචනය නොකළ සහ ශුන්‍ය වේ!

"මන්ද?" ඔබ අහන්න. ඇයි නැත්තේ!

දැන් රස 2 කින් පැමිණේ! ඉන් පළමුවැන්න වස්තුවට Object.definePropertyක්‍රමවේදය එක් කිරීමට භාවිතා කරන බැවින් නව බ්‍රව්සර් අවශ්‍ය වේ Array.protoype. ස්වාභාවික භාවිතය පහසු කිරීම සඳහා මෙය ඉඩ දෙයි , වැනි : myArray.smartSort('a'). ඔබට පැරණි බ්‍රව්සර් සඳහා ක්‍රියාත්මක කිරීමට අවශ්‍ය නම්, හෝ ඔබ ස්වදේශීය වස්තු වෙනස් කිරීමට අකමැති නම්, ක්‍රමයට පමණක් අනුවාදය වෙත අනුචලනය කරන්න .

/* 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')

භාවිතය සරලයි! පළමුව පිස්සු අරාව වැනි ඒවා සාදන්න:

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

ඉන්පසු එය වර්ග කරන්න!

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

ක්රමය පමණි

සරල ක්‍රමයක් හැර, පූර්වයට සමාන ය!

/* 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 */

භාවිත:

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

jsFiddle Method smartSort (අරා, "asc | desc")

මෙම කේතය උත්සාහ කරන්න:

HTML:

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

ජාවාස්ක්‍රිප්ට් කේතය:

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

පහත පරිදි මෙම කේතය උත්සාහ කරන්න

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

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

අරේ මූලාකෘතියේ ක්‍රමයක් ලෙස දැනටමත් යෝජනා කර ඇති සහ පිළිගත් විසඳුම මෙයයි:

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

වර්ග කිරීමේ ක්‍රමය මඟින් අරා මූලද්‍රව්‍ය නූල් බවට පරිවර්තනය කරයි. එබැවින්, පහත දැක්වෙන ආකාරයට අරාව මූලද්‍රව්‍ය සමඟ දශම සංඛ්‍යා සමඟ හොඳින් ක්‍රියා කරයි.

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

සහ අපේක්ෂිත ප්‍රති .ලය ඔබට ලබා දෙයි.

පූර්ණ සංඛ්‍යා> 0 වර්ග කරන්න, කොටුවෙන් පිටත සිතන්න:

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

මෙය .sort()tive ලදායී ලෙස භාවිතා නොකළ යුතු බව සලකන්න, මේ සඳහා වඩාත් සුදුසුය, අනෙක් පිළිතුරු පරීක්ෂා කරන්න

උපයෝගිතා පුස්තකාලයේ මගේ වර්ග කිරීමේ අරාව ශ්‍රිතය මෙන්න:

sortArray: function(array) {
    array.sort(function(a, b) {
        return a > b;
    });
},

# Let's test a string array
var arr = ['bbc', 'chrome', 'aux', 'ext', 'dog'];
utils.sortArray(arr);
console.log(arr);
>>> ["aux", "bbc", "chrome", "dog", "ext", remove: function]

# Let's test a number array
var arr = [55, 22, 1425, 12, 78];
utils.sortArray(arr);
console.log(arr);
>>> [12, 22, 55, 78, 1425, remove: function]