数据结构
划分
-
存储结构 （存储对应的数据的）
-
逻辑结构（逻辑的体现）
-
算法
存储结构的相关的内容
线性结构（有顺序）
数组 （顺序表）
栈 （先进后出）
队列 （先进先出）
非线性结构 （没有顺序）
串
链表 （单向链表 双向链表）
图 （有向图 无向图）
树 （二叉树）
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]
----------------------------------
仅供参考
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]()-
默认情况下，
值（）方法的别名。