回顾JavaScript基础——数组

1：创建数组

var arr1 = [1,2,3];
console.log(arr1);//输出结果：[1,2,3]

var arr2 = new Array(4,5,6);
console.log(arr2);//输出结果：[4,5,6]

var arr3 = Array(7,8,9);
console.log(arr3);//输出结果：[7,8,9]

var arr4 = Array.of(10,11,12);
console.log(arr4);//输出结果：[10,11,12]

//创建数组只有一个元素是，只能用字面值或者Aeeay.of
//Array()或new Array()只有一个参数时，参数的值就代表要创造数组的长度，内容就是全部为空
var arrSingle = Array(6);
console.log(arrSingle);//输出结果：6个空的值
var arrSingle2 =new Array(3);
console.log(arrSingle2);//输出结果：3个空的值

var arrSingle3 = Array.of(10);
console.log(arrSingle3);//输出结果：[10]
var arrSingle4 = [9];
console.log(arrSingle4);//输出结果：[9]

2：访问数组（通过下标或者索引实现）

var arr = [1,2,3];
console.log(arr.length);//输出结果：3
console.log(arr[0]);//输出结果：1
console.log(arr[1]);//输出结果：2
console.log(arr[2]);//输出结果：3
//访问一个不存在元素，也就是超过数组的长度，那么就会返回一个undefined
console.log(arr[5]);//输出结果：undefined

3：数组添加元素

var arr = [1,2,3];
arr[0] = 4;
console.log(arr);//输出结果：[4,2,3]
arr[3] = 5;
console.log(arr);//输出结果：[4,2,3,5];

//如果给数组一个超出长度太多的值，那么数组中间未定义的值就全部为空
arr[7] = 8;
console.log(arr);//输出结果：[4,2,3,5,empty*3,8];
console.log(arr[6]);//输出结果：undefined

//给数组任意位置添加新的元素，arr.splice(索引的位置,0,添加的元素),0指的是删除0个元素
var arr2 = [1,2,3,4]
arr2.splice(2,0,7,8,9);
console.log(arr2);//输出结果：[1,2,3,7,8,9,4]

4：数组删除元素

var arr = [1,2,3];
//删除末尾值，可以将数组长度变减少1
arr.length = 2;
console.log(arr);//输出结果：[1,2]
arr.length = 0;
console.log(arr);//输出结果：[]

var arr2 = [1,2,3,4,5,6]
//删除任意位置的元素，使用arr.splice(删除的索引位置，删除的数量)
arr.splice(2,1);
console.log(arr2);//输出结果：[1,2,4,5,6]

arr.splice(1,2,3,7,8);//后面的3,7,8为在数组被删除元素后面添加的元素
console.log(arr2);//输出结果：[1,3,7,8,5,6]

5：数组遍历

var arr = [1,3,5,7,9];
for(let i;i<arr.length;i++){
    console.log(arr[i]);//输出结果：依次输出1、3、5、7、9
}

for(let ele of arr){
    console.log(ele);//输出结果：依次输出1、3、5、7、9
}
//arr.forEach((访问到的元素,索引,数组本身){})
arr.forEach((ele,index,self)=>{
   console.log(ele,index,self); 
});

6：栈模式（栈是一种后进先出的数据结构）push(),pop()

var stack = [1,2,3];
//入栈
stack.push(4);
console.log(stack);//输出结果[1,2,3,4]

stack.push(5,6,7);
console.log(stack);//输出结果[1,2,3,4,5,6,7]

//出栈,移除最后一个元素，并返回它的值
var last = stack.pop();
console.log(last);//输出结果：7
console.log(stack);//输出结果[1,2,3,4,5,6]

console.log(stack[stack.length-1]);//输出结果：6

7：队列模式（队列是一种后进先出的数据结构）push()、shift(),unshift()插队

var queue = [1,2,3];
//入队
queue.push(4,5,6);
console.log(queue);//输出结果：[1,2,3,4,5,6]

//出队，移除数组第一个元素，并返回它的值
var first = queue.shift();
console.log(first);//输出结果；1
console.log(queue);//输出结果：[2,3,4,5,6]

//插队，从数组头部添加元素
queue.unshift(10,11,12);
console.log(queue);//输出结果：[10,11,12,2,3,4,5,6]

8：反转数组（reverse()方法）

//arr.reverse(),原数组也会被改变
var arr = [1,2,3];
console.log(arr.reverse());//输出结果：[3,2,1]
console.log(arr);//输出结果：[3,2,1]

//反转字符串
var a = "hello".split("");//将字符串用空格转换为数组
console.log(a);//输出结果：h e l l o
var b = a.reverse();
console.log(b);//输出结果：o l l e h
var c = b.join("");//去除空格将数组还原成字符串
console.log(c);//输出结果：olleh

9：数组排序（sort()方法）

var arr = [5,3,2,7,6];
arr.sort();//原地对数组进行排序
console.log(arr);//输出结果：[2,3,5,6,7]

//降序排列
arr.sort(a,b)=>{
	if(a > b){
        return 1;
    }else if(a < b){
        return 1;
    }else{
        return 0;
    }
}
console.log(arr);//输出结果：[7,6,5,3,2]

10：数组连接concat()

var arr1 = [1,2,3];
var arr2 = [4,5,6];
console.log(arr1.concat(arr2));//输出结果：[1,2,3,4,5,6]

11：数组裁切slice()

var arr = [1,2,3,4];
console.log(arr.slice(1));//输出结果：[2,3,4]
//结束位置的索引上的值不会包含在里面
console.log(arr.slice(1,3));//输出结果：[2,3]
//结束位置为负数，则代表倒数位置的数，-1代表最后一个元素，-2代表倒数第二个元素
console.log(arr.slice(1,-1));//输出结果：[2,3]

12：数组map（map会对每个元素进行操作后，返回一个新的数组，接收三个参数（当前元素，当前索引，数组本身）

var arr = [1,2,3];
var mappedArr = arr.map(ele => ele*2);
console.log(mappedArr);//输出结果：[2,4,6]
//原来的数组不发生变化
console.log(arr);//输出结果：[1,2,3];

13：数组reduce，接收四个参数（上一次计算的结果，当前遍历到的数组元素，当前遍历到的索引，数组本身）

var arr = [1,2,3,4];
/*
给previous一个初始值0，然后0+current,current也就是当前遍历到的数组元素1，也就是0+1，
然后将得到的新的结果赋值给previous，
此时previous=1，current就是下一个遍历到的数组元素2，依次执行，
*/
var result = arr.reduce((previous,current) => previoue + current,0);
console.log(result);//输出结果：10
/*
不给first一个默认初始值，那么此时first就等于数组第一个元素，second就等于数组第二个元素，first+second=>1+2=3,
得到的结果就变成下一次的first，而此时second就变成了下一个数组遍历到的元素3，依次执行
*/
var result2 = arr.reduce((first,second) => first+second);
console.log(result2);//输出结果：10

14：数组过滤filter（接收的参数（当前遍历的元素，当前索引，数组本身））

var arr = [1,2,3,4,5,6];
var filteredArr = arr.filter(item => item>4);
console.log(filteredArr);//输出结果：[5,6]

15：数组测试

存在两种

​ 1）检测所有元素是否满足一定条件，满足的话，返回true，不满足返回false

​ 2）如果有一个元素满足条件，返回true，否则的花返回false

//检测所有元素
var arr = [1,2,3,4];
var result = arr.every(item => item>0);
console.log(result);//输出结果：true

var result2 = arr.every(item => item>2);
console.log(result2);//输出结果：false

//检测部分元素
var resultsome = arr.some(item => item>3);
console.log(resultsome);//输出结果：true

var resultsome2 = arr.some(item => item>4);
console.log(resultsome2);//输出结果：false

16：destructuring解构操作符（把数组的元素赋值给变量）

var arr = [1,2,3];
var [a,b,c] = arr;
console.log(a,b,c);//输出结果：1,2,3

//只取部分元素，后面可剩
var [d,e] = arr;
console.log(d,e);//输出结果：1,2

//只取中间的元素，前面的元素可以不写，但是需要有逗号隔开
var [,f] = arr;
console.log(f);//输出结果：2

//当函数返回多个值时，可以返回一个数组，然后在需要调用的第解构出来
function np(){
    let name = "z";
    let age = 19;
    
    return np[name,age];
}
var [myName,myAge] = np();
console.log(myName,myAge);//输出结果：z 19

17：rest操作符 …数组名（可不写）（解构完数组的几个元素后，将剩余的元素当成子数组返回回来）

var arr = [1,2,3,4,5,6];
var [a,b, ...rest] = arr;
console.log(a,b,rest);//输出结果：1 2 [3,4,5,6]

//跳过中间某个元素
var [a, ,b, ...rest] = arr;
console.log(a,b,rest);//输出结果：1 3 [4,5,6]

//用在函数当中参数，用来接收不固定个数的参数
function variousAge(...rest){
    console.log(rest);//输出结果：[1,2,3]
}
variousAge(1,2,3);

18：多维数组（在数组里嵌套多个数组）

var arr = []
for(let i=0;i<5;i++){
    arr[i] = [];
    for(let j=0,j<4;j++){
        arr[i][j]=i + j;
    }
}
console.log(arr);//输出结果 [[0,1,2,3],[1,2,3,4],[2,3,4,5],[3,4,5,6],[4,5,6,7]]