编辑代码

// reduce是数组的方法，可以对数组中的每个元素依次执行一个回调函数，从左到右依次累积计算出一个最终的值。其语法为：
//  arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
//  callback是reduce执行的回调函数;
//      accumulator  函数是上一次循环计算的结果
//      currentValue 当前正在执行的目标元素
//      index 索引
//  initialValue 计算初始值,为空时.默认从数组第一个元素开始

// 1,计算数组中每个元素出现的次数
const fruits = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple'];
const count = fruits.reduce((accumulate, current) => {
    accumulate[current] = (accumulate[current] || 0) + 1
    return accumulate
}, {})
console.log(count)
let maxCount = 0;
for (let key in count) {
    if (count[key] > maxCount) {
        maxCount = count[key]
    }
}
console.log(maxCount)

// 2,拍平嵌套数组
// 利用函数递归,判断深层的数组重复执行合并
const nestedArray = [[1, [7, 8, 9], 2], [3, 4], [5, 6]];

function filterArray(paramsArray) {
    return paramsArray.reduce((accumulate, current) => {
        // console.log(accumulate, current)
        return Array.isArray(current) ? accumulate.concat(filterArray(current)) : accumulate.concat(current)
    }, [])
}
const planArray = filterArray(nestedArray)
console.log(planArray)

// 3,数组条件分组  ---  按age分组
const people = [
    { name: 'Alice', age: 25 },
    { name: 'Bob', age: 30 },
    { name: 'Charlie', age: 35 },
    { name: 'David', age: 25 },
    { name: 'Emily', age: 30 }
];


const output = people.reduce((acc, value) => {
    // console.log(acc, value)
    let key = value.age
    if (!acc[key]) {
        acc[key] = [value]
    } else {
        acc[key].push(value)
    }
    return acc
}, {})
console.log(output)

// 4,将多个数组合并成为对象
const keys = ['name', 'age', 'gender'];
const values = ['Alice', 25, 'female'];

const objs = keys.reduce((acc, value, index) => {
    acc[value] = values[index]
    return acc
}, {})
console.log(objs)

// 5.将字符串转换为对象
const str = 'key1=value1&key2=value2&key3=value3';
// console.log(str.split("&"))
const strObj = str.split("&").reduce((acc, value) => {
    // acc[value.split("=")[0]] = value.split("=")[1]
    const [key, currentVal] = value.split("=")
    acc[key] = currentVal
    return acc
}, {})
console.log(strObj)

// 7,将对象转换为查询字符串
const params = { foo: "bar", baz: 42 };
console.log(Object.entries(params))
const paramsString = Object.entries(params).reduce((acc, value, index) => {
    console.log(value, index)
    const [key, currentVal] = value
    return acc = acc + (index == 0 ? "" : "&") + key + "=" + currentVal
}, "?")

console.log(paramsString)

// 8,打印斐波那契数列
// 从索引2开始之后,当前数字都等于前两个之和
const Fibonacci = (n) => {
    return [...Array(n)].reduce((acc, value, index) => {
        if (index < 2) {
            acc.push(index)
        } else {
            acc.push(acc[index - 1] + acc[index - 2])
        }
        return acc
    }, [])
}

console.log(Fibonacci(10))

// 9,检测字符串是否回文字符串
let palindromeStr = "1234321"
let palindromeArr = palindromeStr.split('')
console.log(palindromeArr)
const isPal = palindromeArr.reduce((acc, current, index, arr) => {
    // console.log(acc,value,arr.length - 1 - index)
    return acc && current == arr[arr.length - 1 - index]
}, true)
console.log("回文字符串~~~", isPal)

// 10,检查括号是否匹配
const strkuo = "((()))(()())";
const isKuo = strkuo.split("").reduce((acc, current) => {
    if (current === "(") {
        acc++
    } else if (current == ")") {
        acc--
    }
    return acc
}, 0) === 0

console.log(isKuo)

// 11,递归获取对象属性
const user = {
    info: {
        name: "Jason",
        address: { home: "Shaanxi", company: "Xian" },
    },
};
// console.log(Object.entries(user))
const get = (config, path, defaulVal) => {
    // 递归执行
    return path.split('.').reduce((config, name) => config[name], config) || defaulVal;
    return callback;
}

get(user, "info.name"); // Jason
get(user, "info.address.company"); // Xian
get(user, "info.address.abc", "default"); // default

console.log(get(user, "info.name"))


// 手写reduce函数
function myReduce(arr, callback, initialValue) {
    let accumulator = initialValue == undefined ? arr[0] : initialValue;
    for (let i = initialValue == undefined ? 1 : 0; i < arr.length; i++) {
        accumulator = callback(accumulator, arr[i], i, arr)
    }
    return accumulator
}

//求和
const heArr = [0, 1, 2, 3, 4, 5]
const sumHe = myReduce(heArr, (acc, val) => {
    console.log(acc, val)
    acc += val
    return acc
})
console.log(sumHe)