JS-数组-函数的使用2

2021-03-04

合并数组

1 2	let ary = [1, 2, 3, 4]; ary.concat(ary); //[1, 2, 3, 4, 1, 2, 3, 4]

数组内部移动复制

let ary = [1, 2, 3, 4, 5];
/* 第一个参数：想要移动的位置
   第二个参数：决定移动的起始位置（包括）
   第三个参数：决定移动的结束位置（不包括）
 */
ary.copyWithin(3, 0, 2); //[1, 2, 3, 1, 2]

查找元素基本使用

ary.indexOf 和 ary.lastIndexOf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ary.indexOf(2);//寻找2的下标值

//return 1
ary.indexOf(88);//寻找 88 的下标值，找不到返回-1
// -1
let a=[1,1,1,2];
a.lastIndexOf(1);//返回下标值2，也就是说查找值为一的最后出现的下标
ary.lastIndexOf(3,-4);//与 indexOf 正好相反
//-1
ary.lastIndexOf(3,0);//与 indexOf 正好相反
//-1
ary.lastIndexOf(3,2);//与 indexOf 正好相反
//2

数组中是否拥有某元素

1
2
3

方式一：if(ary.indexOf(2)!=-1)//有
方式二：ary.includes(2)//true

更加高效的元素查找

问题：当我们想要查找数组中是否存在一个引用类型时，用 includes 行吗？：NO

let a = [{ name: "w" }, { name: "s" }];

a.includes({ name: "w" }); //false
//因为include会根据传入的参数去比较是否相同，而引用类型的比较相等的条件是内存地址相等，实参{name:'w'}实际上是一个新的地址

那么如何检索引用类型？

检索引用类型：find(function) & findIndex

let a = [{ name: "w" }, { name: "s" }];
a.find(function (item) {
  return 1;
}); //当函数中的返回体为真就返回第一个符合函数条件的值（find是禁止贪婪的）

a.find(function(item)
    { 
        return item.name=='w';}
    )
// console:{name: "w"}

//若找不到 返回undefined
a.find(function(item)
    { return item.name==2;}
    )

//如果想要获取到其下标则用findIndex
a.findIndex(function(item){ return item.name=='w';})
//0

find 原理

function Myfind (callback){ for(let i of ary){if(callback(i)) return i;}//return undefined;
    
    写在原型上：
    Array.prototype.MyFind = function (callback){ for(let i of this){if(callback(i)) return i;}return undefined;
    }

forEach循环数组

let a = [{name:'aa'},{name:2}]
a.forEach(function(item,index,arrys){ console.log(item,index,arrys) })
// {name: "aa"} 0  [{…}, {…}]
 //{name: 2} 1  [{…}, {…}]

every 和 some

some() 方法测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值


/* return都是boolean */
let a = [1,2,3];
a.some(function(item,index,array){ return item == 1 });//true,遇到第一个符合条件的都不再继续向下查找

1
2
3

let a = [10,12,11];
a.every(function(i,index,array){ return i>1; });//true,必须每一个都符合才返回true

filter

1
2
3

let a = [10,12,11];
a.filter(function(i,index,array){ return i>10; });//[12, 11],仅过滤符合条件的，返回数组

map

/* map映射数组：数组中的元素如果是值类型，则不会被影响；若是引用类型则会被影响 */
a.map(function(value){ value = 1; return value})
// [1, 1, 1, 1]
/* 但 */
console.log(a);
//[1, 2, 3, 4]，数组a未被改变

/* 而对于引用类型来说 */
b.map(function(item){item.n = '我已被map映射修改';})；//在没有返回item的情况下，b内元素的值已经被修改
console.log(b)；

/* 0: {n: "我已被map映射修改", m: 100}
1: {n: "我已被map映射修改", m: 100} */

/* 所以对于应用类型来说，怎样才能不影响原数组的情况下，获得修改后的副本呢？也就是复制一份数组，再进行修改【有关于浅拷贝和深拷贝】 */
b.map(function(item){ return Object.assign({ item ,add:'新添加'})})
/* 0: {item: {…}, add: "新添加"}
1: {item: {…}, add: "新添加"} */
console.log(b);
/* 仍是[{n: "我已被map映射修改", m: 100}
 {n: "我已被map映射修改", m: 100}] */

reduce

let a = [1,2,3,4,5];
// 第一个参数：回调函数：[参数1-pre：如果没有设置初始值那么第一次的值就是数组的第一个元素，下一次的值是reduce函数上一个返回值        参数2-cur: 当前值]
// 第二个参数：initalPre：pre的初始值
a.reduce(function(pre,cur,curIndex,arry){ console.log(pre,cur,curIndex); },initalPre);

a.reduce(function(pre,cur,index,arry){ console.log(pre,cur,index,arry); return 'h'+cur; });
//1 2 1   [1, 2, 3, 4]
//h2 3 2  [1, 2, 3, 4]
//h3 4 3  [1, 2, 3, 4]

/* 应用：例如统计元素出现的次数 */
function countNum(arry,value){ return arry.reduce(function(pre,cur){ if(cur === value) return ++pre;else return pre; },0) }