⑴ js使用Array.prototype.sort()對數組對象排序的方法
本文實例講述了js使用Array.prototype.sort()對數組對象排序的方法。分享給大家供大家參考。具體分析如下：
在講對數組對象進行排序時，我們先來簡單的了解一下Array.prototype.sort()。sort方法接受一個參數——Function，function會提供兩個參數，分別是兩個進行比較的元素，如果元素是String類型則通過Unicode
code進行比較，如果是Number類型則比較值的大小。如果比較的函數中返回1則兩個元素交換位置，0和-1不交換位置。先看一個例子：
復制代碼
代碼如下:var
arr
=
[3,
5,
2,
1];
//
從小到大排序
arr.sort(function
(a,
b)
{
return
a
>
b
?
1
:
-1;
});
//
得到的結果：[1,
2,
3,
5]
那麼回到我們的主題，如果是對一個數組對象進行排序，該怎麼寫呢？其實原理和上面一樣，如：
復制代碼
代碼如下:var
arr
=
[
{
a
:
2,
b
:
3.2},
{
a
:
3,
b
:
1.2},
{
a
:
4,
b
:
2.2},
{
a
:
6,
b
:
1.2},
{
a
:
5,
b
:
3.2}
]
///
從小到大按屬性b排序
arr.sort(function(x,
y){
return
x.b
>
y.b
?
1:-1;
});
x和y就是arr的一個元素，即一個對象，所以直接比較兩個對象的屬性即可。
上面的例子中，最小的元素中有重復，如果需求是：先按b屬性從小到大排序，如果最小中有重復則再按a屬性排序，那應該怎麼寫呢？
在排序的時候，先按b屬性排序，如果x.b的大於y.b則將x移到y的右邊，如果x.b等於y.b則再通過x.a和y.a進行比較，所以代碼如下：
復制代碼
代碼如下:arr.sort(function
(x,
y)
{
if
(x.b
>
y.b)
{
return
1;
}
else
if
(x.b
===
y.b)
{
return
x.a
>
y.a
?
1
:
-1;
}
else
if
(x.b
<
y.b)
{
return
-1;
}
})
希望本文所述對大家的javascript程序設計有所幫助。
⑵ JavaScript中的sort方法的原理，它是怎麼實現的
假如有一個數組，像這樣var arr = [1,2,4,3,5,56,223,545];你想排序var newArr = arr.sort(function(a,b){ return a>b;//這樣就實現了排序，並返回已排好序的新數組});如果數組里是對象，那麼a和b的值便是對象，你只需要將對象中的某個屬性拿出來比較就可以了
⑶ JS實現數組排序的方法有哪些
從給定的數據中，隨機抽出一項，這項的左邊放所有比它小的，右邊放比它大的，然後再分別這兩邊執行上述操作，採用的是遞歸的思想，總結出來就是實現一層，分別給兩邊遞歸，設置好出口
functionfastSort(array,head,tail){
//考慮到給每個分區操作的時候都是在原有的數組中進行操作的，所以這里head,tail來確定分片的位置
/*生成隨機項*/
varrandomnum=Math.floor(ranDom(head,tail));
varrandom=array[randomnum];
/*將小於random的項放置在其左邊策略就是通過一個臨時的數組來儲存分好區的結果，再到原數組中替換*/
vararrayTemp=[];
varunshiftHead=0;
for(vari=head;i<=tail;i++){
if(array[i]<random){
arrayTemp.unshift(array[i]);
unshiftHead++;
}elseif(array[i]>random){
arrayTemp.push(array[i]);
}
/*當它等於的時候放哪，這里我想選擇放到隊列的前面，也就是從unshift後的第一個位置放置*/
if(array[i]===random){
arrayTemp.splice(unshiftHead,0,array[i]);
}
}
/*將對應項覆蓋原來的記錄*/
for(varj=head,u=0;j<=tail;j++,u++){
array.splice(j,1,arrayTemp[u]);
}
/*尋找中間項所在的index*/
varnowIndex=array.indexOf(random);
/*設置出口，當要放進去的片段只有2項的時候就可以收工了*/
if(arrayTemp.length<=2){
return;
}
/*遞歸，同時應用其左右兩個區域*/
fastSort(array,head,nowIndex);
fastSort(array,nowIndex+1,tail);
}JavaScript實現多維數組、對象數組排序，其實用的就是原生的sort()方法，用於對數組的元素進行排序。
sort() 方法用於對數組的元素進行排序。語法如下：
arrayObject.sort(sortby)
例如：
functionNumAscSort(a,b)
{
returna-b;
}
functionNumDescSort(a,b)
{
returnb-a;
}
vararr=newArray(3600,5010,10100,801);
arr.sort(NumDescSort);
alert(arr);
arr.sort(NumAscSort);
alert(arr);
⑷ js怎麼用sort把數組裡面的英文進行首字母排序，如圖，搞不懂這一行代碼，小白，求大佬。
harCodeAt(0) 方法返回字元串第一個字元的 Unicode 編碼。
sort()方法傳入的是一個函數，函數有兩個參數(pre,next)(參數名可以任意)，依次傳入數組中的兩個元素，如果返回值小於0，則排序後pre排在next前面，
⑸ 如何寫JS數組sort的比較函數
譬如:
var
a=[1,5,3,7];
a.sort(function(a,
b)
{
return
b-a});//從大到小排列
那如果復雜點的順序應該如何寫這個比較函數呢。
對於比較函數function
f(a,b){...}
，若返回正數，則說明a和b需要交換，否則不交換。所以我們可以通通根據下面的格式去寫比較函數：
復制代碼
代碼如下:
function
f(a,
b)
{
if
(...)
{
return
1;
}
return
-1;
}
然後，我們要做的就是寫出if裡面的條件，這個條件就是返回a、b需要交換的條件。譬如：對var
a=["a","A","B","b"];進行不分大小寫並從大到小排序，僅當a.toString().toLowerCase()
<
b.toString().toLowerCase()時，交換a、b，所以用此填充if條件即可。比較函數就是：
function
f(a,
b)
{
if
(a.toString().toLowerCase()
<
b.toString().toLowerCase())
{
return
1;
}
return
-1;
}
再譬如：要使數組的元素按先奇數後偶數的順序排列，則若需a、b交換，僅當滿足a是偶數且b是奇數條件即可，再按從小到大排序，僅當滿足a、b均是奇數或偶數且a>b時即可。如下：
var
a
=
[1,
7,
3,
9,
5,
6,
2,
8,
4];
function
f(a,
b)
{
if
(0
==
a
%
2
&&
1
==
b
%
2)
{
return
1;
}
if
((1
==
a
%
2
&&
1
==
b
%
2
||
0
==
a
%
2
&&
0
==
b
%
2)
&&
a
>
b)
{
return
1;
}
return
-1;
}
alert(a.sort(f));
[Ctrl+A
全選
注:如需引入外部Js需刷新才能執行]
作者：JayChow
⑹ JS中數組重排序方法
1.數組中已存在兩個可直接用來重排序的方法：reverse（）和sort（）。
reverse()和sort（）方法的返回值是經過排序後的數組。reverse（）方法會反轉數組項的順序：
var
values=[1,2,3,4,5];
values.reverse();
alert(values);
//5,4,3,2,1
在默認情況下，sort（）方法按升序排列數組，sort（）方法會調用每個數組項的toString（）轉型方法，然後比較得到字元串，確定如何排序。即使數組中的每一項都是數值，sort（）方法比較的也是字元串：
var
values
=
[0,1,5,10,15];
values.sort();
alert(values);
//0,1,10,15,5
因此，sort（）方法可以接收一個比較函數作為參數。
function
compare(value1,value2){
if
(value1
<
value2){
return
-1;
}else
if
(value1
>
value2){
return
1;
}else{
return
0;
}
}
此比較函數可適用於大多數數據類型，只要將其作為參數傳遞給sort（）方法即可：
var
values
=
[0,1,3,7,9,15];
values.sort(compare);
alert(values);
//0,1,3,7,9,15
也可通過比較函數產生降序排序，只需交換函數返回值即可：
function
compare
(value1,
value2){
if
(value1<value2){
return
1;
}else
if
{
return
-1;
}else{
return
0;
}
}
sort()函數的排序條件是：
參數大於0，arr的相鄰兩個元素交換位置;
參數小於0，arr的相鄰兩個元素不交換位置;
參數等於0，arr的相鄰兩個元素大小相等;所以compare自定義函數必須返回一個數值。
2.對於數值類型或者valueOf（）方法會返回數值類型的對象類型。
可使用一個更簡單的比較函數。此函數只要第二個值減第一個值即可。
function
compare
(value1,value2){
return
value2
-
value1;
}
以上所述是小編給大家介紹的JS中數組重排序方法，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對腳本之家網站的支持！
⑺ Js中的數組sort()排序問題
當兩個數相等時，換位置和不換位置結果都一樣，所以return 0確實沒什麼意義，但總不能把0排除在外吧，所以其實把0作為正數或負數處理都可以。
其實你的比較函數不用搞這么復雜的，這樣即可：
functioncompare(v1,v2){
returnv1-v2;
}同理，如果要從大到小排列就這樣：
functioncompare(v1,v2){
returnv2-v1;
}
⑻ JS數組sort方法如何使用
定義和用法：
sort() 方法用於對數組的元素進行排序。
語法：
1
arrayObject.sort(sortby)
描述：
sortby 可選。規定排序順序。必須是函數。
返回值：
對數組的引用。請注意，數組在原數組上進行排序，不生成副本。
說明：
如果調用該方法時沒有使用參數，將按字母順序對數組中的元素進行排序，說得更精確點，是按照字元編碼的順序進行排序。要實現這一點，首先應把數組的元素都轉換成字元串（如有必要），以便進行比較。
如果想按照其他標准進行排序，就需要提供比較函數，該函數要比較兩個值，然後返回一個用於說明這兩個值的相對順序的數字。比較函數應該具有兩個參數 a 和 b，其返回值如下：
若 a 小於 b，在排序後的數組中 a 應該出現在 b 之前，則返回一個小於 0 的值。
若 a 等於 b，則返回 0。
若 a 大於 b，則返回一個大於 0 的值。
⑼ 如何查看js的sort方法的源碼
sort() 方法用於對數組的元素進行排序。 語法： arrayObject.sort(sortby)描述
⑽ js中sort方法的源碼，該怎麼解決
unction ArraySort(comparefn) {
// In-place QuickSort algorithm.
// For short (length <= 22) arrays, insertion sort is used for efficiency.
var custom_compare = IS_FUNCTION(comparefn);
function Compare(x,y) {
// Assume the comparefn, if any, is a consistent comparison function.
// If it isn't, we are allowed arbitrary behavior by ECMA 15.4.4.11.
if (x === y) return 0;
if (custom_compare) {
// Don't call directly to avoid exposing the builtin's global object.
return comparefn.call(null, x, y);
}
if (%_IsSmi(x) && %_IsSmi(y)) {
return %SmiLexicographicCompare(x, y);
}
x = ToString(x);
y = ToString(y);
if (x == y) return 0;
else return x < y ? -1 : 1;
};
function InsertionSort(a, from, to) {
for (var i = from + 1; i < to; i++) {
var element = a[i];
// Pre-convert the element to a string for comparison if we know
// it will happen on each compare anyway.
var key =
(custom_compare || %_IsSmi(element)) ? element : ToString(element);
// place element in a[from..i[
// binary search
var min = from;
var max = i;
// The search interval is a[min..max[
while (min < max) {
var mid = min + ((max - min) >> 1);
var order = Compare(a[mid], key);
if (order == 0) {
min = max = mid;
break;
}
if (order < 0) {
min = mid + 1;
} else {
max = mid;
}
}
// place element at position min==max.
for (var j = i; j > min; j--) {
a[j] = a[j - 1];
}
a[min] = element;
}
}
function QuickSort(a, from, to) {
// Insertion sort is faster for short arrays.
if (to - from <= 22) {
InsertionSort(a, from, to);
return;
}
var pivot_index = $floor($random() * (to - from)) + from;
var pivot = a[pivot_index];
// Pre-convert the element to a string for comparison if we know
// it will happen on each compare anyway.
var pivot_key =
(custom_compare || %_IsSmi(pivot)) ? pivot : ToString(pivot);
// Issue 95: Keep the pivot element out of the comparisons to avoid
// infinite recursion if comparefn(pivot, pivot) != 0.
a[pivot_index] = a[from];
a[from] = pivot;
var low_end = from; // Upper bound of the elements lower than pivot.
var high_start = to; // Lower bound of the elements greater than pivot.
// From low_end to i are elements equal to pivot.
// From i to high_start are elements that haven't been compared yet.
for (var i = from + 1; i < high_start; ) {
var element = a[i];
var order = Compare(element, pivot_key);
if (order < 0) {
a[i] = a[low_end];
a[low_end] = element;
i++;
low_end++;
} else if (order > 0) {
high_start--;
a[i] = a[high_start];
a[high_start] = element;
} else { // order == 0
i++;
}
}
QuickSort(a, from, low_end);
QuickSort(a, high_start, to);
}
var old_length = ToUint32(this.length);
if (old_length < 2) return this;
%RemoveArrayHoles(this);
var length = ToUint32(this.length);
// Move undefined elements to the end of the array.
for (var i = 0; i < length; ) {
if (IS_UNDEFINED(this[i])) {
length--;
this[i] = this[length];
this[length] = void 0;
} else {
i++;
}
}
QuickSort(this, 0, length);
// We only changed the length of the this object (in
// RemoveArrayHoles) if it was an array. We are not allowed to set
// the length of the this object if it is not an array because this
// might introce a new length property.
if (IS_ARRAY(this)) {
this.length = old_length;
}
return this;
}