Map：返回一个由回调函数的返回值组成的新的数组
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function map(arr, callback){
//声明一个空的数组
let result = [];
//遍历数组
for(let i=0;i<arr.length;i++){
//执行回调
result.push(callback(arr[i], i));
}
//返回结果
return result;
}
//声明一个数组
const arr = [1,2,3,4,2077,5,1024];
//map 函数调用
const result = map(arr, (item, index) => {
console.log(index);
return item * 10;
});
reduce：从左到右为每个数组元素执行依次回调函数，并把上次回调函数的返回值放在一个暂存器中传给下次回调函数，并返回最后一次回调函数的返回值
/**
*
* @param {Array} arr
* @param {Function} callback
* @param {*} initValue
*/
export function reduce(arr, callback, initValue){
//声明变量
let result = initValue;
//执行回调
for(let i=0;i<arr.length;i++){
//执行回调
result = callback(result, arr[i]);
}
//返回最终的结果
return result;
}
数组固定：
let result = arr.reduce(function(res, value){
return res + value;
}, 0);
封装：
let result = reduce(arr, function(res, value){
return res + value;
}, 10);
filter：将所有在过滤函数中满足条件的数组元素放在一个新的数据中并返回
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function filter(arr, callback){
//声明空数组
let result = [];
//遍历数组
for(let i=0;i<arr.length;i++){
//执行回调
let res = callback(arr[i], i);
//判断 如果为真则压入到 result 结果中
if(res){
result.push(arr[i]);
}
}
//返回结果
return result;
}
const result = arr.filter(item => item % 2===1);
const result = filter(arr, item => item % 2===0);
console.log(result);
find：找到第一个满足测试函数的元素并返回i那个元素的值，如果找不到就返回undefined
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function find(arr, callback){
//遍历数组
for(let i=0;i<arr.length;i++){
//执行回调
let res = callback(arr[i], i);
//判断
if(res){
//返回当前正在遍历的元素
return arr[i];
}
}
//如果没有遇到满足条件的 返回 undefined
return undefined;
}
const result = arr.find(item => {
return item > 1000;
});
const result = find(arr, (item, index) => {
return item > 10000;
});
findIndex：找到第一个满足测试函数的元素并返回那个元素的索引，如果找不到，则是返回-1
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function findIndex(arr, callback){
//遍历数组
for(let i=0;i<arr.length;i++){
//执行回调
let res = callback(arr[i], i);
//判断
if(res){
//返回当前正在遍历的元素
return i;
}
}
//如果没有遇到满足条件的 返回 undefined
return -1;
}
const arr = [1,2,3,4,2077,5,1024];
const result = arr.findIndex(item => {
return item > 10000;
});
const result = findIndex(arr, (item, index) => {
return item > 20000;
});
console.log(result);
every：如果数组中的每一个元素都满足测试函数，则返回true，否则返回false
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function every(arr, callback){
//遍历数组
for(let i=0;i<arr.length;i++){
// 执行回调 如果回调执行返回结果为 false
if(!callback(arr[i], i)){
return false;
}
}
//如果都满足条件则返回 true
return true;
}
const arr = [1,2,3,4,2077,5,1024];
const result = arr.every(item => {
return item > 1;
});
const result = every(arr, (item, index) => {
return item > 0;
});
some：如果数组中至少有一个满足测试函数，则返回true。否则返回false
/**
*
* @param {Array} arr
* @param {Function} callback
*/
export function some(arr, callback){
//遍历数组
for(let i=0;i<arr.length;i++){
// 执行回调 如果回调执行返回结果为 false
if(callback(arr[i], i)){
return true;
}
}
//如果都满足条件则返回 true
return false;
}
const arr = [1,2,3,4,2077,5,1024];
const result = arr.some(item => {
return item > 20000;
});
const result = some(arr, (item, index) => {
return item > 20000;
});
concat数组合并：
export function concat(arr, ...args){
//声明一个空数组
const result = [...arr];
//遍历数组
args.forEach(item => {
//判断 item 是否为数组
if(Array.isArray(item)){
result.push(...item);
}else{
result.push(item);
}
});
//返回 result
return result;
}
let arr = [1,2,3];
const result = arr.concat([4,5,6], 7,8);
console.log(result);
const result = concat(arr, [4,5,6], 7, 8, [9,10]);
slice数组切片：
/**
*
* @param {Array} arr
* @param {Number} begin
* @param {Number} end
*/
function slice(arr, begin, end){
//若arr数组长度为 0
if(arr.length === 0){
return [];
}
//判断 begin
begin = begin || 0;
if(begin >= arr.length){
return [];
}
//判断 end
end = end || arr.length;
if(end < begin){
end = arr.length;
}
//声明一个空数组
const result = [];
//遍历对象
for(let i=0;i<arr.length;i++){
if(i >= begin && i < end){
//将下标对应的元素压入数组
result.push(arr[i]);
}
}
return result;
}
//数组切片
let arr = [1,3,5,7,9,15];
// let result = arr.slice(1, 5);
// console.log(result);
// const result = slice(arr, 1, 5);
const result = slice(arr);
console.log(result);
数组的扁平化：
/**
* 数组扁平化
* @param {Array} arr
*/
function flatten1(arr){
//声明空数组
let result = [];
//遍历数组
arr.forEach(item => {
//判断
if(Array.isArray(item)){
result = result.concat(flatten1(item));
}else{
result = result.concat(item);
}
});
//返回结果
return result;
}
/**
*
* @param {Array} arr
*/
function flatten2(arr){
//声明数组
let result = [...arr];
//循环判断
while(result.some(item => Array.isArray(item))){
// [1,2,[3,4,[5,6]],7]
// result = [].concat(1,2,[3,4,[5,6]],7);// [1,2,3,4,[5,6],7]
// result = [].concat(1,2,3,4,[5,6],7);// [1,2,3,4,5,6,7]
result = [].concat(...result);//
}
//返回结果
return result;
}
//声明一个数组
let arr = [1,2,[3,4,[5,6]],7];// [1,2,3,4,5,6,7]
//数组扁平化
// console.log(flatten1(arr));
// some 以及 concat
console.log(flatten2(arr));
数组分块：将数组拆分多个size长度的区块，每个区块组成小数组，整体组成一个二位数组
/**
* 数组分块儿
* @param {Array} arr
* @param {Number} size
*/
export function chunk(arr, size=1){
//判断
if(arr.length === 0){
return [];
}
//声明两个变量
let result = [];
let tmp = [];// [1,2,3]
//遍历
arr.forEach(item => {
//判断tmp元素长度是否为 0
if(tmp.length === 0){
//将 tmp 压入到 result 中
result.push(tmp);
// [ [1,2,3], [4,5,6], [7] ]
}
//将元素压入到临时数组 tmp 中
tmp.push(item);
//判断
if(tmp.length === size){
tmp = [];
}
});
return result;
}
console.log(chunk([1, 2, 3, 4, 5, 6, 7]));
//[[1,2,3],[4,5,6],[7]]
数组取差异：得到当前数组中所有不在arr中的元素组成的数组（不改变元素组）A-B
例子：difference([1,3,5,7],[5,8]) => [1,3,7]
export function difference(arr1, arr2=[]){
//判断参数
if(arr1.length === 0){
return [];
}
if(arr2.length === 0){
return arr1.slice();
}
const result = arr1.filter(item => !arr2.includes(item));
return result;
}
// console.log(difference([1,3,5,7], [5, 8]));
console.log(difference([1,3,5,7]));
