数组(Array)

数据结构

划分

• 存储结构 （存储对应的数据的）

• 逻辑结构（逻辑的体现）

• 算法

存储结构的相关的内容

线性结构（有顺序）

数组 （顺序表）

栈 （先进后出）

队列 （先进先出）

非线性结构 （没有顺序）

串

链表 （单向链表 双向链表）

图 （有向图 无向图）

树 （二叉树）

hash

所有的存储结构 必须具备增删改查的方法

数组(Array)

概述：

数组是一种数据结构，它里面的存储的数据是有顺序的（又称为顺序表）。

数组它里面存储的数据一般情况下是单一类型的数据。但是我们也可以存储多种类型。

数组是一个存储数据比较简易的一个容器，所以它可以实现其他的相关数据结构。

 

 

数组索引从零开始：数组中的第一个元素是 0，第二个元素是 1，依此类推。

Array 属性

属性	描述
constructor	返回创建 Array 对象原型的函数。
length	设置或返回数组中元素的数量。
prototype	允许您向数组添加属性和方法。

数组的声明（引用数据类型）

使用[] 来声明

//第一种声明
var array = [1, 2, 3] //数据里面存储的数据采用,分割
console.log(typeof array) //object 数组是引用数据类型
console.log(array) 

 

使用new Array关键词声明

//第二种声明方式 采用new关键词， 凡是采用new 关键词构建的都是 引用数据类型
var array = new Array() //没有指定长度的数组
//当你传递一个参数的时候 就是构建对应的长度的数组
var array1 = new Array(10) //new 后面的方法的首字母要大写  指定长度为10的数组
console.log(array1);
//当你传递多个参数的时候 就是将对应的参数放入对应的数组内
var array2 = new Array(1,2,3,4)
console.log(array2);

 

数组的特性

• 下标 从0开始到length-1 可以通过[下标] 来访问对应的数组里面的值

• length 长度（数组里面的值的个数）

数组的遍历

传统for循环进行遍历

var array = new Array()
for(var i=0;i<array.length;i++){
    console.log(array[i])
}

 

for in 遍历 （一般用于遍历对象）

//for in来遍历 key 也就是对应数组的下标 (一般用于遍历对象 不仅是遍历数组 它还可以遍历其他的对象)
for(var index in array){ //index这个key在array里面
    console.log(array[index]);
}

 

for of 遍历 （专门遍历数组）

//for of来遍历数组 遍历的是值
for(var value of array){ //value这个值存在于array中
    console.log(value);
}

 

数组的操作（方法）

添加方法（add push save set...）

push 添加到末尾

//添加方法 会改变原本的数组
//添加方法 会返回添加后的长度
// push方法 添加元素到末尾
var arr = [1,2]
var v = arr.push(3,4) //在末尾追加3 4
console.log(v);
console.log(arr.length); //4
console.log(arr); //[1,2,3,4]

 

unshift 添加到开头

// unshift 添加到开头
var m = arr.unshift(5,6,7)
console.log(m);
console.log(arr.length); //7
console.log(arr); //[5,6,7,1,2,3,4]

 

注 ： 数组的添加方法返回对应的新的长度

删除方法 （delete（完全删除 硬删） remove（移出 软删）pop 移出...）

pop 删除最后一个

//删除方法 删除末尾的第一个 返回的是删除的元素
console.log(arr.pop()); //4
console.log(arr); //[5,6,7,1,2,3]

 

shift 删除第一个

//shift 删除 删除开头的第一个
console.log(arr.shift());//返回5
console.log(arr); //[6,7,1,2,3]

​

删除方法 添加修改和删除 splice（会影响之前的数组）

var arr1 = [1,2,3,4]
//开始下标 删除个数
//删除操作
var spliceArr = arr1.splice(0,1) //删除完成功内容 一个数组
console.log(spliceArr);//[1]
console.log(arr1);//[2,3,4]
//添加操作
console.log(arr1.splice(0,0,5));//[]
console.log(arr1);//[5,2,3,4]
//修改操作
console.log(arr1.splice(0,1,1)); //删除原本5 将1放到5的位置 5
console.log(arr1);//[1,2,3,4]

 

返回对应的删除的元素

修改方法 （update replace）

//他的修改就是重新賦值 数组没有修改方法
arr[2] = 0 //修改當前第三個元素 下标为2的元素
​

查询相关的方法（select query find search..）

indexOf 根据对应的值查询下标（有就返回对应的下标 没有返回-1）

var arr1 = [1,2,3,1]
//默认查询 从开头查到结尾 返回的是第一个查找到的下标
console.log(arr1.indexOf(1));//0
//根据对应的值返回下标 找不到返回-1
console.log(arr1.indexOf(4));//-1
//indexOf可以规定开头查找的位置
console.log(arr1.indexOf(1,1));//返回3

​

lastIndexOf 从后往前查找 找到第一个 没有找到返回-1

//从后往前找 找到第一个 默认是从最后开始
console.log(arr1.lastIndexOf(1));//3
//根据对应的值返回下标 找不到返回-1
console.log(arr1.lastIndexOf(4));//-1
//lastIndexOf可以规定开头查找的位置 从下标1开始
console.log(arr1.lastIndexOf(1,1));//返回0
console.log(arr1.lastIndexOf(3,1));//返回-1

sort排序的方法

默认按照ascii码排序

// sort排序的方法
var arr = [20,18,25,15,1,2]
//传入一个比较的方法 返回排序好的数组
var arr1 = arr.sort() //会改变原本的数组
console.log(arr);//[1,15,18,2,20,25]
console.log(arr1);
//引用数据类型的比较 == === 返回的值是一样
console.log(arr == arr1);//true 对应的排序返回的数组其实就原本排序完成的数组

​

如果需要按照对应的值的大小进行排序 自定义比较方法 return a-b 就是正序 return b-a就是倒序

var arr = [20,18,25,15,1,2]
// sort方法默认按照ascii码排序
// 自定义对应比较方法传入 进行排序
arr.sort(function(a,b){
    //返回的是a-b 对应的是正序 如果返回的是b-a 那么对应的是倒序
    // return a-b
    return b-a
})
console.log(arr);//[1,2,15,18,20,25]

​

引用数据类型的比较比较的是地址值 值比较的就是对应的值（[] ! = []）

 

 

 

 

reverse反转的方法

var arr1 = [1,2,3,4,5]
arr1.reverse()
console.log(arr1);//[5,4,3,2,1]

不会改变原数组的方法

join 数组转为字符串（不会影响原本的数组）

var arr1 = [5,4,3,2,1]
//join 将数组转为字符串 返回一个字符串 不会更改原本的数组
//join里面的参数为对应的分隔符 默认为,
var str = arr1.join(':')
console.log(str);//5:4:3:2:1
console.log(arr1);//[5,4,3,2,1]

​

连接 （合并多个数组 concat 返回一个新数组 不会改原本的数组）

concat

// 连接方法 concat
var arr1 = [1,2,3]
var arr2 = [4,5,6]
//concat返回一个新的数组
var newArr = arr1.concat(arr2)
console.log(newArr);//[1,2,3,4,5,6]
console.log(arr1);//[1,2,3]

截取 （slice sub..）

截取 slice （不会影响原本的数组）

var arr1 = [1,2,3,4]
//截取多个 返回对应的截取的内容 开始下标  结束下标（不包含结束下标）
var sliceArr = arr1.slice(0,2)
console.log(sliceArr);//[1,2]
console.log(arr1);//[1,2,3,4]

总结：

push() 　　　　从后面添加元素，返回值为添加完后的数组的长度
pop() 　　　　 从后面删除元素，只能是一个，返回值是删除的元素
shift() 　　　从前面删除元素，只能删除一个 返回值是删除的元素
------删除前面第一个，从头开始
unshift() 　　从前面添加元素, 返回值是添加完后的数组的长度
------------添加到开头 
splice(i,n) 　删除从i(索引值)开始之后的那个元素。返回值是删除的元素
------------i开始下标  n删除个数        会影响之后的数组
concat() 　　 连接两个数组 返回值为连接后的新数组
----------合并多个数组 concat 返回一个新数组 不会改原本的数组
sort() 　　　　将数组进行排序,默认根据ASCII码比较,返回值是排好的数组
reverse() 　　将数组反转,返回值是反转后的数组
slice(start,end) 切去索引值start到索引值end的数组，不包含end索引的值，返回值是切出来的数组
----------截取多个 返回对应的截取的内容 开始下标  结束下标（不包含结束下标）
indexOf() 　　查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1
----------默认查询， 从开头查到结尾， 返回的是第一个查找到的下标，否则返回-1

 

push() 从后面添加元素，返回值为添加完后的数组的长度
pop() 从后面删除元素，只能是一个，返回值是删除的元素
shift() 从前面删除元素，只能删除一个 返回值是删除的元素
------删除前面第一个，从头开始
unshift() 从前面添加元素, 返回值是添加完后的数组的长度
------------添加到开头 
splice(i,n) 删除从i(索引值)开始之后的那个元素。返回值是删除的元素
------------i开始下标  n删除个数        会影响之后的数组
concat() 连接两个数组 返回值为连接后的新数组
----------合并多个数组 concat 返回一个新数组 不会改原本的数组
sort() 将数组进行排序,默认根据ASCII码比较,返回值是排好的数组
reverse() 将数组反转,返回值是反转后的数组
slice(start,end) 切去索引值start到索引值end的数组，不包含end索引的值，返回值是切出来的数组
----------截取多个 返回对应的截取的内容 开始下标  结束下标（不包含结束下标）
indexOf() 查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1
----------默认查询， 从开头查到结尾， 返回的是第一个查找到的下标，否则返回-1

高阶函数(1)

forEach(callback) 遍历数组,无return  即使有return，也不会返回任何值，并且会影响原来的数组
map(callback) 映射数组(遍历数组),有return 返回一个新数组 。

注:forEach()和map()的区别

1. arr.forEach()是和for循环一样，是代替for。arr.map()是修改数组其中的数据，并返回新的数据。

2. arr.forEach() 没有return arr.map() 有return

 

高阶函数(2)

filter(callback) 过滤数组，返回一个满足要求的数组 
every(callback) 依据判断条件，数组的元素是否全满足，若满足则返回ture
some() 依据判断条件，数组的元素是否有一个满足，若有一个满足则返回ture
reduce(callback, initialValue) 迭代数组的所有项，累加器，数组中的每个值（从左到右）合并，最终计算为一个值

?

1 2 3 4 5 6 7 8 9 10

lastIndexOf()   　　　　　　 和arr.indexOf()的功能一样，不同的是从后往前查找 Array.from() 　　　　　　　　 将伪数组变成数组，就是只要有length的就可以转成数组。 ---es6 Array.of() 　　　　　　　　　 将一组值转换成数组，类似于声明数组    ---es6 find(callback) 　　　　　　　找到第一个符合条件的数组成员 findIndex(callback) 　　　　找到第一个符合条件的数组成员的索引值 fill(target, start, end)   使用给定的值，填充一个数组 includes() 　　　　　　　　　 判断数中是否包含给定的值 keys() 　　　　　　　　　　　　遍历数组的键名 values() 　　　　　　　　　　 遍历数组键值 entries() 　　　　　　　　　　遍历数组的键名和键值

　　

----------------------------------
仅供参考
​

Array 方法

方法	描述
concat()	连接两个或多个数组，并返回已连接数组的副本。
copyWithin()	将数组中的数组元素复制到指定位置或从指定位置复制。
entries()	返回键/值对数组迭代对象。
every()	检查数组中的每个元素是否通过测试。
fill()	用静态值填充数组中的元素。
filter()	使用数组中通过测试的每个元素创建新数组。
find()	返回数组中第一个通过测试的元素的值。
findIndex()	返回数组中通过测试的第一个元素的索引。
forEach()	为每个数组元素调用函数。
from()	从对象创建数组。
includes()	检查数组是否包含指定的元素。
indexOf()	在数组中搜索元素并返回其位置。
isArray()	检查对象是否为数组。
join()	将数组的所有元素连接成一个字符串。
keys()	返回 Array Iteration 对象，包含原始数组的键.
lastIndexOf()	在数组中搜索元素，从末尾开始，并返回其位置。
map()	使用为每个数组元素调用函数的结果创建新数组。
pop()	删除数组的最后一个元素，并返回该元素。
push()	将新元素添加到数组的末尾，并返回新的长度。
reduce()	将数组的值减为单个值（从左到右）。
reduceRight()	将数组的值减为单个值（从右到左）。
reverse()	反转数组中元素的顺序。
shift()	删除数组的第一个元素，并返回该元素。
slice()	选择数组的一部分，并返回新数组。
some()	检查数组中的任何元素是否通过测试。
sort()	对数组的元素进行排序。
splice()	从数组中添加/删除元素。
toString()	将数组转换为字符串，并返回结果。
unshift()	将新元素添加到数组的开头，并返回新的长度。
valueOf()	返回数组的原始值。

Array()

创建新对象。Array

静态属性

get Array[@@species]

返回构造函数。Array

静态方法

Array.from()

从类似数组的对象或可迭代对象创建新实例。Array

Array.isArray()

如果参数是数组，则返回该参数，或者其他参数。truefalse

Array.of()

创建具有可变数量的参数的新实例，而不考虑参数的数量或类型。Array

实例属性

Array.prototype.length

反映数组中的元素数。

Array.prototype[@@unscopables]

包含 ES2015 版本之前的 ECMAScript 标准中未包含的属性名称，这些属性名称出于语句绑定目的而被忽略。

实例方法

Array.prototype.at()

返回给定索引处的数组项。接受负整数，从最后一项开始倒计时。

Array.prototype.concat()

返回一个新数组，该数组是与其他数组和/或值联接的调用数组。

Array.prototype.copyWithin()

复制数组中的数组元素序列。

Array.prototype.entries()

返回一个新的数组迭代器对象，该对象包含数组中每个索引的键/值对。

Array.prototype.every()

如果调用数组中的每个元素都满足测试函数，则返回。true

Array.prototype.fill()

用静态值填充数组中从开始索引到结束索引的所有元素。

Array.prototype.filter()

返回一个新数组，其中包含调用数组的所有元素，提供的筛选函数将为其返回 。true

Array.prototype.find()

返回数组中满足提供的测试函数的第一个元素的值，或者如果未找到适当的元素，则返回该值。undefined

Array.prototype.findIndex()

返回数组中满足提供的测试函数的第一个元素的索引，或者如果未找到适当的元素，则返回该索引。-1

Array.prototype.findLast()

返回数组中满足提供的测试函数的最后一个元素的值，或者如果未找到适当的元素，则返回该元素的值。undefined

Array.prototype.findLastIndex()

返回数组中满足提供的测试函数的最后一个元素的索引，或者如果未找到适当的元素，则返回该索引。-1

Array.prototype.flat()

返回一个新数组，其中包含所有子数组元素以递归方式连接到该数组中，直至达到指定的深度。

Array.prototype.flatMap()

返回一个新数组，该数组通过将给定的回调函数应用于调用数组的每个元素，然后将结果平展一个级别。

Array.prototype.forEach()

为调用数组中的每个元素调用一个函数。

Array.prototype.group() 实验的

根据测试函数返回的字符串将数组的元素分组到对象中。

Array.prototype.groupToMap() 实验的

根据测试函数返回的值将数组的元素分组到 Map 中。

Array.prototype.includes()

确定调用数组是否包含值（返回值或适当值）。truefalse

Array.prototype.indexOf()

返回可在调用数组中找到给定元素的第一个（最小）索引。

Array.prototype.join()

将数组的所有元素联接到一个字符串中。

Array.prototype.keys()

返回一个新的数组迭代器，其中包含调用数组中每个索引的键。

Array.prototype.lastIndexOf()

返回在调用数组中可以找到给定元素的最后一个（最大）索引，或者如果找不到任何元素，则返回该索引。-1

Array.prototype.map()

返回一个新数组，其中包含对调用数组中的每个元素调用函数的结果。

Array.prototype.pop()

从数组中删除最后一个元素并返回该元素。

Array.prototype.push()

将一个或多个元素添加到数组的末尾，并返回数组的新元素。length

Array.prototype.reduce()

对数组的每个元素（从左到右）执行用户提供的“reducer”回调函数，以将其减少到单个值。

Array.prototype.reduceRight()

对数组的每个元素（从右到左）执行用户提供的“reducer”回调函数，以将其减少到单个值。

Array.prototype.reverse()

反转数组元素就地的顺序。（第一个变成最后一个，最后一个变成第一个。

Array.prototype.shift()

从数组中删除第一个元素并返回该元素。

Array.prototype.slice()

提取调用数组的一部分并返回一个新数组。

Array.prototype.some()

如果调用数组中至少有一个元素满足提供的测试函数，则返回该值。true

Array.prototype.sort()

就地对数组的元素进行排序并返回该数组。

Array.prototype.splice()

在数组中添加和/或删除元素。

Array.prototype.toLocaleString()

返回一个本地化的字符串，表示调用数组及其元素。重写对象.prototype.to定位字符串（） 方法。

Array.prototype.toString()

返回一个字符串，表示调用数组及其元素。重写对象.

Array.prototype.unshift()

将一个或多个元素添加到数组的前面，并返回数组的新元素。length

Array.prototype.values()

返回一个新的数组迭代器对象，该对象包含数组中每个索引的值。

Array.prototype[@@iterator]()

默认情况下，值（） 方法的别名。