JS基础[三]

一.数组

1. 多条数据存放在一个变量中。
2. 按顺序保存数据的数据类型。
3. 数组的声明：
   1. 字面量声明：let array = ['张三','李四','王五'];
   2. 构造函数声明：let array = new Array('张三','李四','王五');
4. 下标：数组是按顺序保存的，所以数组里的每个元素都有自己的下标，下标从0开始，张三的下标为0，王五的下标为2。
5. length长度：数组的长度length是从1开始，所以array数组的长度为3。
6. 存放类型：数组可以存储任意类型的数据。
7. 获取指定下标的数据：array[1]拿到的数组元素是'李四'。
8. 遍历数组：使用循环来获取数组中的每一个元素。

// 数组元素求和、平均值
let array = [1,2,3,4,5];
let sum = 0;
for(let i=0; i<array.length; i++) {
    sum += array[i];
}
console.log(`和为：${sum}\n平均值：${sum/array.length}`); // 输出：和为：15 平均值为：3

// 数组元素求最大值、最小值
array = [5,6,3,4,7];
let max = array[0];
let min = array[0];
for(let i=1; i<array.length; i++) {
    if(array[i]<min) {
		min = array[i];
	}
    if(array[i]>max) {
		max = array[i];
	}
}
console.log(`最大值：${max}\n最小值：${min}`); // 输出：最大值：7 最小值：3

二.操作数组

1. 数组增加元素：
   1. arr.push(元素1,元素2, ...... 元素n);将一个或多个数组元素添加到数组末尾，并返回该数组的新长度。
   2. arr.unshift(元素1,元素2, ...... 元素n);将一个或多个数组元素添加到数组开头，并返回该数组的新长度。
2. 数组删除元素：
   1. arr.pop();从数组中删除最后一个元素，并返回该元素的值。
   2. arr.shift();从数组中删除第一个元素，并返回该元素的值。
   3. arr.splice(起始下标位置, 删除几个元素);删除指定元素。其中第二个参数“删除几个元素”为非必传，不传值时，默认从起始下标删除至最后。
3. 数组修改元素：
   1. arr[i] = 新值;
4. 查询数组元素：
   1. arr[i];

// 数组增加元素
let  array1 = ['狗', '猫'];
array1.push('哈哈', '数组');
console.log(array1); // 输出：狗 猫 哈哈 数组
console.log(array1.push('red')); // 输出：5
console.log(array1); // 输出：狗 猫 哈哈 数组 red
array1.unshift('蓝天', '白云');
console.log(array1); // 输出：蓝天 白云 狗 猫 哈哈 数组 red
console.log(array1.unshift('加在开头的元素')); // 输出：8
console.log(array1); // 输出：加在开头的元素 蓝天 白云 狗 猫 哈哈 数组 red

// 数组删除元素
let array2 = ['red', 'blue', 'yellow'];
console.log(array2.pop()); // 输出：yellow
console.log(array2); // 输出：red blue
array2.pop();
console.log(array2); // 输出：red

array2 = ['red', 'blue', 'yellow'];
console.log(array2.shift()); // 输出：red
console.log(array2); // 输出：blue yellow
array2.shift();
console.log(array2); // 输出：yellow

array2 = ['red', 'blue', 'yellow'];
array2.splice(1, 1);
console.log(array2); // 输出：red yellow

array2 = ['red', 'blue', 'yellow'];
array2.splice(1);
console.log(array2); // 输出：red

array2 = ['red', 'blue', 'yellow'];
let a = 'red';
let index = 0;
for(let i=0; i<array2.length; i++){
    if(a===array2[i]){
        index = i;
    }
}
array2.splice(index, 2);
console.log(array2); // 输出：yellow


// 修改数组元素
let array3 = [];
array3[0] = '哈哈';
array3[1] = '数组';
console.log(array3); // 输出：哈哈 数组
array3[0] += '狗子';
console.log(array3); // 输出：哈哈狗子 数组

// 查询数组元素
let data = array3[1];
console.log(data); // 输出：数组

三.冒泡排序

1. 冒泡排序是一种简单的排序算法。
2. 重复访问要排序的数据，一次比较两个元素，然后按顺序交换元素位置，例如：从大到小，从小到大。一直重复到排列顺序正确，无需交换位置时停止。
3. 名字由来：因为越小的元素会经过交换位置慢慢“浮”到数列的顶端。
4. 举例：[1,4,3,5,2]排序后：[1,2,3,4,5]或[5,4,3,2,1]。

// 冒泡排序
let arr = [6,5,4,3,2,1]
for(let i=0;i<arr.length-1;i++) {
    for(let j=i+1;j<arr.length;j++){
        if(arr[i]>arr[j]){
            let a = arr[i];
            arr[i] = arr[j];
            arr[j] = a;
        }
    }
}
console.log(arr); // 输出：1,2,3,4,5,6

1. 比较规律（其中的数字为数组下标）：
   1. 0I：1J
   2. 0I：2J   1I：2J
   3. 0I：3J   1I：3J   2I：3J
   4. 0I：4J   1I：4J   2I：4J   3I：4J
   5. 0I：5J   1I：5J   2I：5J   3I：5J   4I：5J
2. 其中I为i循环，J为j循环，I循环一次，J将整个数组循环一遍。
3. 为什么I循环的最大值是length-1？J循环的最小值是i+1？因为两两比较，不存在0：0、5：5，或者1：0、3：2的情况，前者是因为自己与自己比较是无意义的，后者是因为在0：1和2：3时已经比较过了，无需重复比较，所以i循环无需循环到5，只需要循环到0-4就可以，即是length-1，j循环无需循环0和已经比较过的值,，即是i+1。

四.sort()排序

1. arr.shot()方法对数组的元素进行排序。
2. 默认排序顺序为按字母升序。
3. 数字排序就需要传一个函数作为参数来调用。

// sort字母排序
let arr = ['car','apple','pen','green','pink'];
arr.sort();
console.log(arr); // 输出： ["apple", "car", "green", "pen", "pink"]

// sort数字排序
// 升序
let num = [7,4,6,88,10,23,1];
num.sort(function(a,b){return a-b});
console.log(num); // 输出：[1, 4, 6, 7, 10, 23, 88]

// 降序
num = [7,4,6,88,10,23,1];
num.sort(function(a,b){return a-b});
console.log(num); // 输出：[88, 23, 10, 7, 6, 4, 1]

仅作为个人学习用，如有错误，还请指正。