js 数组对象及方法的使用

js 数组对象及方法的使用

数组的概念

概念：数组就是一组（一般情况下相同类型）的数据(可以是任意数据类型)

数组是一种数据类型

作用：使用单独的变量名存储一系列的值

创建数组

• 声明

1. 通过new运算符创建数组
   let arr=new Array(20，true,“hello”);

2. 省略new运算符创建数组
   let arr=new Array(20，true,“hello”);

注意：上述两种方法要是传入的参数只有一个的话，并且还是数字的话，就代表是声明一个这个参数这么长的数组

3. 使用字面量创建
   let arr=[20，true,“hello”];

属性：length

1. 设置数组长度
   arr.length=10;
2. 获取数组长度
   arr.length
3. 数组名[数组名.length]=值
   如果值>原数组的长度，就从数组最后删掉多出来的部分
   如：let arr=[1,2,3];
   arr[arr.length]=2;
   那么arr=[1,2]

数组中的元素可以是任意的数据类型

数组的遍历

• for循环
• for … in … 快速遍历、快速枚举

数组方法

1.push(参数)

– 格式：数组名.（参数1,2…）
–该方法可以向数组的末尾添加一个或多个元素，并返回数组新的长度(返回值)

–将要添加的元素作为参数传递，元素会自动添加到数组末尾

2.pop()

–该方法可删除数组的最后一个元素，并返回删除的元素

3.unshift()

–向数组的开头添加一个或多个元素，并返回新的数组长度

–插入以后，数组的下标(索引)会依次调整

digits=[2,3,4];
digits.unshift(1);//原数组就会在第一个数组元素前加上元素1
//执行后的digits=[1，2,3,4];下标也随之调整

注意：
要是要添加的元素是一个数组，比如说数组
num=[3,4];
nums=[1,2];
num.unshift(nums);//这是不可行的，如果要实现num=[1,2,3,4];就用for循环一个个添加

4.shift()

–删除数组的第一个元素，并将删除的元素返回

5.slice(start，end)

–可以用来从数组提取指定元素，包含开始,不包括结束

–start:截取开始的位置下标

–end:截取结束的位置下标，这个参数要是不写，就从开始到最后一个元素，这个值可为负值，即从最后一个元素往前取

–该方法不会改变原数组，返回一个新的数组，包含从 start 到 end （不包括该元素）的 原数组中的元素。

let a=[1,2,3];
console.log(a.slice(0,0));//返回[],下标从0-0（不包含下标为0）的元素
console.log(a.slice(0,1));//返回[1],下标从0-1（不包含下标为1）的元素

6.splice(start，length，数据1，数据2…)

–可用于删除数组的指定元素

–会改变原数组，并将删除的元素作为返回值返回

–start:开始位置的下标

–length：截取元素的长度

–数据1,2…：在start位置，添加的元素

7.concat()

–可连接两个或多个数组，并将新的数组返回

1. 两个数组：数组1.concat（数组2）
2. 三个数组：数组1.concat（数组2，数组3）//数组1不能没有值

–不会改变原数组

–参数可以是数组和元素

8.join()

– 格式：数组名.join(字符串)

–将数组中的元素，用传入的拼接符，拼接成一个字符串

–不会改变原数组，将转换的字符串返回

9.reverse()

–用来反转数组（逆序）

–会改变原数组

10.sort()

–按字符串排序，根据Unicode编码，即纯数字的排序可能会错误，可自己指定规则
在sort()中添加一个回调函数，需要定义两个参数

function sortT(a, b){//sortT是函数名
        //return 值;(可写成if...else...)
    如：
 if(a>b){
        return 1;
    }else if(a<b){
        return -1;
    }else{
        return 0;
    }(升序)
    也可写成
    return a-b(升序)/b-a(降序);
    }
arr.sort(sortT)；

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

如果返回一个>0的值，元素交换位置

如果返回一个<0的值，元素位置不变

如果返回一个=0的值，认为ab元素相等，位置也不变

–会改变原数组

reduce()

• 接收一个函数作为累加器，数组中的每个值（从左到右开始缩减），最终计算成一个值
• 注: reduce() 对于空数组是不会执行回调函数的。

[1,2,-3].reduce((a, b) => a - b, 0)；
//a为累计器累计回调的返回值，b为数组的每一项元素
//0  ->  0-(1)  ->  (-1)-2  ->  (-3)-(-3)  ->  0

注意：

方法1和2两个方法形成栈结构

方法1,3,4形成队列结构

数组的引用

运行程序：

1. 准备运行程序要用的空间（一旦分配好以后，内存大小没法进行改变了）
2. 开始运行程序
   引用数据类型
   
   要想原数组不改变，可以用concat（）
   

声明提升

预编译：在所有代码运行之前，计算机将代码从头到尾看一遍，将这个程序需要运行的空间一次性分配好。

函数也会声明提升

声明提升：在当前作用域，声明的变量和函数，会直接提升在整个代码的最前面运行

省略var,直接去强制给一个变量赋值，这个变量会被js强制声明为全局变量（不建议，这属于语法错误）

二维数组

数组里边有数组

冒泡排序

规则：前后两个数两两进行比较，如果符合条件就交换两个数的位置

规律：冒泡排序每一轮排序，都可以找出一个较大的数，放在正确的位置

分析：
比较的轮数=数组长度-1
每一轮比较的次数=数组的长度-当前的轮数

//冒泡排序
function bubbleSort(arr){
    for (let i = 0; i < arr.length-1; i++) {
        for (let j = 0; j < arr.length-(i+1); j++) {
            if(arr[j]>arr[j+1]){
                //交换两个数的位置
                let tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
            
        }
        
    }
}

选择排序（打擂台法）

规则：选出一个位置，这个位置上的数，和后面所有的数进行比较，如果比较出大小就交换两个数的位置

规律：每一轮都能选出一个最小的数，放在正确的位置上

分析：
比较的轮数=数组长度-1
每一轮比较的次数=数组的长度-当前的轮数

//选择排序
function changeSortAsc(arr){//asc升序
    for (let i = 0; i < arr.length-1; i++) {
        //被比较的数的下标
        for (let j = i+1; j < arr.length; j++) {
            if(arr[i]>arr[j]){
                //交换两个数的位置
                let tmp=arr[i];
                arr[i]=arr[j];
                arr[j]=tmp;
            }
            
        }
        
    }
}
function changeSortDesc(arr){//desc降序
    for (let i = 0; i < arr.length-1; i++) {
        //被比较的数的下标
        for (let j = i+1; j < arr.length; j++) {
            if(arr[i]<arr[j]){
                //交换两个数的位置
                let tmp=arr[i];
                arr[i]=arr[j];
                arr[j]=tmp;
            }
            
        }
        
    }
}