数组的基础

目录

一、数组的概念

二、数组的基本操作

三、数组的常用基本方法

四、JS中使用数组方法实现栈和队列

五、索引数组与关联(hash)数组

六、数组的排序算法

---

一、数组的概念

什么是数组？

        数组就是各种类型的数据的有序集合。

        这里的有序指的是：下标。

        注意：这里的集合不是数学上的集合以及JS中的Set，只是一种叫法，表示各类型的数据在数组中只是代表着其中的一项。

什么是下标？

        下标指的就是元素在数组中的位置。从0开始，最后一个元素的下标是元素总个数-1。

数组的三大不限制：

        1、不限制元素个数；

        2、不限制元素类型；

        3、不限制数组下标越界；

                下标越界指的就是在使用下标获取数组元素或者对数组元素进行某些操作时，超出了最大下标的值。在JS中下标越界不会报错，但是在其他语言中会报错。

二、数组的基本操作

如何获取数组的长度？

        可以直接通过：数组名.length获取数组的长度。

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

console.log(arr.length) //5

如何获取数组元素？

        使用数组的下标获取对应元素的值。（下标是从0开始的）

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

console.log(arr[0]) //1
console.log(arr[1]) //2
console.log(arr[2]) //3
console.log(arr[3]) //4
console.log(arr[4]) //4

如何改变数组元素的值？

        通过下标并赋值的方式来修改数组中对应元素的值。

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


arr[0]=8
console.log(arr[0]) //8

如何向数组的末尾添加元素？

        可以通过使用数组的长度并赋值的方式来添加。（数组的长度-1代表着最大下标，那么数组的长度就代表着紧挨最大下标后面的位置）

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

arr[arr.length]=6
console.log(arr) //[1,2,3,4,5,6]

如何使用循环遍历数组？

        可以使用for循环对数组进行遍历，循环的条件就是数组的长度。

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

for(var i=0;i<arr.length;i++){
    console.log(arr[i])
}

三、数组的常用基本方法

1、arr.push(值...)：在数组末尾添加元素

var arr=[1,2,3]

arr.push(4)
arr.push(5,6,7)
arr.push("123")
arr.push(function(){})
var res=arr.push({name:"hah"})
console.log(arr)
console.log(res)

        特点：
                1）、可以同时添加多个元素

                2）、可以添加各种类型的元素

                3）、会影响原数组

                4）、返回值是当前添加元素之后，数组的长度

2、arr.pop()：删除数组末尾的一个元素

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

var res=arr.pop()

var res2=arr.pop(5)

console.log(arr)
console.log(res)  //5
console.log(res2) //4

        特点：

                1）、一次只能删除一个，即使在括号中传递参数也无效；

                2）、返回值是被删除的元素；

                3）、会影响原数组；

3、arr.unshift()：在数组最前面添加元素

        用法和特性同push方法。

4、arr.shift()：删除一个数组最前面的元素

        用法和特性同pop方法。

5、arr.splice(starti，length，替换元素1...)：可以截取指定长度的数组，也可以替换和添加元素

只给前两个参数，且length不为0，则是截取数组，相当于删除。

var arr = [1, 2, 3, 4, 5];
var res = arr.splice(0, 3); //截取数组，相当于从0开始，删除三个元素
console.log(arr); //[4,5]
console.log(res); //[1,2,3]

加上替换元素，但length为0，表示在starti之前插入替换元素。

var arr = [1, 2, 3, 4, 5];
var res = arr.splice(0,0,5,6,7); //添加元素，相当于在原本下标为0的前面，添加元素5,6,7
console.log(arr); //[5,6,7 1, 2, 3, 4, 5]
console.log(res); //[]

加上替换元素，且length不为0，表示使用替换元素将截取的数组替换。

var arr = [1, 2, 3, 4, 5];
var res = arr.splice(0,2,5,6); //截取数组，相当于从0开始，截取两个元素，再使用5，6去替换被截取的数组
console.log(arr); //[5, 6, 3, 4, 5]
console.log(res); //[1,2]

        特点：
                1）、会影响原数组；

                2）、有返回值，返回值根据传参的不同，意义也不同；

6、arr.reverse()：翻转数组

可以将数组倒序。

var arr = [1, 2, 3, 4, 5];
var res = arr.reverse();
console.log(arr); //[5,4,3,2,1]
console.log(res); //[5,4,3,2,1]

        特点：

                1）、会影响原数组；

                2）、返回值是翻转之后的结果；

7、arr.sort()：数组排序

可以将数组内的元素进行排序。

var arr = [5,9,7,3,4,2,1];
console.log(arr); 

 但如果是多位数或者是字符串排序：

var arr=[5,9,3,5,'a','g','c','123','agv']
arr.sort()

console.log(arr) //['123', 3, 5, 5, 9, 'a', 'agv', 'c', 'g']

可以看出，字符和字符串也可以进行排序，那么sort排序的依据是什么 ？

答案是：ASCII码。两两之间会按位比较，直到比较出结果，如果到最后一个都相同的话，那么就说明两个值相同。

如何按照升序排序或者降序排序呢？

        传递一个函数类型的参数，也叫做回调函数，会被自动调用，无需写函数名。

var arr=[5,9,3,5,'a','g','c','123','agv']
arr.sort(function(a,b){
    return a-b //升序
)

console.log(arr)

arr.sort(function(a,b){
    return b-a //降序
)
console.log(arr)

这里的形参a保存的是后一个数，b保存的是前一个数:

        如果a>b，就会返回一个正数，说明后一个数>前一个数

        如果a<b，就会返回一个负数，说明后一个数<前一个数

        如果a==b，就会返回一个0，说明后一个数==前一个数

        而sort的底层就能通过你返回的值来判断要不要帮你交换位置

         特点：

                1）、会影响原数组；

                2）、没有返回值；

8、arr.join("指定字符")：将数组的每一项使用指定字符进行连接。

var arr=[1,2,3,4,5]
var res=arr.join("-")
console.log(arr) //[1, 2, 3, 4, 5]
console.log(res) //1-2-3-4-5

 当不传指定字符串的参数时，默认使用逗号连接。

var arr = [1, 2, 3, 4, 5];
var res = arr.join();
console.log(arr);
console.log(res);

        如何将数组进行无缝连接？

                直接传空字符串：arr.join("") 

        特点：

                1）、不会影响原数组；

                2）、返回值是连接好的结果；

                3）、返回的结果是String类型；

9、slice(starti,endi)：截取指定范围的字符串，包括开始下标，但不包括结束下标。

var arr=[1,2,3,4,5]
var res=arr.slice(0,3) //截取下标为0-2的数据
console.log(arr) //[1,2,3,4,5]
console.log(res) // [1,2,3]

        特点：

                1）、不会影响原数组；

                2）、返回值 是截取的结果；

                3）、如果两个参数都不传，相当于赋值；

10、arr.concat(数据...)：将数组与其他数据进行拼接，即将括号内的数据添加到数组arr的末尾部分。

var arr=[1,2,3,4,5]
var res=arr.concat(0,3) //截取下标为0-2的数据
console.log(arr) //[1,2,3,4,5]
console.log(res) // [1,2,3,4,5,0,3]

        特点：
                1）、不会影响原数组；

                2）、返回值是拼接好的数组；

                3）、括号内的值也可以是其他数据类型，包括数组；

11、arr.indexOf和arr.lastIndexOf：返回要查找的元素的下标

arr.indexOf(要查找的元素,从下标为几的元素开始找)，如果数组内有重复的元素，那么只能找到第一个出现的位置。第二个参数一般用不上。

lastIndexOf和indexOf差不多，区别就是lastIndexOf是从最后一个元素开始查找，返回的下标值是从第一个下标开始的。

var arr=[1,2,3,4,5]
var res=arr.indexOf(3)
console.log(res) //2
var res2 = arr.indexOf("txl"); //当在该数组内找不到自己像查找的数据时，返回-1
console.log(res2);
var res3=arr.indexOf(3,2) //表示要查找的元素为3，从该数组下标为2的元素开始查找
console.log(res3) //2

12、forEach()：遍历数组

 forEach中传入的是一个函数形式的参数，forEach会自动的调用这个函数。该函数被叫做回调函数，其中那个有三个形参：

        第一个是item：数组中的每一项；

        第二个是index：数组每一项的下标；

        第三个是arr：表示当前被循环的数组。

var arr=["aa","bb","cc","dd"]
arr.forEach(function(item,index,arr){
    console.log(item,index)
})

四、JS中使用数组方法实现栈和队列

什么是栈？

        一端封闭，只能从另一端进出。

什么是队列？

        只能从一端进入，另一端出去。

JS中的方法如何实现栈和队列？

开头添加：arr.unshift(新值...)，添加时可以添加多个值

开头删除：arr.shift()，删除只能删除一个，并且删除的时第一个元素，返回值是被删除的元素

结尾添加：arr.push(新值...) ，可以添加多个值，添加在最后

结尾删除：arr.pop() ，一次只能删除一个，删除的是最后一个，返回值是被删除的元素

这四个方法的互相结合使用，就可以实现栈和队列的操作。

五、索引数组与关联(hash)数组

什么是索引数组？

        索引数组就是一般的下标数组，也是最常见的数组形式。索引数组的最大缺点就是下标无意义，这也是会出现关联数组的重要原因。

什么是关联数组？

        关联数组又叫hash数组，下标可以自定义，并且有意义的数组，类似于对象的形式，只不过还是用[]包裹。

如何创建关联数组？ 

        1、先创建一个空数组

        2、添加自定义下标并且赋值:arr["自定义下标"]=新值

var arr=[]

arr["name"]="张三"
arr["age"]=18

console.log(arr) //[name: '张三', age: 18]

 关联数组的特点？

        1、length失效，不论里面的数据多长，length都为0；

        2、和对象的形式很想，都是以键值对的形式存在；

因为length为0，所以不能通过正常的for循环来遍历数组，怎么解决？

        可以使用for..in循环。

        语法：for(var item in arr){

                console.log(arr[item])

        }

        这里的item就代表的是key值，通过key值来获取对应的数据。

关联数组的底层原理？

        底层原理是hash算法，所以又叫hash数组。

        将字符串交给hash算法，会得到一个尽量不重复的数字，但是字符串的内容如果相同的话，那么得到的数字也一定相同。

        添加元素：将自定义下标交给hash算法，得到一个数字（即地址值），将要保存的数据放进去了

        读取元素：将指定的自定义下标交给hash算法，得到一个和添加时完全相同的数字（地址值），通过这个地址值可以拿到当初保存的东西

六、数组的排序算法

数组的常见排序算法有两个：冒泡排序和选择排序。

什么是冒泡排序?

        之所以叫做冒泡排序，因为每一个元素都可以像小气泡一样，根据自身大小一点一点向数组的一侧移动。每一轮循环只能确定一个数的位置。

冒泡排序规则？

• 遍历数组，挨个比较，如果前一个比后一个大，那么交换位置；

• 遍历一遍之后，数组最后一个数字就是最大的了；

• 随后重新遍历，依旧按照之前的规则，第二大的数字会跑到倒数第二的位置；

• 不断重复以上操作，直到第一个数字是最小的为止；

冒泡排序的实现：

var arr = [5, 4, 2, 3, 6, 8, 1, 9]; //准备一个乱序数组
// 数组长度-1的原因是，避免最后的索引越界
for (var i = 0; i < arr.length - 1; i++) {
	// 如果只是一层循环，只是把最大的数沉底，所以需要双重循环
	// 而第二重循环需要-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;
		}
	}
}
console.log(arr);

什么是选择排序？

        是一种简单直观的排序算法，简称为选排。它的工作原理是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

选择排序规则？

• 首先假定数组中的第0个就是最小数字（或者最大数字）的索引

• 遍历数组，只要比当前值小（大），就替换之前记录的索引

• 第一次遍历结束后，找到最小（大）的那个索引，让最小（大）的换到第0个的位置

• 开始第二遍，假定索引为1的数字是最小（大）的

• 重复之前的操作

• 最终按照从小（大）到大（小）的顺序进行排序

选择排序的实现：

var arr = [5, 1, 9, 12, 4, 3, 7, 8, 6, 1, 2, 5, 6];
for (var i = 0; i < arr.length - 1; i++) {
	// 记录最小索引
	var minIndex = i;
	for (var j = i + 1; j < arr.length; j++) {
		if (arr[j] < arr[minIndex]) {
			minIndex = j;
		}
	}
	// 如果记录的最小索引和当前第一个索引相等，则不需要交换
	if (minIndex != i) {
		// 交换
		var temp = arr[i];
		arr[i] = arr[minIndex];
		arr[minIndex] = temp;
	}
}
console.log(arr);
/*
	[
       1, 1, 2, 3, 4, 5,
       5, 6, 6, 7, 8, 9,
       12
    ]
*/