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