javascript 中数组内容

在这里插入代码片数组：
功能:一个标识符，存储多个数据 人任何数据类型都可以存入数在这里插入代码片组
书写格式：
声明数组的方式：
1.字面量声明：
关键字 标识符 赋值符号 中括号 分号
let f70 = [] ;

let f70 = [];
console.log(f70); //[]
console.log(typeof f70); //object(数据类型为symbol)

赋值：
注：每个值字间的分隔符是,

f70 = [1, "bvd", undefined, true, null];
console.log(f70); //
console.log(typeof f70); //object(数据类型为symbol)

使用数组中的值：
书写格式：数组名称[下标/索引]
数组中的每一个值(健值)，都会有一个对应的下标（索引）（健名）
因二者都是成对出现，所以也可称为键值对
可以通过下标来获取数组中的值
下标的起始值是0
因此数组中第一个值的下标为0，第二个为1，以此类推。

let f71 = [1, "d", 789];
console.log(f71[1]); //d
// 结果为un的原因，获取的数组不存在值的下标
console.log(f71[100]); //undefined

1.构造函数声明

书写格式：
let f77 = new Array (13, 58);

使用方法：
console.log(f77[0]); //13
构造函数声明与字面量声明的区别：解析上字面量比构造函数效率高。
原因：
字面量属于JSON格式，可以直接被JS进行解析
构造函数需要先调用构造函数，在进行JS引擎解析
使用场景
解构：不是数组，但书写格式为中括号 中括号前没有标识符
功能：把引用数据类型，分解成及基本数据类型；
注：解构的左右数据类型，必须要一致。

1. 2个变量的值互换

let i = 1;
let j = 2;
[i, j] = [j, i] //把右侧的值赋值给左侧
console.log(i, j);

1. 批量赋值

let [a, b, c] = [1, 2, 3]
console.log(a,b,c);
数组的遍历

let f88 = [2, 5, , 2, , 5, 5, 25, 5, 5, 2, 5, ]
for (let i = 0; i < f88.length; i++) { //只拿存在的值   i < f88.length或者为i <= f88.length-1
    console.log(f88[i]);
}

// console.log(“数组的长度”, f88.length);
// .length 数组的长度 (数组的属性)

1. 

for …of 遍历数组中的每个值 item为自定义

let f65 = ["A", "B", "C", "D", "E", "F"]
for (let item of f65) {
    console.log(item);
}

1. 

for …of 遍历数组中的每个值的下标

let f65 = ["A", "B", "C", "D", "E", "F"]
for (let item in f65) {
    console.log(item);
}

数组的方法: 小括号

增加：

.unshfit在数组前添加数据（可1到多个值）,返回添加后的数组长度。

F70.unshift(1,2);
console.log(F70); //[1,2,"A","B","C"]
let j = F70.unshift();
console.log(j);

.push在数组后添加数据（可以1到多个值）,返回添加后的数组长度。

let F70 = ["A"];
let k = F70.push("B", "C");
console.log(F70); //["A","B","C"]
console.log(k); //3

删除：

.shift在数组前删除数据（只能删一个）,并返回删除的数据（格式：let i =）

F70 = [1, 2, "A", "B", "C"]
let j = F70.shift("2");
console.log(F70); //[2,"A","B"]

.pop在数组后删除数据（只能删除1个）,并返回删除的数据。

F70 = [1, 2, "A", "B", "C"]
let i = F70.pop("1");
console.log(F70); //[1,2,"A","B"]

可打印获取到的删除内容
console.log(i, j); //C , 1
3.判断数组中是否存在查找的值。
A.书写格式：
数组.includes(查找内容)
功能：查找内容存在，返回true，反之返回false

let F70 = ["A", "B", "C"];
let inputName = "B";
let state = F70.includes(inputName);
console.log(state); // true

B.书写格式：
数组.indexOf(查找内容)
功能：查找内容存在，返回值所在的下标 反之不存在，返回-1
注：从前往后查找，返回第1个匹配值的下标。就不再继续查找。

state = F70.indexOf(inputName);
console.log(state); //1
inputName = "D";
state = F70.indexOf(inputName);
console.log(state); //-1

f70 = ["a", "b", "c","a"];
inputname = "a";
state1 = f70.indexOf(inputname);

C.书写格式：
数组.lastIndexOf(查找内容)
功能：查找内容存在，返回值所在的下标 反之，返回-1
注：从后往前查找，返回第1个匹配值的下标。就不再继续查找。
state2 = F70.lastIndexOf(inputName);
console.log(state1, state2); //0,3

数组.slice(参数1，参数2) 批量获取数组内容 slice不会改变原数组
参数1是起始下标，参数2是结束下标
获取范围是从参数1开始，到参数2结束（但不包含参数2也就是结束参数的内容）的所有内容
注：返回获取的内容，赋值给接受的变量，不会改变原数组内容。

f70 = ["a", "b", "c", "d","e","f"];
let f71 = f70.slice(1, 2);
console.log(f70);
console.log(f71);

若参数为负数，则用数组长度与其相加。
若没有满足范围的值，返回空数组。

f71 = f70.slice(1,-7);
console.log(f71,typeof f71);
若参数只有一个，则获取从这个参数到数组的最后一个值。

f71 = f70.slice(2);
console.log(f71);
4.修改，插入
数组.splice(参数1，参数2,参数3) 会改变原数组
当只有1个参数：
从这个参数的下标截取到最后一个值，存储为一个新的数组并且返回

f70 = ["a", "b", "c", "d", "e", "f"];
f71 = f70.splice(2);
console.log(f70);
console.log(f71);

当为2个参数：
第一个参数为起始下标，第二个参数为截取个数

f70 = ["a", "b", "c", "d", "e", "f"];
f71 = f70.splice(0,5);
console.log(f70);
console.log(f71);
f70.length=0;

当为3个参数：
第1个参数为起始下标
第2个参数为截取个数 （为0则是插入，非0则是修改）
第3个参数及以后，都是插入或修改的值

f70 = ["a", "b", "c", "d", "e", "f"];
f71 = f70.splice(2,2,8);
console.log(f70);//[ 'a', 'b', 8, 'e', 'f' ]
console.log(f71);//[ 'c', 'd' ]

f70 = ["a", "b", "c", "d", "e", "f"];
f71 = f70.splice(2,0,8,1,5);
console.log(f70);//[ 'a', 'b', 8, 1, 5, 'c', 'd', 'e', 'f' ]
console.log(f71);//[]

f70 = ["a", "b", "c", "d", "e", "f"];
f71 = f70.splice(2, 1, 9, 0);
console.log(f70);//[ 'a', 'b', 9, 0, 'd', 'e', 'f' ]
console.log(f71);//[ 'c' ]

5.排序
数组.sort

let abb = [14, 21, 3, 52, 84, 62, 10, 9, 4];
// .sort( ) 数组的方法（也是函数） 排序
// 升序
let arr = abb.sort((a, b) => a - b);
console.log(arr);
/ / 降序
let arr1 = abb.sort((a, b) => b - a);
console.log(arr1);
6.满足需求
1.数组.every 判断数组中的每个值，是不是都满足需求

let cdd = [14, 62, 10, 9, 4];
let state = cdd.every(a => a % 2 == 0); //返回的为布尔值
console.log(state); //false

2.数组.some 判断数组中的每个值，是不是都满足需求
注：只要有一个满足，就返回true 都不满足才会返回false

let state1 = cdd.some(a => a + 2 > 5); //返回的为布尔值
console.log(state1); //true
7.过滤
数组.filter 返回满足符合条件的值

let cdd = [14, 62, 10, 9, 4];
let state2 = cdd.filter(a => a % 2 == 0); //返回的为符合该条件的值
console.log(state2); //[ 14, 62, 10, 4 ]

扩展：

let arr2 = [1, 2, 3];
let arr3 = [2, 3, 4];
// 交集：

let intersect = arr2.filter(a => arr3.includes(a));
console.log(intersect);

// 并集：

let union = new Set([...arr2, ...arr3])
console.log(...union);

// 差集；

let different = arr3.filter(a => !arr2.includes(a));
console.log(different);

8.遍历，执行需求
1.数组.map（遍历出数组中的每个值） 无法使用break
执行箭头函数的需求，把最终的结果，以新数组的方式返回。
注：不会改变原数组

let state3 = cdd.map(a => a % 2 == 0);
console.log(state3); //[ true, true, true, false, true ]

state3 = cdd.map(a => a - 1);
console.log(state3); //[ 13, 61, 9, 8, 3 ]

2.数组.forEach（遍历出数组中的每个值） 无法使用break
执行箭头函数的需求，无返回值。
注：不会改变原数组

l

et state4 = cdd.forEach(a => a - 1);
console.log(state4); //undefined


let cdd = [14, 62, 10, 9, 4];
let state5 = cdd.map(a => a % 2 == 0);
console.log(state5);
``