blocks|key|789337|text|var+data+=+[
++++{+'value'+:+5,+'name'+:+'foo'},
++++{+'value'+:+3,+'name'+:+'bar'},
++++{+'value'+:+10,+'name'+:+'js'}
];

var+changed+=+sortAndReport(data,+byValue);

//+sortAndReport+::+[a],+(a,+a+->+Number)+->+Boolean
//+Sorts+an+array+according+to+the+provided+Array.prototype.sort
//+compare+function+and+returns+a+Boolean+indicating+whether
//+sorting+changed+the+order+of+the+array.
function+sortAndReport(a,+fn)+{
++++var+changed+=+false;

++++a.sort(function+(a,+b)+{
++++++++var+sortResult+=+fn(a,+b);
++++++++changed++++++++=+sortResult+>+0;
++++++++return+sortResult;
++++});

++++return+changed;
}

//+byValue+::+{+value+::+Number+},+{+value+::+Number+}+->+Number
function+byValue(a,+b)+{
++++return+a.value+-+b.value;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|789338|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var data = [
 { 'value' : 5, 'name' : 'foo'},
 { 'value' : 3, 'name' : 'bar'},
 { 'value' : 10, 'name' : 'js'}
];

var changed = sortAndReport(data, byValue);

// sortAndReport :: [a], (a, a -&gt; Number) -&gt; Boolean
// Sorts an array according to the provided Array.prototype.sort
// compare function and returns a Boolean indicating whether
// sorting changed the order of the array.
function sortAndReport(a, fn) {
 var changed = false;

 a.sort(function (a, b) {
 var sortResult = fn(a, b);
 changed = sortResult &gt; 0;
 return sortResult;
 });

 return changed;
}

// byValue :: { value :: Number }, { value :: Number } -&gt; Number
function byValue(a, b) {
 return a.value - b.value;
}
</code></pre>

blocks|key|1268834|text|你必须以某种方式来比较这些数组。您可以很容易地克隆一个数组并进行检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1268835|++var+arr+=+[5,+4,+1,+6]
++var+arrBefore+=+arr.slice(0);
++arr.sort()

++for(var+i+=0;+i<+arr.length;+i%2B%2B)+{+
++++if+(arrBefore[i]+!==+arr[i])+{
++++++//+a+change+was+made
++++}
++}+|code-block|syntax|javascript|1268836|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You have to compare the arrays somehow. You can easily clone an array and make the check:

<pre><code> var arr = [5, 4, 1, 6]
 var arrBefore = arr.slice(0);
 arr.sort()

 for(var i =0; i&lt; arr.length; i++) { 
 if (arrBefore[i] !== arr[i]) {
 // a change was made
 }
 } 
</code></pre>

blocks|key|1268847|text|你所要求的，没有什么是内置的。如果它是一个简单的数组，您只需使用join/toString()并比较最后两个字符串。如果数组包含对象，则可能使用JSON.stringify并进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1268848|var+myArray1+=+[1,2,3,4,5],
++++myArray2+=+[2,1,3,4,5],
++++myArray1_sorted+=+myArray1.slice().sort(),
++++myArray2_sorted+=+myArray2.slice().sort();

//Check+to+see+if+the+strings+are+the+same+or+different
console.log(+myArray1_sorted.toString()+===+myArray1.toString()+);+//true+-+sort+should+not+change+anything
console.log(+myArray2_sorted.toString()+===+myArray2.toString()+);+//false+-+sort+should+have+changed+order|code-block|syntax|javascript|1268849|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

There is nothing built in that does what you are asking. If it is a simple array you can just use join/toString() and compare the two final strings. If the array contains objects, probably would use JSON.stringify and compare.

<pre><code>var myArray1 = [1,2,3,4,5],
 myArray2 = [2,1,3,4,5],
 myArray1_sorted = myArray1.slice().sort(),
 myArray2_sorted = myArray2.slice().sort();

//Check to see if the strings are the same or different
console.log( myArray1_sorted.toString() === myArray1.toString() ); //true - sort should not change anything
console.log( myArray2_sorted.toString() === myArray2.toString() ); //false - sort should have changed order
</code></pre>

blocks|key|789398|text|简而言之:没有内置函数，您必须检查是否相等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|789399|这里有一种检查是否平等的方法：|789400|function+arraysEqual(a,+b)+{

++++//+Are+the+lengths+the+same?
++++var+i+=+a.length;
++++if+(i+!==+b.length)
++++++++return+false;

++++//+Are+all+the+values+the+same?
++++while+(i+--)+{
++++++++if+(a[i]+!==+b[i])
++++++++++++return+false;
++++}

}|code-block|syntax|javascript|789401|请注意，这并不会检查它们是否为数组；arraysEqual("abc",+["a",+"b",+"c"])为真。如果愿意，可以添加这张支票。|offset|length|style|CODE|789402|entityMap^0|0|0|0|I|Z|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In short: no built-in function, you've gotta check for equality.

Here's one way to check for equality:

<pre><code>function arraysEqual(a, b) {

 // Are the lengths the same?
 var i = a.length;
 if (i !== b.length)
 return false;

 // Are all the values the same?
 while (i --) {
 if (a[i] !== b[i])
 return false;
 }

}
</code></pre>

Note that this doesn't check if they're arrays; <code>arraysEqual("abc", ["a", "b", "c"])</code> is true. You can add this check if you want.

blocks|key|624994|text|没有一个内置的功能来做你想做的事。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|624995|这个怎么样：|624996|function+isArraySorted(array)+{
++++if+(!array.length)+{
++++++++return+true;
++++}
++++var+lastElement+=+array[0];
++++for+(var+i+=+1;+i+<+array.length;+i%2B%2B)+{
++++++++if+(array[i]+<=+lastElement)+{
++++++++++++return+false;
++++++++}
++++++++lastElement+=+array[i];
++++}
++++return+true;
}

alert(isArraySorted([1,2,3])+%2B+"+"+%2B+isArraySorted([1,2,3,2.5]));

var+array+=+[1,2,3];

if+(!isArraySorted(array))+{
++++//+No+need+to+do+the+sort+if+the+array+is+already+sorted.
++++array.sort();
}|code-block|syntax|javascript|624997|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

There's not a built-in function to do what you want.

How about this:

<pre><code>function isArraySorted(array) {
 if (!array.length) {
 return true;
 }
 var lastElement = array[0];
 for (var i = 1; i &lt; array.length; i++) {
 if (array[i] &lt;= lastElement) {
 return false;
 }
 lastElement = array[i];
 }
 return true;
}

alert(isArraySorted([1,2,3]) + " " + isArraySorted([1,2,3,2.5]));

var array = [1,2,3];

if (!isArraySorted(array)) {
 // No need to do the sort if the array is already sorted.
 array.sort();
}
</code></pre>

blocks|key|624999|text|来自Array.sort文档：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|625000|array.sort([compareFunction])|code-block|syntax|javascript|625001|因此，很明显，没有内置的解决方案/方法来检测至少一个元素在排序过程中是否改变了其位置。因此，您需要编写自己的方法：|625002|function+isAnyElementChangedItsPosition(+unsortedArray,+sortedArray+){
+++for(+var+i+=+0;+i+<+unsortedArray.length;+%2B%2Bi){
+++++++if(+unsortedArray[i]+!==+sortedArray[i]+){
+++++++++++return+true;
+++++++}
+++}+
+++return+false;
}|625003|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/sort^0|2|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

From <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/sort" rel="nofollow">Array.sort</a> docs:

<pre><code>array.sort([compareFunction])
</code></pre>

So it is obvious, there is no built-in solution/method for detecting whether at least one element has changed its position during the sorting. So you need to write your own method:

<pre><code>function isAnyElementChangedItsPosition( unsortedArray, sortedArray ){
 for( var i = 0; i &lt; unsortedArray.length; ++i){
 if( unsortedArray[i] !== sortedArray[i] ){
 return true;
 }
 } 
 return false;
}
</code></pre>

blocks|key|1268943|text|不复制数据，因为字符串和并行数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1268944|function+chkOrder(a)+{
++for(var+i+=1;+i<+a.length;+i%2B%2B)
++++if+(a[i-1]+>+a[i])+return+false;
++return+true;
}|code-block|syntax|javascript|1268945|您可能需要在">“符号上工作，如果您颠倒顺序，这也会在第一天返回false+(而不是order+)。|1268946|如果我们可以控制包含的对象，那么我们就可以控制对象中的更改，并触发父排序。|1268947|function+O(parent,data)+{//initialize+with+parent+and+value+array/object
++this.parent=parent;
++this.data=data;
++//shortcurt+to+sort+parent
++this.sort=function()
++++{console.log("sortingparent");this.parent.sort(this.parent.sortfunc);}
++this.setData=function(data)+{
++this.data=data;
++this.sort();
}
//if+changes+can+be+groupped+then+is+more+efficient+to+signal+parent+dirty+and+sort+latter
this.setKey=function(key,value)+{//change+value+in+the+data
++if+(key==parent.sortkey&&value!=this.data[key])+{
++++this.data[key]=value;
++++this.sort();
++}+else+this.data[key]=value;
}
this.parent.push(this);
++this.sort();
++return+this;
}
//-------
//using+a+simple+array,+this+could+also+be+and+object+and+have+specific+func's
var+arr=[];
//example,+sort+by+name,+ascending
arr.sortkey="name";
//closure+to+build+a+sort+predicate+bound+to+the+used+key
function+setkey(key)+{return+function(a,b)+{return+a.data[key]>b.data[key];}}
arr.sortfunc=setkey(arr.sortkey);
var+b=new+O(arr,{name:"B",value:0});
var+c=new+O(arr,{name:"C",value:2});
var+a=new+O(arr,{name:"A",value:1});
var+d=new+O(arr,{name:"D",value:3});
console.log("changing+value");
a.setKey("value",100);//when+not+sorting+by+value+its+the+same+as+a.data.value=100
console.log("changing+name");
a.setKey("name","X");//this+will+fire+parent+sort
for(n=0;n<arr.length;n%2B%2B)+console.log(arr[n].data.name,"=",arr[n].data.value);|1268948|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Not duplicating data, becase strings and parallel arrays do.

<pre><code>function chkOrder(a) {
 for(var i =1; i&lt; a.length; i++)
 if (a[i-1] &gt; a[i]) return false;
 return true;
}
</code></pre>

you might need to work on th ">" sign if you reverse the order
this will also return false (not ordered) on first occourence

if we can control the contained objects then we can control changes in the objects and fire a parent sort

<pre><code>function O(parent,data) {//initialize with parent and value array/object
 this.parent=parent;
 this.data=data;
 //shortcurt to sort parent
 this.sort=function()
 {console.log("sortingparent");this.parent.sort(this.parent.sortfunc);}
 this.setData=function(data) {
 this.data=data;
 this.sort();
}
//if changes can be groupped then is more efficient to signal parent dirty and sort latter
this.setKey=function(key,value) {//change value in the data
 if (key==parent.sortkey&amp;&amp;value!=this.data[key]) {
 this.data[key]=value;
 this.sort();
 } else this.data[key]=value;
}
this.parent.push(this);
 this.sort();
 return this;
}
//-------
//using a simple array, this could also be and object and have specific func's
var arr=[];
//example, sort by name, ascending
arr.sortkey="name";
//closure to build a sort predicate bound to the used key
function setkey(key) {return function(a,b) {return a.data[key]&gt;b.data[key];}}
arr.sortfunc=setkey(arr.sortkey);
var b=new O(arr,{name:"B",value:0});
var c=new O(arr,{name:"C",value:2});
var a=new O(arr,{name:"A",value:1});
var d=new O(arr,{name:"D",value:3});
console.log("changing value");
a.setKey("value",100);//when not sorting by value its the same as a.data.value=100
console.log("changing name");
a.setKey("name","X");//this will fire parent sort
for(n=0;n&lt;arr.length;n++) console.log(arr[n].data.name,"=",arr[n].data.value);
</code></pre>

blocks|key|789454|text|如果不想弄乱数组的两个副本，请在开始排序之前检查数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|789455|如果每个项都处于排序位置，则可以循环遍历数组，并返回true+(比较“小于”下一项)，或在检测到一个项位于错误位置时返回false。|789456|由于您使用的是对象，比较代码取决于对对象进行排序的方式。|789457|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If you don't want to mess with two copies of the array, check the array before starting the sort.

You can loop through the array and return true if every item is in its sorted position, 
(compares 'less' than the next item) or false as soon as one item is detected in the wrong position.

Since you are using objects, the comparison code depends on the way you are sorting the objects.

I'm using array.sort to sort an array of objects.

Is there someway to determine if the order of those objects changed other than doing a comparison myself? Some in-built JS function? I don't need to know the # of changes, just that there was at least 1 change.

Update:

I'm sorting custom objects, e.g.:

<pre><code>[
 { 'value' : 5, 'name' : 'foo'},
 { 'value' : 3, 'name' : 'bar'},
 { 'value' : 10, 'name' : 'js'}
]
</code></pre>

Update 2:

I'm considering adding an additional custom property 'order' as I generate the objects and then checking to see if 'order' is or isn't sequential after the .sort. Is there a faster/better method?

JS Sort - Determine if Anything Changed?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我使用array.sort对对象数组进行排序。除了自己做比较之外，还有什么方法可以确定这些对象的顺序是否发生了变化？内置的JS功能？我不需要知道改变的#，只是至少有一个变化。更新：我正在对定制对象进行排序，例如：[ { 'value' : 5, 'name' : 'foo'}, { 'value' : 3, 'name...

问JS分类-确定有什么变化吗？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JS分类-确定有什么变化吗？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JS分类-确定有什么变化吗？
EN