JavaScript数据结构与算法（1）--数组结构

JavaScript String 对象 | 菜鸟教程 (runoob.com) 菜鸟教程的数组、字符串等等的js内置方法操作，其他更多内容，点击进入自研探索吧

1.1 数组的定义

//定义数组的第一种写法
let arr=new Array(1,2,3)
console.log(arr)

//定义数组的第二种写法
let arr2=[3,4,5]
console.log(arr2)

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

1.2 length

• 数组的length是可读写的，并且会影响到原数组

let arr = [1, 2, 3];
console.log(arr.length);  //3

arr.length = 2;
console.log(arr);  // [1, 2]

1.3 操作数组的方法

(1)push ,pop ,shift ,unshift ,splice ,slice ,字符串操作》split切分 ,reverse倒置数组 ,join ,toString ,sort排序 ,concat合并

push 从最后面插入一个元素

pop 从最后面铲除一个元素

shift 从前面删除一个元素

unshift 从前面插入一个元素

splice 从任意位置删除任意数量元素

如：arr.splice(0,2)从第零个位置开始删除两个元素

arr.splice(0,2,5)从第零个位置开始删除两个元素，同时在删除元素的位置，追加一个元素5（在删除元素的位置，插入5）

slice 传入索引值，将数组里对应索引范围内的元素作为新数组返回，不影响原数组

字符串操作》split切分 把字符串（按条件）分割为字符串数组

reverse倒置数组 颠倒数组中元素的顺序

join 把数组的所有元素“以指定字符”连接成一个字符串

toString 把整个数组转换成字符串（数组中的元素之间用逗号分隔）

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push('aa');
fruits.pop();
fruits.shift();
fruits.unshift('bb');


//从索引为2的位置开始，删除0个元素，并在删除元素的位置（索引为2的位置），追加插入"Lemon","Kiwi"数值到数组当中
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"aa","bb");
//fruits 输出结果：["Banana", "Orange","aa","bb", "Apple", "Mango"]

//slice 传入索引值，将数组里对应索引范围内的元素作为新数组返回，不影响原数组
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3); //citrus的结果输出：["Orange",  "Apple"]

//split切分 把字符串（按条件）（按空格进行）分割为字符串数组
var str="How are you doing today?";
var n=str.split(" "); 
//打印n为：['How','are','you','doing','today?']

//reverse倒置数组 颠倒数组中元素的顺序
var fruits = ["1", "2", "3", "4"];
fruits.reverse();
//打印fruits为：['4','3','2','1']

//join 把数组的所有元素“以指定字符”连接成一个字符串
var fruits = ["1", "2", "3", "4"];
var energy = fruits.join(" and ");
//打印energy为：'1 and 2 and 3 and 4'

//toString 把整个数组转换成字符串（数组中的元素之间用逗号分隔）
var fruits = ["aa", "bb", "cc", "dd"];
fruits.toString();
//此时打印fruits为：'aa,bb,cc,dd'

字符串操作》split切分 把字符串（按条件）分割为字符串数组

sort排序

let arr=[3,2,4,6,5]
//如果x-y大于0，则交换顺序（结果获得一个递增数组，正序，从小到大）
arr.sort((x,y)=>x-y)  //返回的是一个大于0或者小于0的数

//如果y-x大于0，则不交换顺序（结果获得一个递减数组，倒序，从大到小）
arr.sort((x,y)=>y-x)  //返回的是一个大于0或者小于0的数


【数组元素是对象】
let arr=[{
name:"aaa",
age:18
},{
name:"bbb",
age:50
},
{
name:"ccc",
age:100
},]
//按照年龄进行排序（从小到大）
arr.sort((x,y)=>x.age-y.age)

concat合并

let arr1=[1,2,3]
let arr2=[4,5,6]
console.log(arr1.concat(arr2,7,8,9))
//打印结果：[1,2,3,4,5,6,7,8,9]

(2)迭代方法every ,some ,filter ,map ,foreach ,reduce

every 只有每一项都要条件，结果才为真（全真才真，一假就假）

some 只要有一项满足条件，结果就为真（一真为真，全假才假）

filter 过滤出满足条件的元素（模糊查询用得最多）如果有多个元素满足条件最后返回一个所有满足条件元素的数组

map 映射，也是一个回调函数，遍历映射每一项元素

forEach 遍历

reduce 可以做一些累加累乘，深度属性一些点的访问（第一次相加的结果作为下次相加的item1,item2是接着下一个元素值）

let arr=[10,11,12,13]
//只有每一项都要大于10，才会结果返回true
let res=arr.every(item=>item>10) //false

//只要有其中一项大于10，就返回true
let res=arr.some(item=>item>10) //true
let res=arr.some(item=>item>13) //false

//过滤出满足条件的元素
let res=arr.filter(item=>item>12) //[13]

//映射，也是一个回调函数
//['10aaa','11aaa','12aaa','13aaa']
let res=arr.map(item=>item+"aaa")

console.log(res)

//遍历
arr.forEach(item=>{
console.log(item)
})
//遍历，想知道索引值在这里就传两个参数
arr.forEach(（item,index）=>{
console.log(item,index)
})


//第一次相加的结果作为下次相加的item1,item2是接着下一个元素值
let res=arr.reduce((item1，item2)=>item1+item2) //46

es6之后更新了一个迭代器对象

可以通过这个方法，拿到数组的所有键值对，所有的键，所有的值

把类似于数组的结构，转换成数组的结构

(3)Array.from 直接转换成数组

转换完之后，数组的操作方法map等等都可以使用了

(4)搜索 indexOf ,lastIndexOf ,includes ,find ,findLast ,findIndex ,findLastIndex

indexOf 查找数组中是否包含该元素，如果包含则返回（与）该元素（多个相等的第一个）准确的索引值，如果不包含则返回-1

lastIndexOf 查找数组中是否包含该元素，如果包含则返回（与）该元素（多个相等的最后一个）准确的索引值

includes 查找数组中是否包含该元素，如果包含则返回true，如果不包含则返回false

find 从前面开始查，查找数组，返回能满足条件的第一个元素

findLast 从后面开始查，查找数组，返回能满足条件的第最后一个元素

findIndex 从前面开始查，查找数组，返回能满足条件的第一个元素的索引值

findLastIndex 从后面开始查，查找数组，返回能满足条件的第最后一个元素的索引值

let arr=[10,11,12,13]
//查找数组中是否包含该元素，如果包含则返回该元素的索引值，如果不包含则返回-1
//查找数组中是否包含该元素，如果包含则返回（与）该元素（多个相等的第一个）准确的索引值，如果不包含则返回-1
console.log(arr.indexOf(15))  //-1
console.log(arr.indexOf(10))  //0

let arr=[10,11,12,13,10]
//查找数组中是否包含该元素，如果包含则返回（与）该元素（多个相等的最后一个）准确的索引值
console.log(arr.lastIndexOf(15))  //-1
console.log(arr.lastIndexOf(10))  //4


let arr=[10,11,12,13]

//查找数组中是否包含该元素，如果包含则返回true，如果不包含则返回false
console.log(arr.includes(15))  //false
console.log(arr.includes(10))  //true

//从前面开始查，查找数组，返回能满足条件的第一个元素
//从后面开始查，查找数组，返回能满足条件的第最后一个元素
let res=arr.find(item=>item>10) //11
let res=arr.findLast(item=>item>10) //13

//从前面开始查，查找数组，返回能满足条件的第一个元素的索引值
//从后面开始查，查找数组，返回能满足条件的第最后一个元素的索引值
let res=arr.findIndex(item=>item>10) //1
let res=arr.findLastIndex(item=>item>10) //3

二维数组，两层for循环遍历