Array.sort() 要领排序，默以为升序排序，如
1，2，3，4如许的分列，能够传一个对照要领做为排序的参数，也能够不传，则为根据字符的逐一 unicode 排序。
简朴默许排序
第一步，建立一个 array.sort.js, 内里写下以下内容并保留
let array_a=[1,12,11,123,9,10,2];声明一个数字数组
array_a.sort();
//挪用数组排序
console.log(array_a);
//输出排序后的数组第二步，在命令行下运转
node array.sort.js第三步，检察运转效果
[ 1, 10, 11, 12, 123, 2, 9 ]笔记
纯数字的数组的排序效果，并没有根据
1，2，9，10，11，12，123如许输出。Arrary 的默许排序是根据字符的 unicode point 来排序，字符的第一名 unicode 越小，该字符越靠前，排序后的字符在数组中响应的索引值越小。
字符首位雷同的情况下，第二位 unicode 越小，响应字符更靠前。
以上涉及到一个字符的 unicode 转换题目，这里不多扩大，写一段代码运转历程做笔记
let str1='1',str2='中国',unicode_arr=[];
console.log(str1.charCodeAt(0));//0 代表字符中的第一名，str1 是只要长度 1 的字符; 输出 '49'
for(let i=0;i<str2.length;i++){//字符长度为不肯定时
let temp_str=str2.charCodeAt(i);
unicode_arr.push(temp_str);//放入一个数组中。
console.log(temp_str);
}
/**** 转 unicode 为字符 ****/
let str3='';
for(let i=0;i<unicode_arr.length;i++){
let temp_str=String.fromCharCode(unicode_arr[i]);
str3+=temp_str;
console.log(temp_str);
}
console.log(str3);//输出 '中国'
传入对照要领排序
第一步，在以上的代码基础上，追加下面的代码到 array.sort.js 中
let array_b=[
{key:0,val:9},
{key:1,val:6},
{key:2,val:8},
{key:3,val:7},
{key:4,val:9},
{key:5,val:10}
];第二步，增加以下对照要领做数组 array_b 的排序
array_b.sort((a,b)=>{
console.log(`array_b now is: -- ${JSON.stringify(array_b)}`);
//输出上一轮排序后的数组，第一次运转未排序
console.log(`current a is: -- ${JSON.stringify(a)}`);
//对照中的 a 是数组 array_b 中的哪一个
console.log(`a's index is:-- ${array_b.indexOf(a)}`);
//对照中的 a 在数组中的索引值
console.log(`current b is: -- ${JSON.stringify(b)}`);
//对照中的 b 是数组 array_b 中的哪一个
console.log(`b's index is: -- ${array_b.indexOf(b)}`);
//对照中的 b 在数组中的索引值
console.log(b.val-a.val);
//输出要领返回值
return b.val-a.val;
//对照要领返回值，采用了降序分列
//假如大于 0，a 的索引值要大于 b 的索引值，
//假如小于 0，a 的索引值要小于 b 的索引值，
//假如行于 0，a，b 的索引值都坚持稳固
});
console.log(array_b);//检察排序效果
/*[
{ key: 5, val: 10 },
{ key: 0, val: 9 },
{ key: 4, val: 9 },
{ key: 2, val: 8 },
{ key: 3, val: 7 },
{ key: 1, val: 6 }
]*/第三步，运转以下命令行
node array.sort.js第四步，检察排序历程
array_b now is:-- [{"key":0,"val":9},{"key":1,"val":6},{"key":2,"val":8},{"key":3,"val":7},{"key":4,"val":9},{"key":5,"val":10}]
//数组初始化时。
current a is:-- {"key":0,"val":9}
a index is:-- 0
current b is:-- {"key":1,"val":6}
b index is:-- 1
-3
//最先从数组索引 0 最先，与索引 1 对照。
array_b now is:-- [{"key":0,"val":9},{"key":1,"val":6},{"key":2,"val":8},{"key":3,"val":7},{"key":4,"val":9},{"key":5,"val":10}]
//第一次运转后，返回值为 -3， 小于 0 ，所以 a,b 的索引值未变化，a index < b index。
current a is:-- {"key":1,"val":6}
a index is:-- 1
current b is:-- {"key":2,"val":8}
b index is:-- 2
2
//最先从数组索引 1 最先，与索引 2 对照。
array_b now is:-- [{"key":0,"val":9},{"key":1,"val":6},{"key":1,"val":6},{"key":3,"val":7},{"key":4,"val":9},{"key":5,"val":10}]
//第二次运转后，因为返回值为 2，大于 0，所以 索引 1 的值临时添补索引 2 的值，并把索引 2 的值从数组中掏出，与数组中比索引 1 小的索引 0 的值对照，在对照稳固后，肯定掏出的索引 2 的值 放在数组的索引 1，或许索引 2 的位置
current a is:-- {"key":0,"val":9}
a index is:-- 0
current b is:-- {"key":2,"val":8}
b index is:-- -1
-1
//最先从数组索引 0 最先与掏出的原索引 2 对照。
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":1,"val":6},{"key":3,"val":7},{"key":4,"val":9},{"key":5,"val":10}]
//第三次运转后，因为返回值为 -1，小于 0，所以索引 0 坚持稳固，掏出的原索引 2，变成数组索引 1
current a is:-- {"key":1,"val":6}
a index is:-- 2
current b is:-- {"key":3,"val":7}
b index is:-- 3
1
//末了一次的索引肇端为 1，在第二次，第三次对照稳固后，从数组索引 2 最先与索引 3 对照
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":1,"val":6},{"key":1,"val":6},{"key":4,"val":9},{"key":5,"val":10}]
//第四次运转后，因为返回值为 1，大于 0，索引 2 与索引 3 要发作索引对换，掏出索引 3 ，并由索引 2 添补索引 3 的位置，
current a is:-- {"key":2,"val":8}
a index is:-- 1
current b is:-- {"key":3,"val":7}
b index is:-- -1
-1
//最先从比索引 2 小的索引 1 与掏出的原索引 3 对照。
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6},{"key":4,"val":9},{"key":5,"val":10}]
//第五次运转后，对照稳固后，掏出的索引 3 放在数组索引 2 的位置
current a is:-- {"key":1,"val":6}
a index is:-- 3
current b is:-- {"key":4,"val":9}
b index is:-- 4
3
//从索引 3 最先与索引 4 对照
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6},{"key":1,"val":6},{"key":5,"val":10}]
//第六次运转后，掏出索引 4 ，由索引 3 添补索引 4
current a is:-- {"key":3,"val":7}
a index is:-- 2
current b is:-- {"key":4,"val":9}
b index is:-- -1
2
//索引 2 与原索引 4 对照
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":3,"val":7},{"key":1,"val":6},{"key":5,"val":10}]
//第七次运转后，原索引 4 比索引 2 要大，索引 3，由索引 2 添补，索引 3 与索引 2 守候对照稳固后肯定
current a is:-- {"key":2,"val":8}
a index is:-- 1
current b is:-- {"key":4,"val":9}
b index is:-- -1
1
//索引 1与原索引 4 对照
array_b now is:-- [{"key":0,"val":9},{"key":2,"val":8},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6},{"key":5,"val":10}]
//第八次运转后，原索引 4 比索引 1 要大，索引 2，由索引 1 添补，索引 2 与索引 1 守候对照稳固后肯定
current a is:-- {"key":0,"val":9}
a index is:-- 0
current b is:-- {"key":4,"val":9}
b index is:-- -1
0
//索引 0 与原索引 4 对照
array_b now is:-- [{"key":0,"val":9},{"key":4,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6},{"key":5,"val":10}]
//第九次运转后，原索引 4 与原索引 0 相称，把原索引 4 放在索引 1 的位置添补，……对照到索引 0，终究稳固。
current a is:-- {"key":1,"val":6}
a index is:-- 4
current b is:-- {"key":5,"val":10}
b index is:-- 5
4
//从上次掏出的索引 4 的位置最先，与索引 5 对照
array_b now is:-- [{"key":0,"val":9},{"key":4,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6},{"key":1,"val":6}]
//第十次运转后，返回值为 4 大于 0，索引 4 与索引 5 要发作位置对换，索引 5 由索引 4 添补，并掏出索引 5 与索引 3，2，1，0 对照，不停由对照的索引出发点添补索引出发点+1 的位置，在对照稳固后，确认当前的肇端索引照样对照的肇端索引+1的位置安排掏出的原索引 5
//以下为不停的不稳固对照，不停的 a 添补 b，而且出发点索引-1 与掏出的值对照的历程。
current a is:-- {"key":3,"val":7}
a index is:-- 3
current b is:-- {"key":5,"val":10}
b index is:-- -1
3
array_b now is:-- [{"key":0,"val":9},{"key":4,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":3,"val":7},{"key":1,"val":6}]
current a is:-- {"key":2,"val":8}
a index is:-- 2
current b is:-- {"key":5,"val":10}
b index is:-- -1
2
array_b now is:-- [{"key":0,"val":9},{"key":4,"val":9},{"key":2,"val":8},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6}]
current a is:-- {"key":4,"val":9}
a index is:-- 1
current b is:-- {"key":5,"val":10}
b index is:-- -1
1
array_b now is:-- [{"key":0,"val":9},{"key":4,"val":9},{"key":4,"val":9},{"key":2,"val":8},{"key":3,"val":7},{"key":1,"val":6}]
current a is:-- {"key":0,"val":9}
a index is:-- 0
current b is:-- {"key":5,"val":10}
b index is:-- -1
1笔记
对照要领的运转次数不肯定，完全由初始数组的长度与运算值复杂度相干在对照历程当中，假如有发作索引变动，会由 a 来添补 b，构成新数组，并在下一轮对照中把索引出发点-1，由上一轮的对照中的 a 前面的一名与掏出的值做对照，取 a 前面一名的值做为 a，掏出的值为 b;
轮回2的历程，直至发作对照的 a 的索引为 0，末了在数组中肯定掏出的数组项该添补在数组哪一个位置。
被掏出数组的为下一轮对照中的 b
此篇为个人进修明白的笔记，为了更好的明白和控制，迎接留言。
