blocks|key|2017234|text|要比较值，可以使用比较方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2017235|function+naturalSorter(as,+bs){
++++var+a,+b,+a1,+b1,+i=+0,+n,+L,
++++rx=/(\.\d%2B)%7C(\d%2B(\.\d%2B)?)%7C([%5E\d.]%2B)%7C(\.\D%2B)%7C(\.$)/g;
++++if(as===+bs)+return+0;
++++a=+as.toLowerCase().match(rx);
++++b=+bs.toLowerCase().match(rx);
++++L=+a.length;
++++while(i<L){
++++++++if(!b[i])+return+1;
++++++++a1=+a[i],
++++++++b1=+b[i%2B%2B];
++++++++if(a1!==+b1){
++++++++++++n=+a1-b1;
++++++++++++if(!isNaN(n))+return+n;
++++++++++++return+a1>b1?+1:-1;
++++++++}
++++}
++++return+b[i]?+-1:0;
}|code-block|syntax|javascript|2017236|但是为了提高数组排序的速度，请在排序前调整数组，这样您只需执行一次小写转换和正则表达式，而不是在排序的每个步骤中执行一次。|2017237|function+naturalSort(ar,+index){
++++var+L=+ar.length,+i,+who,+next,+
++++isi=+typeof+index==+'number',+
++++rx=++/(\.\d%2B)%7C(\d%2B(\.\d%2B)?)%7C([%5E\d.]%2B)%7C(\.(\D%2B%7C$))/g;
++++function+nSort(aa,+bb){
++++++++var+a=+aa[0],+b=+bb[0],+a1,+b1,+i=+0,+n,+L=+a.length;
++++++++while(i<L){
++++++++++++if(!b[i])+return+1;
++++++++++++a1=+a[i];
++++++++++++b1=+b[i%2B%2B];
++++++++++++if(a1!==+b1){
++++++++++++++++n=+a1-b1;
++++++++++++++++if(!isNaN(n))+return+n;
++++++++++++++++return+a1>b1?+1:+-1;
++++++++++++}
++++++++}
++++++++return+b[i]!=+undefined?+-1:+0;
++++}
++++for(i=+0;+i<L;+i%2B%2B){
++++++++who=+ar[i];
++++++++next=+isi?+ar[i][index]+%7C%7C+'':+who;
++++++++ar[i]=+[String(next).toLowerCase().match(rx),+who];
++++}
++++ar.sort(nSort);
++++for(i=+0;+i<L;+i%2B%2B){
++++++++ar[i]=+ar[i][1];
++++}
}|2017238|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To compare values you can use a comparing method-

<pre><code>function naturalSorter(as, bs){
 var a, b, a1, b1, i= 0, n, L,
 rx=/(\.\d+)|(\d+(\.\d+)?)|([^\d.]+)|(\.\D+)|(\.$)/g;
 if(as=== bs) return 0;
 a= as.toLowerCase().match(rx);
 b= bs.toLowerCase().match(rx);
 L= a.length;
 while(i&lt;L){
 if(!b[i]) return 1;
 a1= a[i],
 b1= b[i++];
 if(a1!== b1){
 n= a1-b1;
 if(!isNaN(n)) return n;
 return a1&gt;b1? 1:-1;
 }
 }
 return b[i]? -1:0;
}
</code></pre>

But for speed in sorting an array, rig the array before sorting,
so you only have to do lower case conversions and the regular expression
once instead of in every step through the sort.

<pre><code>function naturalSort(ar, index){
 var L= ar.length, i, who, next, 
 isi= typeof index== 'number', 
 rx= /(\.\d+)|(\d+(\.\d+)?)|([^\d.]+)|(\.(\D+|$))/g;
 function nSort(aa, bb){
 var a= aa[0], b= bb[0], a1, b1, i= 0, n, L= a.length;
 while(i&lt;L){
 if(!b[i]) return 1;
 a1= a[i];
 b1= b[i++];
 if(a1!== b1){
 n= a1-b1;
 if(!isNaN(n)) return n;
 return a1&gt;b1? 1: -1;
 }
 }
 return b[i]!= undefined? -1: 0;
 }
 for(i= 0; i&lt;L; i++){
 who= ar[i];
 next= isi? ar[i][index] || '': who;
 ar[i]= [String(next).toLowerCase().match(rx), who];
 }
 ar.sort(nSort);
 for(i= 0; i&lt;L; i++){
 ar[i]= ar[i][1];
 }
}
</code></pre>

blocks|key|2017341|text|基于@Adrien+Be上面的回答，并使用Brian+Huisman+&+David+koelle创建的代码，下面是一个对象数组的修改过的原型排序：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2017342|//Usage:+unsortedArrayOfObjects.alphaNumObjectSort("name");
//Test+Case:+var+unsortedArrayOfObjects+=+[{name:+"a1"},+{name:+"a2"},+{name:+"a3"},+{name:+"a10"},+{name:+"a5"},+{name:+"a13"},+{name:+"a20"},+{name:+"a8"},+{name:+"8b7uaf5q11"}];
//Sorted:+[{name:+"8b7uaf5q11"},+{name:+"a1"},+{name:+"a2"},+{name:+"a3"},+{name:+"a5"},+{name:+"a8"},+{name:+"a10"},+{name:+"a13"},+{name:+"a20"}]

//+**Sorts+in+place**
Array.prototype.alphaNumObjectSort+=+function(attribute,+caseInsensitive)+{
++for+(var+z+=+0,+t;+t+=+this[z];+z%2B%2B)+{
++++this[z].sortArray+=+new+Array();
++++var+x+=+0,+y+=+-1,+n+=+0,+i,+j;

++++while+(i+=+(j+=+t[attribute].charAt(x%2B%2B)).charCodeAt(0))+{
++++++var+m+=+(i+==+46+%7C%7C+(i+>=48+&&+i+<=+57));
++++++if+(m+!==+n)+{
++++++++this[z].sortArray[%2B%2By]+=+"";
++++++++n+=+m;
++++++}
++++++this[z].sortArray[y]+%2B=+j;
++++}
++}

++this.sort(function(a,+b)+{
++++for+(var+x+=+0,+aa,+bb;+(aa+=+a.sortArray[x])+&&+(bb+=+b.sortArray[x]);+x%2B%2B)+{
++++++if+(caseInsensitive)+{
++++++++aa+=+aa.toLowerCase();
++++++++bb+=+bb.toLowerCase();
++++++}
++++++if+(aa+!==+bb)+{
++++++++var+c+=+Number(aa),+d+=+Number(bb);
++++++++if+(c+==+aa+&&+d+==+bb)+{
++++++++++return+c+-+d;
++++++++}+else+{
++++++++++return+(aa+>+bb)+?+1+:+-1;
++++++++}
++++++}
++++}

++++return+a.sortArray.length+-+b.sortArray.length;
++});

++for+(var+z+=+0;+z+<+this.length;+z%2B%2B)+{
++++//+Here+we're+deleting+the+unused+"sortArray"+instead+of+joining+the+string+parts
++++delete+this[z]["sortArray"];
++}
}|code-block|syntax|javascript|2017343|entityMap|0|LINK|mutability|MUTABLE|url|http://www.davekoelle.com/files/alphanum.js|1|http://www.davekoelle.com/alphanum.html^0|L|D|0|11|C|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

Building on @Adrien Be's answer above and using the code that <a href="http://www.davekoelle.com/files/alphanum.js" rel="nofollow noreferrer">Brian Huisman</a> &amp; <a href="http://www.davekoelle.com/alphanum.html" rel="nofollow noreferrer">David koelle</a> created, here is a modified prototype sorting for an array of objects:

<pre><code>//Usage: unsortedArrayOfObjects.alphaNumObjectSort("name");
//Test Case: var unsortedArrayOfObjects = [{name: "a1"}, {name: "a2"}, {name: "a3"}, {name: "a10"}, {name: "a5"}, {name: "a13"}, {name: "a20"}, {name: "a8"}, {name: "8b7uaf5q11"}];
//Sorted: [{name: "8b7uaf5q11"}, {name: "a1"}, {name: "a2"}, {name: "a3"}, {name: "a5"}, {name: "a8"}, {name: "a10"}, {name: "a13"}, {name: "a20"}]

// **Sorts in place**
Array.prototype.alphaNumObjectSort = function(attribute, caseInsensitive) {
 for (var z = 0, t; t = this[z]; z++) {
 this[z].sortArray = new Array();
 var x = 0, y = -1, n = 0, i, j;

 while (i = (j = t[attribute].charAt(x++)).charCodeAt(0)) {
 var m = (i == 46 || (i &gt;=48 &amp;&amp; i &lt;= 57));
 if (m !== n) {
 this[z].sortArray[++y] = "";
 n = m;
 }
 this[z].sortArray[y] += j;
 }
 }

 this.sort(function(a, b) {
 for (var x = 0, aa, bb; (aa = a.sortArray[x]) &amp;&amp; (bb = b.sortArray[x]); x++) {
 if (caseInsensitive) {
 aa = aa.toLowerCase();
 bb = bb.toLowerCase();
 }
 if (aa !== bb) {
 var c = Number(aa), d = Number(bb);
 if (c == aa &amp;&amp; d == bb) {
 return c - d;
 } else {
 return (aa &gt; bb) ? 1 : -1;
 }
 }
 }

 return a.sortArray.length - b.sortArray.length;
 });

 for (var z = 0; z &lt; this.length; z++) {
 // Here we're deleting the unused "sortArray" instead of joining the string parts
 delete this[z]["sortArray"];
 }
}
</code></pre>

blocks|key|1803710|text|如果你有一个对象数组，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1803711|myArrayObjects+=+myArrayObjects.sort(function(a,+b)+{
++return+a.name.localeCompare(b.name,+undefined,+{
++++numeric:+true,
++++sensitivity:+'base'
++});
});|code-block|syntax|javascript|1803712|​|1803713|var+myArrayObjects+=+[{
++++"id":+1,
++++"name":+"1+example"
++},
++{
++++"id":+2,
++++"name":+"100+example"
++},
++{
++++"id":+3,
++++"name":+"12+example"
++},
++{
++++"id":+4,
++++"name":+"5+example"
++},

]

myArrayObjects+=+myArrayObjects.sort(function(a,+b)+{
++return+a.name.localeCompare(b.name,+undefined,+{
++++numeric:+true,
++++sensitivity:+'base'
++});
});
console.log(myArrayObjects);|1803714|1803715|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

If you have a array of objects you can do like this: 

<pre><code>myArrayObjects = myArrayObjects.sort(function(a, b) {
 return a.name.localeCompare(b.name, undefined, {
 numeric: true,
 sensitivity: 'base'
 });
});
</code></pre>

<div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var myArrayObjects = [{
 "id": 1,
 "name": "1 example"
 },
 {
 "id": 2,
 "name": "100 example"
 },
 {
 "id": 3,
 "name": "12 example"
 },
 {
 "id": 4,
 "name": "5 example"
 },

]

myArrayObjects = myArrayObjects.sort(function(a, b) {
 return a.name.localeCompare(b.name, undefined, {
 numeric: true,
 sensitivity: 'base'
 });
});
console.log(myArrayObjects);</code></pre>
</div>
</div>

blocks|key|1803789|text|到2019年为止，功能最全的库似乎是natural-orderby。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1803790|import+{+orderBy+}+from+'natural-orderby'

const+unordered+=+[
++'123asd',
++'19asd',
++'12345asd',
++'asd123',
++'asd12'
]

const+ordered+=+orderBy(unordered)

//+[+'19asd',
//+++'123asd',
//+++'12345asd',
//+++'asd12',
//+++'asd123'+]|code-block|syntax|javascript|1803791|它不仅接受字符串数组，还可以按对象数组中某个键的值进行排序。它还可以自动识别和排序字符串:货币、日期、货币和其他一堆东西。|1803792|令人惊讶的是，压缩后的大小也只有1.6kB。|1803793|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/yobacca/natural-orderby^0|I|F|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|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

The most fully-featured library to handle this as of 2019 seems to be <a href="https://github.com/yobacca/natural-orderby" rel="nofollow noreferrer">natural-orderby</a>.
<pre class="lang-js prettyprint-override"><code>import { orderBy } from 'natural-orderby'

const unordered = [
 '123asd',
 '19asd',
 '12345asd',
 'asd123',
 'asd12'
]

const ordered = orderBy(unordered)

// [ '19asd',
// '123asd',
// '12345asd',
// 'asd12',
// 'asd123' ]
</code></pre>
It not only takes arrays of strings, but also can sort by the value of a certain key in an array of objects. It can also automatically identify and sort strings of: currencies, dates, currency, and a bunch of other things.
Surprisingly, it's also only 1.6kB when gzipped.

I'm looking for the easiest way to sort an array that consists of numbers and text, and a combination of these.
E.g.
<pre><code>'123asd'
'19asd'
'12345asd'
'asd123'
'asd12'
</code></pre>
turns into
<pre><code>'19asd'
'123asd'
'12345asd'
'asd12'
'asd123'
</code></pre>
This is going to be used in combination with the solution to <a href="https://stackoverflow.com/questions/2793847/sort-outer-array-based-on-values-in-inner-array-javascript">another question I've asked here</a>.
The sorting function in itself works, what I need is a function that can say that that '19asd' is smaller than '123asd'.
I'm writing this in JavaScript.
Edit: as adormitu pointed out, what I'm looking for is a function for natural sorting

Javascript : natural sort of alphanumerical strings

我正在寻找一种最简单的方法来对由数字和文本组成的数组以及它们的组合进行排序。例如。'123asd''19asd''12345asd''asd123''asd12'变成了'19asd''123asd''12345asd''asd12''asd123'这将与的解决方案结合使用。排序函数本身是有效的，我需要的是一个可以说'1...

问Javascript :自然类型的字母数字字符串
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript :自然类型的字母数字字符串EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Javascript :自然类型的字母数字字符串
EN