zqy233的前端学习笔记Array
数组方法
push
向数组的末尾添加一个或多个元素，并返回新的长度， 会改变原数组
js
const arr = [1, 2]
console.log(arr.push(3,4)) // 4
console.log(arr) // [1, 2, 3, 4]
const arr = [1, 2]
console.log(arr.push(3,4)) // 4
console.log(arr) // [1, 2, 3, 4]
unshift
向数组的开头添加一个或更多元素，并返回新的长度， 会改变原数组
js
const arr = ['c', 'd']
console.log(arr.unshift('a', 'b')) // 4
console.log(arr) // [ 'a', 'b', 'c', 'd' ]
const arr = ['c', 'd']
console.log(arr.unshift('a', 'b')) // 4
console.log(arr) // [ 'a', 'b', 'c', 'd' ]
pop
删除数组的最后一个元素并返回删除的元素，会改变原数组
js
const arr = [1, 2, 3]
console.log(arr.pop()) // 3
console.log(arr) // [ 1, 2 ]
const arr = [1, 2, 3]
console.log(arr.pop()) // 3
console.log(arr) // [ 1, 2 ]
shift
删除数组第一个元素，返回当前删除的元素，会改变原数组
js
const arr = [1, 2, 3]
console.log(arr.shift()) // 1
console.log(arr) // [2,3]
const arr = [1, 2, 3]
console.log(arr.shift()) // 1
console.log(arr) // [2,3]
reverse
颠倒数组中元素的顺序，返回颠倒顺序的数组，会改变原数组
js
const arr = [1, 2, 3]
console.log(arr.reverse()) // [3, 2, 1]
console.log(arr) // [3, 2, 1]
const arr = [1, 2, 3]
console.log(arr.reverse()) // [3, 2, 1]
console.log(arr) // [3, 2, 1]
slice
添加或删除数组中的元素
| 参数 | 描述 |
|---|---|
| index | 必需。规定从何处添加/删除元素。 该参数是开始插入和（或）删除的数组元素的下标，必须是数字。 |
| howmany | 可选。规定应该删除多少元素。必须是数字，但可以是 "0"。 如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。 |
| item1, ..., itemX | 可选。要添加到数组的新元素 |
js
const fruits = [1, 2, 3, 4]
console.log(fruits.splice(2, 0, 5,6)) // []
console.log(fruits)
const fruits = [1, 2, 3, 4]
console.log(fruits.splice(2, 0, 5,6)) // []
console.log(fruits)
map
map 方法遍历每个数组元素并进行依次处理后，返回一个新数组，所以使用 map 时需要返回值，并定义变量接收返回值
map 方法不会改变原数组
接受一个函数，函数有三个参数，一个必选，两个可选
js
const arr = [1, 2, 3]
const a = arr.map((a, index, arr) => {
return a + 1
})
console.log(a) // [ 2, 3, 4 ]
const b = arr.map((a, index, arr) => {
return index
})
console.log(b) // [0, 1, 2]
const c = arr.map((a, index, arr) => {
return arr
})
console.log(a) // [[1, 2, 3],[1, 2, 3],[1, 2, 3]]
const arr = [1, 2, 3]
const a = arr.map((a, index, arr) => {
return a + 1
})
console.log(a) // [ 2, 3, 4 ]
const b = arr.map((a, index, arr) => {
return index
})
console.log(b) // [0, 1, 2]
const c = arr.map((a, index, arr) => {
return arr
})
console.log(a) // [[1, 2, 3],[1, 2, 3],[1, 2, 3]]
forEach
遍历每个数组元素，和 map 一样都不会修改原数组，区别在于没有返回值，返回值是 undefined，所以使用 forEach 不需要返回值
参数是一个函数，函数有三个参数，一个必选，两个可选
用法示例 1：修改数组并 push 到一个新数组
js
const arr = [1, 2, 3]
const newarr = [] //当前的元素 index索引 数组对象本身
arr.forEach((a, index, arr) => {
a = a + 3
newarr.push(a)
console.log(a) // 4,5,6
})
console.log(arr) // [1,2,3]
console.log(newarr) // [4,5,6]
const arr = [1, 2, 3]
const newarr = [] //当前的元素 index索引 数组对象本身
arr.forEach((a, index, arr) => {
a = a + 3
newarr.push(a)
console.log(a) // 4,5,6
})
console.log(arr) // [1,2,3]
console.log(newarr) // [4,5,6]
用法示例 2：过滤数组并 push 到一个新数组
js
const arr = [1, 2, 3]
let newarr = []
arr.forEach((a) => {
if (a == 2) return
newarr.push(a)
})
console.log(newarr) // [ 1, 3 ]
const arr = [1, 2, 3]
let newarr = []
arr.forEach((a) => {
if (a == 2) return
newarr.push(a)
})
console.log(newarr) // [ 1, 3 ]
join
数组转字符串
js
const arr = ['a', 'b', 'c', 'd']
const string = arr.join() // a,b,c,d
console.log(string)
console.log(typeof arr) // object
console.log(typeof string) // string
const arr = ['a', 'b', 'c', 'd']
const string = arr.join() // a,b,c,d
console.log(string)
console.log(typeof arr) // object
console.log(typeof string) // string
concat
concat() 方法用于连接两个或多个数组。
js
const a = ['a']
const b = ['b', 'c', 'd', 'e']
const f = ['f']
const arr = a.concat(b, f)
console.log(arr) // [ 'a', 'b', 'c', 'd', 'e', 'f' ]
const a = ['a']
const b = ['b', 'c', 'd', 'e']
const f = ['f']
const arr = a.concat(b, f)
console.log(arr) // [ 'a', 'b', 'c', 'd', 'e', 'f' ]
fill
fill 可以插入数组数据,Array(num)可以产生 num 大小的数组，Array(num).fill(a)每次生成一个数组元素时都会调用 fill 方法插入数据
js
const a = { name: 'A', age: 20, sex: '男' }
const b = Array(1).fill(a)
console.log(b) // [ { name: 'A', age: 20, sex: '男' } ]
const c = []
c.push(a)
console.log(c) // [ { name: 'A', age: 20, sex: '男' } ]
const d = Array(3).fill(a)
console.log(d) //[ { name: 'A', age: 20, sex: '男' } ,{ name: 'A', age: 20, sex: '男' } ,{ name: 'A', age: 20, sex: '男' } ]
const a = { name: 'A', age: 20, sex: '男' }
const b = Array(1).fill(a)
console.log(b) // [ { name: 'A', age: 20, sex: '男' } ]
const c = []
c.push(a)
console.log(c) // [ { name: 'A', age: 20, sex: '男' } ]
const d = Array(3).fill(a)
console.log(d) //[ { name: 'A', age: 20, sex: '男' } ,{ name: 'A', age: 20, sex: '男' } ,{ name: 'A', age: 20, sex: '男' } ]
filter
遍历数组元素，返回符合条件的数据，为 true 的保留，为 false 的滚犊子
示例：返回偶数
js
const a = [1, 2, 3, 4, 5]
const b = a.filter((item) => item % 2 === 0)
console.log(b) //[2,4]
const a = [1, 2, 3, 4, 5]
const b = a.filter((item) => item % 2 === 0)
console.log(b) //[2,4]
示例：直接使用 true/false 的字段来过滤
js
const a = [
{ id: 1, is: true },
{ id: 2, is: true },
{ id: 3, is: false },
{ id: 4, is: true },
{ id: 5, is: false }
]
const b = a.filter((item) => item.is)
console.log(b) //[ { id: 1, is: true }, { id: 2, is: true }, { id: 4, is: true } ]
const a = [
{ id: 1, is: true },
{ id: 2, is: true },
{ id: 3, is: false },
{ id: 4, is: true },
{ id: 5, is: false }
]
const b = a.filter((item) => item.is)
console.log(b) //[ { id: 1, is: true }, { id: 2, is: true }, { id: 4, is: true } ]
include
js
const foo = 'foo'
const bar = 'bar'
const arr = [foo, bar]
const test = 'foo'
if (arr.includes(test)) console.log('TRUE')
const foo = 'foo'
const bar = 'bar'
const arr = [foo, bar]
const test = 'foo'
if (arr.includes(test)) console.log('TRUE')
是否改变原数组
改变原数组
添加元素(返回新的长度)
push把元素添加到数组尾部unshift把元素添加数组头部
删除元素(返回被删除的元素)
pop删除数组最后一个元素shift删除数组第一个元素
颠倒顺序
reverse颠倒数组元素顺序
插入、删除、替换数组元素:(返回被删除的数组）
splice
排序
sort对数组元素进行排序
不会改变原数组
concat连接两个或更多数组，返回结果every检测数组中每个元素是否都符合要求some检测数组中是否有元素符合要求filter挑选数组中符合条件的并返回符合要求的数组join把数组的所有元素放到一个字符串toString把数组转成字符串slice截取一段数组，返回新数组indexOf搜索数组中的元素，并返回所在的位置
数组去重
js
const set = new Set(['foo', 'bar', 'baz', 'foo'])
Array.from(set) // [ "foo", "bar", "baz" ]
const set = new Set(['foo', 'bar', 'baz', 'foo'])
Array.from(set) // [ "foo", "bar", "baz" ]
据相同选项合并数据
js
let json = []
let dataInfo = {}
json.forEach(item => {
let { idCardNo } = item
if (!dataInfo[idCardNo]) {
dataInfo[idCardNo] = {
idCardNo,
name: '',
msgs: [],
}
}
dataInfo[idCardNo].name = item.name
dataInfo[idCardNo].msgs.push(item)
item.jdMessageList.forEach(subitem => {
dataInfo[idCardNo].msgs.push(subitem);
})
});
let list = Object.values(dataInfo)
let json = []
let dataInfo = {}
json.forEach(item => {
let { idCardNo } = item
if (!dataInfo[idCardNo]) {
dataInfo[idCardNo] = {
idCardNo,
name: '',
msgs: [],
}
}
dataInfo[idCardNo].name = item.name
dataInfo[idCardNo].msgs.push(item)
item.jdMessageList.forEach(subitem => {
dataInfo[idCardNo].msgs.push(subitem);
})
});
let list = Object.values(dataInfo)
取出对象数组中的某个属性生成数组
js
const emojiArr = choices.map(item => item.emoji)
const emojiArr = choices.map(item => item.emoji)
控制台打印json数据
js
console.log(JSON.parse(jsonData))
console.log(JSON.parse(jsonData))
要么不填，要填则要填写完整
js
if (!(Object.values(i).every(item => item == "") || Object.values(i).every(item => item != ""))) {
return $Toast("请完整填写")
}
if (!(Object.values(i).every(item => item == "") || Object.values(i).every(item => item != ""))) {
return $Toast("请完整填写")
}
不用循环获取长度为m，所有元素都为n的数组
js
function fn(m, n) {
return m ? fn(m - 1, n).concat(n) : [];
}
function fn(m, n) {
return Array(m).fill(n)
}
function fn(m, n) {
return m ? fn(m - 1, n).concat(n) : [];
}
function fn(m, n) {
return Array(m).fill(n)
}
获取一个倒叙的数字列表
js
getNumbers (start, stop) {
return Array(stop - start).fill(start).map((n, i) => n + i)
}
getNumbers (start, stop) {
return Array(stop - start).fill(start).map((n, i) => n + i)
}
遍历所有节点，去除type为0的节点
js
const list = [{
"id": 0,
"type": 1,
"children": [{
"id": "0-1",
"type": 1,
"children": [{
"id": 0,
"type": 1,
"children": []
}]
}]
},
{
"id": 1,
"type": 1,
"children": [{
"id": "1-0",
"type": 1,
"children": []
}]
}, {
"id": 2,
"type": 0,
"children": [{
"id": "2-0",
"type": 1,
"children": []
}, {
"id": "2-1",
"type": 1,
"children": []
}, {
"id": "2-2",
"type": 0,
"children": [{
"id": "2-2-0",
"type": 1,
"children": []
}]
}, {
"id": "2-3",
"type": 0,
"children": []
}]
}
]
function getList(list) {
for (let i = 0; i < list.length; i++) {
const item = list[i]
if (item.type == 0) {
list.splice(i, 1)
i--
}
if (item.children && item.children.length > 0) {
getList(item.children)
}
}
}
getList(list)
const list = [{
"id": 0,
"type": 1,
"children": [{
"id": "0-1",
"type": 1,
"children": [{
"id": 0,
"type": 1,
"children": []
}]
}]
},
{
"id": 1,
"type": 1,
"children": [{
"id": "1-0",
"type": 1,
"children": []
}]
}, {
"id": 2,
"type": 0,
"children": [{
"id": "2-0",
"type": 1,
"children": []
}, {
"id": "2-1",
"type": 1,
"children": []
}, {
"id": "2-2",
"type": 0,
"children": [{
"id": "2-2-0",
"type": 1,
"children": []
}]
}, {
"id": "2-3",
"type": 0,
"children": []
}]
}
]
function getList(list) {
for (let i = 0; i < list.length; i++) {
const item = list[i]
if (item.type == 0) {
list.splice(i, 1)
i--
}
if (item.children && item.children.length > 0) {
getList(item.children)
}
}
}
getList(list)
合并相同字段的数据
js
let resData = [{
"name": "住院医疗最高报销",
"tagName": "医疗",
"insuredAmount": "6000"
},
{
"name": "身故赔付",
"tagName": "寿险",
"insuredAmount": "36.00"
},
{
"name": "120种重大疾病确诊赔付",
"tagName": "重疾",
"insuredAmount": "350000"
},
{
"name": "烦死了免费陈述事实",
"tagName": "寿险",
"insuredAmount": "8888.00"
},
{
"name": "你好，噜噜噜",
"tagName": "寿险",
"insuredAmount": "66.00"
},
]
let dataInfo = {}
resData.forEach((item, index) => {
let { tagName } = item
if (!dataInfo[tagName]) {
dataInfo[tagName] = {
tagName,
child: []
}
}
dataInfo[tagName].child.push(item)
})
let list = Object.values(dataInfo)
let resData = [{
"name": "住院医疗最高报销",
"tagName": "医疗",
"insuredAmount": "6000"
},
{
"name": "身故赔付",
"tagName": "寿险",
"insuredAmount": "36.00"
},
{
"name": "120种重大疾病确诊赔付",
"tagName": "重疾",
"insuredAmount": "350000"
},
{
"name": "烦死了免费陈述事实",
"tagName": "寿险",
"insuredAmount": "8888.00"
},
{
"name": "你好，噜噜噜",
"tagName": "寿险",
"insuredAmount": "66.00"
},
]
let dataInfo = {}
resData.forEach((item, index) => {
let { tagName } = item
if (!dataInfo[tagName]) {
dataInfo[tagName] = {
tagName,
child: []
}
}
dataInfo[tagName].child.push(item)
})
let list = Object.values(dataInfo)
稀疏数组与hole
在绝大多数JavaScript的实现中，数组是稀疏的，我们可以认为js的数组都是稀疏的（虽然ES标准并没有这样规定）
稀疏数组是什么
稀疏数组与密集数组最大的不同，就是稀疏数组中可以有**孔(hole**)。孔是逻辑上存在于数组中，但物理上不存在与内存中的那些数组项。在那些仅有少部分项被使用的数组中，孔可以大大减少内存空间的浪费。比如，我们要表示一个长度为10000的数组，它的最后一个项是字符串'a'。如果按照密集数组的做法，我们需要开辟10000个项的空间，有9999个项的空间都被浪费了。而如果按照稀疏数组的做法，稀疏数组只需要记录：“数组第10000个项的值为'a'”，这节省了很多内存空间。
JavaScript数组天生就是稀疏数组
js数组就是若干个下标（数字）与值之间的映射。从下标x到值y的映射表示：“数组第x个项的值为y”。这实际上就是上例中稀疏数组的记录方法
js
const a = new Array
const a = new Array
得到的数组a中只有一个属性length，记录了它的长度，但是没有任何下标（数字）与值之间的映射。这是一个只有孔的数组
如果执行a[1] = 'aaa'，那么实际上是在这个稀疏数组中增加了一条从1到"aaa"之间的映射
如果继续执行a[10000]='bbb'，也只不过是又增加了一条从10000到"bbb"之间的映射而已。length自动变为了10001，这符合我们的直觉。不存在映射关系，但又处在数组长度范围内的数组项，就是孔
此时，这个数组与长度为2的普通数组['aaa', 'bbb']，占用相同大小的内存空间
JavaScript数组稀疏特性带来的“怪异现象”
slice会复制孔
js
var arr = [ 'a', , 'b' ]
// ["a", undefined × 1, "b"]
arr.slice(1,2)
// [undefined × 1]
arr.slice()
// ["a", undefined × 1, "b"]
var arr = [ 'a', , 'b' ]
// ["a", undefined × 1, "b"]
arr.slice(1,2)
// [undefined × 1]
arr.slice()
// ["a", undefined × 1, "b"]
forEach、every会跳过孔（不对孔调用回调函数）
js
var arr = [ 'a', , 'b' ]
// ["a", undefined × 1, "b"]
arr.forEach(function (x, i) { console.log(i+'.'+x) })
// 0.a
// 2.b
arr.every(function (x) { return x.length === 1 })
// true
var arr = [ 'a', , 'b' ]
// ["a", undefined × 1, "b"]
arr.forEach(function (x, i) { console.log(i+'.'+x) })
// 0.a
// 2.b
arr.every(function (x) { return x.length === 1 })
// true
map不对孔调用回调函数，但是孔会保留
js
arr.map(function (x,i) { return i+'.'+x })
// [ '0.a', undefined × 1, '2.b' ]
arr.map(function (x,i) { return i+'.'+x })
// [ '0.a', undefined × 1, '2.b' ]
filter不对孔调用回调函数，但是孔会被过滤掉
js
arr.filter(function (x) { return true })
// [ 'a', 'b' ]
arr.filter(function (x) { return true })
// [ 'a', 'b' ]
join会将孔转化为一个空字符串进行拼接，与undefined一样
js
arr.join('-')
// 'a--b'
[ 'a', undefined, 'b' ].join('-')
// 'a--b'
arr.join('-')
// 'a--b'
[ 'a', undefined, 'b' ].join('-')
// 'a--b'
而其他所有的数组方法会正常对待孔，就像数组中真的存在这个“空位”一样：
js
var arr2 = arr.slice()
arr2.sort()
// [ 'a', 'b', undefined × 1 ]
var arr2 = arr.slice()
arr2.sort()
// [ 'a', 'b', undefined × 1 ]
初始化无孔数组的方法
因为数组中的孔会造成上述的那些“怪异现象”，所以我们有时希望初始化一个没有孔的数组。 比如我们希望初始化[0,1,2]这样的数组，但是我们无法通过new Array(3)与map方法得到：
js
var a1 = new Array(3)
// [undefined × 3]
a1.map(function (x, i) { return i })
// [undefined × 3]
// 因为map会跳过孔，所以实际上回调函数没有被调用过
var a1 = new Array(3)
// [undefined × 3]
a1.map(function (x, i) { return i })
// [undefined × 3]
// 因为map会跳过孔，所以实际上回调函数没有被调用过
正确的方法：
js
var a2 = Array.apply(null, Array(3))
// [undefined, undefined, undefined]
a2.map(function (x, i) { return i })
// [0, 1, 2]
// map的回调函数执行了3次
var a2 = Array.apply(null, Array(3))
// [undefined, undefined, undefined]
a2.map(function (x, i) { return i })
// [0, 1, 2]
// map的回调函数执行了3次
打印结果分别为[undefined × 3]和[undefined, undefined, undefined]，chrome控制台用这两种表示方式来区分孔和真正的undefined值！
第一种方法没有构造出映射，只创造出了3个孔。而第二种方法创建出了真正的“从下标到值之间的映射”，映射的值为undefined。因此map不会跳过这些数组项。
Array.apply(null, Array(n))的原理
为什么var a2 = Array.apply(null, Array(3))能创造出无孔的数组呢？ 我们将一个含有3个孔的数组作为第二个参数传递给apply，apply将利用这个数组来决定调用Array()的参数。 因为apply将数组中的孔视为undefined，所以Array调用的参数实际上为Array(undefined, undefined, undefined)。 又因为通过Array(a,b,c)这种方法调用Array会返回[a,b,c]，所以Array(undefined, undefined, undefined)返回的是[undefined, undefined, undefined]
判断一个数组完全包含另一个数组
js
// 生成随机字符串
function randomString(e) {
e = e || 32;
var t = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678",
a = t.length,
n = "";
for (i = 0; i < e; i++) n += t.charAt(Math.floor(Math.random() * a));
return n
}
// every + includes
function arrIncludes(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
return arr2.every(val => arr1.includes(val));
}
// indexOf
function arrIncludes2(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const aaStr = arr1.toString();
for (let i = 0; i < arr2.length; i += 1) {
if (aaStr.indexOf(arr2[i]) < 0) return false;
}
return true;
}
// Set
function arrIncludes3(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const tempArrLength = Array.from(new Set([...arr1, ...arr2])).length;
return tempArrLength === arr1.length || tempArrLength === arr2.length;
}
// Map
function arrIncludes4(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const map1 = new Map()
console.log('map1: ', map1);
arr1.forEach(item => map1.set(item,item))
console.log('map2: ', map1);
return arr2.every(val => map1.has(val));
}
let arr1 = []
// 生成随机字符串
for (let i = 1; i <= 100000; i++) {
arr1.push(randomString(10));
}
console.log('arr1: ', arr1);
let arr2 = arr1.slice(0, 50000)
console.log('arr2: ', arr2);
// let arr1 = ['1','3','4','5','6','2']
// let arr2 = ['1','2','6','7']
let timeA1 = performance.now()
let resA = arrIncludes(arr1, arr2)
console.log('resA: ', resA);
let timeA2= performance.now()
let timeResA1 = timeA2-timeA1
console.log('timeResA1: ', timeResA1);
let timeB1 = performance.now()
let resB = arrIncludes2(arr1, arr2)
console.log('resB: ', resB);
let timeB2= performance.now()
let timeResB1 = timeB2-timeB1
console.log('timeResB1: ', timeResB1);
let timeC1 = performance.now()
let resC = arrIncludes3(arr1, arr2)
console.log('resC: ', resC);
let timeC2= performance.now()
let timeResC1 = timeC2-timeC1
console.log('timeResC1: ', timeResC1);
let timeD1 = performance.now()
let resD = arrIncludes4(arr1, arr2)
console.log('resD: ', resD);
let timeD2= performance.now()
let timeResD1 = timeD2-timeD1
console.log('timeResD1: ', timeResD1);
// 生成随机字符串
function randomString(e) {
e = e || 32;
var t = "ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678",
a = t.length,
n = "";
for (i = 0; i < e; i++) n += t.charAt(Math.floor(Math.random() * a));
return n
}
// every + includes
function arrIncludes(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
return arr2.every(val => arr1.includes(val));
}
// indexOf
function arrIncludes2(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const aaStr = arr1.toString();
for (let i = 0; i < arr2.length; i += 1) {
if (aaStr.indexOf(arr2[i]) < 0) return false;
}
return true;
}
// Set
function arrIncludes3(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const tempArrLength = Array.from(new Set([...arr1, ...arr2])).length;
return tempArrLength === arr1.length || tempArrLength === arr2.length;
}
// Map
function arrIncludes4(arr1, arr2) {
if (!Array.isArray(arr2)) {
arr2 = [arr2];
}
const map1 = new Map()
console.log('map1: ', map1);
arr1.forEach(item => map1.set(item,item))
console.log('map2: ', map1);
return arr2.every(val => map1.has(val));
}
let arr1 = []
// 生成随机字符串
for (let i = 1; i <= 100000; i++) {
arr1.push(randomString(10));
}
console.log('arr1: ', arr1);
let arr2 = arr1.slice(0, 50000)
console.log('arr2: ', arr2);
// let arr1 = ['1','3','4','5','6','2']
// let arr2 = ['1','2','6','7']
let timeA1 = performance.now()
let resA = arrIncludes(arr1, arr2)
console.log('resA: ', resA);
let timeA2= performance.now()
let timeResA1 = timeA2-timeA1
console.log('timeResA1: ', timeResA1);
let timeB1 = performance.now()
let resB = arrIncludes2(arr1, arr2)
console.log('resB: ', resB);
let timeB2= performance.now()
let timeResB1 = timeB2-timeB1
console.log('timeResB1: ', timeResB1);
let timeC1 = performance.now()
let resC = arrIncludes3(arr1, arr2)
console.log('resC: ', resC);
let timeC2= performance.now()
let timeResC1 = timeC2-timeC1
console.log('timeResC1: ', timeResC1);
let timeD1 = performance.now()
let resD = arrIncludes4(arr1, arr2)
console.log('resD: ', resD);
let timeD2= performance.now()
let timeResD1 = timeD2-timeD1
console.log('timeResD1: ', timeResD1);
数组补全指定元素
js
// 可能有的区没有数据，需要补全
this.order.forEach((item) => {
let obj = res.find((i) => i.FQ === item);
if (!obj) {
res.push({
YYDL: "--.--",
FQ: item,
});
}
});
// 可能有的区没有数据，需要补全
this.order.forEach((item) => {
let obj = res.find((i) => i.FQ === item);
if (!obj) {
res.push({
YYDL: "--.--",
FQ: item,
});
}
});
按照指定顺序数据排序
sort会影响原数组
js
data.sort((a, b) => {
return order.indexOf(a.FQ) - order.indexOf(b.FQ);
});
data.sort((a, b) => {
return order.indexOf(a.FQ) - order.indexOf(b.FQ);
});
获取最大值
js
const numData = this.data.map((item) =>
Number(item.YDL !== "--.--" ? item.YDL : 0)
);
const max = Math.max(...numData);
const numData = this.data.map((item) =>
Number(item.YDL !== "--.--" ? item.YDL : 0)
);
const max = Math.max(...numData);
插入指定数据到指定位置
第一个参数表示插入哪个元素后面，第二个元素表示删除几个元素，第三个元素表示指定数据
示例：把数组的第二个元素插入第二个元素后面
js
numData.splice(1, 0, numData[1]);
numData.splice(1, 0, numData[1]);
按时间排序
js
function MsgSort(obj) {
obj.sort((a, b) => {
let t1 = Date.parse(a.createTime)
let t2 = Date.parse(b.createTime)
return t2 - t1
})
return obj
}
function MsgSort(obj) {
obj.sort((a, b) => {
let t1 = Date.parse(a.createTime)
let t2 = Date.parse(b.createTime)
return t2 - t1
})
return obj
}