2635. 转换数组中的每个元素

编写一个函数，这个函数接收一个整数数组 arr 和一个映射函数 fn ，通过该映射函数返回一个新的数组。

返回数组的创建语句应为 returnedArray[i] = fn(arr[i], i) 。

请你在不使用内置方法 Array.map 的前提下解决这个问题。

示例 1:
输入：arr = [1,2,3], fn = function plusone(n) { return n + 1; }
输出：[2,3,4]
解释：
const newArray = map(arr, plusone); // [2,3,4]
此映射函数返回值是将数组中每个元素的值加 1。

示例 2:
输入：arr = [1,2,3], fn = function plusI(n, i) { return n + i; }
输出：[1,3,5]
解释：此映射函数返回值根据输入数组索引增加每个值。

示例 3:
输入：arr = [10,20,30], fn = function constant() { return 42; }
输出：[42,42,42]
解释：此映射函数返回值恒为 42。

提示：
0 <= arr.length <= 1000
-109 <= arr[i] <= 109
fn 返回一个数

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var map = function(arr, fn) {
    const len = arr.length;
    for (let i = 0; i < len; i++) {
        arr[i] = fn(arr[i], i);
    }
    return arr;
}

2634. 过滤数组中的元素

给定一个整数数组 arr 和一个过滤函数 fn，并返回一个过滤后的数组 filteredArr 。

fn 函数接受一个或两个参数：

arr[i] - arr 中的数字
i - arr[i] 的索引
filteredArr 应该只包含使表达式 fn(arr[i], i) 的值为真值的 arr 中的元素。真值是指 Boolean(value) 返回参数为 true 的值。

请在不使用内置的 Array.filter 方法的情况下解决该问题。

示例 1：
输入：arr = [0,10,20,30], fn = function greaterThan10(n) { return n > 10; }
输出： [20,30]
解释：
const newArray = filter(arr, fn); // [20, 30]
过滤函数过滤掉不大于 10 的值

示例 2：
输入：arr = [1,2,3], fn = function firstIndex(n, i) { return i === 0; }
输出：[1]
解释：
过滤函数 fn 也可以接受每个元素的索引
在这种情况下，过滤函数删除索引不为 0 的元素

示例 3：
输入：arr = [-2,-1,0,1,2], fn = function plusOne(n) { return n + 1 }
输出：[-2,0,1,2]
解释：
像 0 这样的假值应被过滤掉

提示：
0 <= arr.length <= 1000
-109 <= arr[i] <= 109

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var filter = function(arr, fn) {
    const len = arr.length;
    let newArray = [];
    for (let i = 0; i < len; i++) {
        if(fn(arr[i],i)){
            newArray.push(arr[i])
        }
    }
    return newArray;
};

2626. 数组归约运算

请你编写一个函数，它的参数为一个整数数组 nums 、一个计算函数 fn 和初始值 init 。返回一个数组归约后的值。

你可以定义一个数组归约后的值，然后应用以下操作： val = fn(init, nums[0]) ， val = fn(val, nums[1]) ， val = fn(val, nums[2]) ，… 直到数组中的每个元素都被处理完毕。返回 val 的最终值。

如果数组的长度为 0，它应该返回 init 的值。

请你在不使用内置数组方法的 Array.reduce 前提下解决这个问题。

示例 1：
输入：
nums = [1,2,3,4]
fn = function sum(accum, curr) { return accum + curr; }
init = 0
输出：10
解释：
初始值为 init=0 。
(0) + nums[0] = 1
(1) + nums[1] = 3
(3) + nums[2] = 6
(6) + nums[3] = 10
Val 最终值为 10。

示例 2：
输入：
nums = [1,2,3,4]
fn = function sum(accum, curr) { return accum + curr * curr; }
init = 100
输出：130
解释：
初始值为 init=0 。
(100) + nums[0]^2 = 101
(101) + nums[1]^2 = 105
(105) + nums[2]^2 = 114
(114) + nums[3]^2 = 130
Val 最终值为 130。

示例3:
输入：
nums = []
fn = function sum(accum, curr) { return 0; }
init = 25
输出：25
解释：这是一个空数组，所以返回 init 。

提示：
0 <= nums.length <= 1000
0 <= nums[i] <= 1000
0 <= init <= 1000

/**
 * @param {number[]} nums
 * @param {Function} fn
 * @param {number} init
 * @return {number}
 */
var reduce = function(nums, fn, init) {
    const len = nums.length;
    if(len == 0){
        return init;
    }
    let val = init;
    for (let i = 0; i < len; i++) {
        val = fn(val,nums[i]);
    }
    return val;
}