数组方法、冒泡排序、选择排序

数组

对象允许存储键值化的集合，这很好。

但很多时候我们需要的是有序集合，里面的元素都是按顺序排列的。例如，我们可能需要存储一些列表，比如用户、商品以及 HTML 元素等。

这里使用对象就不是很方便了，因为对象不提供能够管理元素顺序的方法。我们不能在已有的元素“之间”插入一个新的属性。这种场景下对象就不太适用了。

声明数组

三种声明：

1. 通过new关键字创建数组

let arr = new Array(1，true，3);

2.省略new关键字创建数组

let arr = Array(1，false，3);

3.字面量赋值

var arr = [10,true,"hello",20];

【注】前两种方式，若传入参数只有一个，且为number时，这个数字表示声明的数组的长度，而不是存放的数据。

var arr = new Array(10);//数组长度为10
var arr1=  Array(10);//数组长度为10

数组下标

从0开始，数据在数组中的序号。最大值为length-1.

绝大多数情况下使用的都是第二种语法。我们可以在方括号中添加初始元素：

let fruits = ["Apple", "Orange", "Plum"];

数组元素从 0 开始编号。

我们可以将元素的索引值填写在方括号内来获取元素：

let fruits = ["Apple", "Orange", "Plum"];

alert( fruits[0] ); // Apple
alert( fruits[1] ); // Orange
alert( fruits[2] ); // Plum

可以替换元素：

fruits[2] = 'Pear'; // 现在变成 ["Apple", "Orange", "Pear"]

…或者新加一个元素：

fruits[3] = 'Lemon'; // 现在变成 ["Apple", "Orange", "Pear", "Lemon"]

length 属性的值是数组中元素的总个数

let fruits = ["Apple", "Orange", "Plum"];

alert( fruits.length ); // 3

也可以用 alert 来显示整个数组。

let fruits = ["Apple", "Orange", "Plum"];

alert( fruits ); // Apple,Orange,Plum

数组可以存储任何类型的元素。

例如:

// 混合值
let arr = [ 'Apple', { name: 'John' }, true, function() { alert('hello'); } ];

// 获取索引为 1 的对象然后显示它的 name
alert( arr[1].name ); // John

// 获取索引为 3 的函数并执行
arr[3](); // hello

以逗号结尾

数组和对象一样，都可以在末尾冗余一个逗号：

         let fruits = [
  "Apple",
  "Orange",
  "Plum",
];

因为每一行都是相似的，所以这种以“逗号结尾”的方式使得插入/移除项变得更加简单。

遍历数组

1、for循环遍历数组

遍历数组最古老的方式就是 for 循环

let arr = ["Apple", "Orange", "Pear"];

for (let i = 0; i < arr.length; i++) {
  alert( arr[i] );// Apple, Orange, Pear
}

2、for…in循环遍历数组

这个key指的是每个元素的下标；

let arr = ["Apple", "Orange", "Pear"];

for (let key in arr) {
  alert( arr[key] ); // Apple, Orange, Pear
}

3、for…of循环遍历

这个key指的是数组中的每个元素；

let fruits = ["Apple", "Orange", "Plum"];

// 迭代数组元素
for (let kry of fruits) {
  alert( key );
}

区别

1. for in不需要每次都判断，效率更高
2. for..of 不能获取当前元素的索引，但大多数情况是够用的。而且这样写更短。
3. for in若在遍历过程中，数组发生了变化，会出现问题，不安全。

数组方法

push()

​ 功能：给数组的末尾添加元素

​ 格式：数组名.push(参数…)

​ 返回值：插入元素后的数组长度

pop()

​ 功能：在数组的末尾取下一个元素

​ 格式：数组名.pop()

​ 返回值：取下的元素。

unshift()

​ 功能：从数组的头部添加元素

​ 格式：数组名.unshift(参数…)

​ 返回值：插入元素后的数组长度

shift()

​ 功能：从数组的头部取下一个元素

​ 格式：数组名.shift()

​ 返回值：取下的元素。

concat()

​ 功能：合并数组。

​ 格式：数组名.concat(数组);

​ 1.copy原数组，生成新数组。

​ 2.将输入的数组中的元素单独拆分出来，添加到新数组中。

		var arr = [1, 2, "3", true, 5];
        var arr2 = [5, 6];
        var newArr = arr.concat(arr2);
        alert(newArr);//1,2,3,true,5,5,6

slice()

​ 功能：获取当前数组指定区域的元素，生成新数组。

​ 格式：数组名.slice(start,end) 含头不含尾

​ start:开始位置的下标

​ end：结束位置的下标

​ 返回值：新数组，原数组不变。

indexof()

​ 功能：在数组中查找第一次出现元素的下标。

​ 格式：数组.index(item,start);

​ 参数：

​ item：要查找的元素

​ start：开始查找的位置

​ 返回值：查找到的元素下标，若未查到，则返回-1。

forEach()

​ 格式：数组.forEach(function(item,index,arr)){

​ }

​ 参数：

​ item：当前遍历的元素，

​ index：当前遍历元素的下标

​ arr：数组

splice()

​ 截取

​ 格式：数组.splice(start,length,数据…)

​ 返回值：截取的元素

​ 参数：

​ start：开始截取的位置

​ length：截取的长度

​ 第三个参数开始：在start位置开始，插入新元素。

1. 增

    arr.splice(1,0,"5");//在下标为1的位置增加一个元素5
   

2. 删

    arr.splice(1,1);//在下标为1的位置删除一个元素
   

3. 改

    arr.splice(1,1,'44');//在下标为1的位置原来下标为1的值，然后在下标为1 的地方添加一个元素44
   

join()

​ 格式：数组.join(字符串);

​ 功能：将数组中元素用指定的字符串拼接

​ 返回值：拼接好的字符串

 var str = [1, 2, 32];;
 document.write(str.join('='));//1=2=32

reverse()

​ 功能：将数组元素反转。

​ 格式:数组.reverse();

​ 该方法会修改原数组。

​

sort()

方法对数组进行 原位（in-place） 排序，更改元素的顺序。(译注：原位是指在此数组内，而非生成一个新数组。)

它还返回排序后的数组，但是返回值通常会被忽略，因为修改了 arr 本身。

语法：

let arr = [ 1, 2, 15 ];

// 该方法重新排列 arr 的内容
arr.sort();

alert( arr );  // 1, 15, 2

你有没有注意到结果有什么奇怪的地方？

顺序变成了 1, 15, 2。不对，但为什么呢？

这些元素默认情况下被按字符串进行排序。

数组排序

比较函数可以返回任何数字

实际上，比较函数只需要返回一个正数表示“大于”，一个负数表示“小于”。

通过这个原理我们可以编写更短的函数：

let arr = [ 1, 2, 15 ];

arr.sort(function(a, b) { return a - b; });

alert(arr);  // 1, 2, 15

箭头函数最好

你还记得 箭头函数 吗？这里使用箭头函数会更加简洁：

arr.sort( (a, b) => a - b );

冒泡排序

 var arr = [1, 3, 2, 4, 6, 5];

规则：从左到右，数组中相邻的两个元素进行比较。将较大（较小）的数放在后面。

​ 规律:每一轮都可以找出一个最大（最小）值，放在正确的位置上。

​ 比较的轮次：数组的长度-1

每一轮比较的次数：数组长度-当前的轮次

 var arr = [1, 3, 2, 4, 6, 5];
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        document.write(arr)

选择排序

规则：选出一个位置，让这个位置上的数与后面的数比较，如果大于（小于）后面的数，则交换位置。然后对该位置进行下一轮比较。

​ 规律：每一轮，在当前位置找到正确的值，每一轮结束后确定一个下标的值。

​ 比较的轮次：数组的长度-1

​ 每一轮比较的次数：数组长度-当前的轮次

 var arr = [1, 3, 2, 4, 6, 5];
        for (var i = 0; i < arr.length - 1; i++) {
            for (var j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    var temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        document.write(arr)

​