JS Higher Order Function

Array.prototype.reduce<U>(callback: (state: U, element: T, index: number, array: T[]) => U, firstState?: U): U

const data = [1, 2, 3, 4, 5, 6, 1];
const reducer = (accumulator, value, index, array) => {
  if (index === array.length - 1) (accumulator + value) / array.length;
  return accumulator + value;
};
const getMean = data.reduce(reducer, 0);
console.log(getMean); // 3.142857142857143

const data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
const flatArrayReducer = (accumulator, value, index, array) => {
  return [...accumulator, ...value];
};
const flattenedData = data.reduce(flatArrayReducer, []); 
console.log(flattenedData); // [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]

const input = [
  {
    "title": "슈퍼맨",
    "year": "2005",
    "cast": ["장동건", "권상우", "이동욱", "차승원"]
  },
  {
    "title": "스타워즈",
    "year": "2013",
    "cast": ["차승원", "신해균", "장동건", "김수현"]
  },
  {
    "title": "고질라",
    "year": "1997",
    "cast": []
  }
];
const flatMapReducer = (accumulator, value, index, array) => {
  const key = "cast";
  if (value.hasOwnProperty(key) && Array.isArray(value[key])) {
    value[key].forEach(val => {
      if (accumulator.indexOf(val) === -1) {
        accumulator.push(val);
      }
    });
  }
  return accumulator;
};
const flattenCastArray = input.reduce(flatMapReducer, []);
console.log(flattenCastArray); // ['장동건', '권상우', '이동욱', '차승원', '신해균', '김수현']

const arr = [1, 2, 3];
const mapReducer = (acc, value) => {
    acc.push(value * 2);
    return acc;
};
const result = arr.reduce(mapReducer, []);
const result2 = arr.reduce((acc, value) => {
    acc.push(value * 2)
    return acc;
}, []);
const result3 = arr.reduce((acc, value) => [...acc, value * 2], []);

var arr = [4, 15, 377, 395, 400, 1024, 3000]
var arr2 = arr.reduce((pre, value) => {
    if (value % 5 == 0) {
        pre.push(value);
    }
    return pre;
}, []);

const data = [1, 2, 3];
const initialValue = [];
const reducer = (accumulator, value) => {
  accumulator.push(value * 2);
  return accumulator;
};
const result = data.reduce(reducer, initialValue);
console.log(result); // [2, 4, 6]
const result2 = data.map(x => x * 2);
console.log(result2); // [2, 4, 6]

const data = [1, 2, 3, 4, 5, 6];
const initialValue = [];
const reducer = (accumulator, value) => {
  if (value % 2 != 0) {
    accumulator.push(value);
  }
  return accumulator;
};
const result1 = data.reduce(reducer, initialValue);
console.log(result1); // [1, 3, 5]
const result2 = data.filter(x => x % 2 != 0);
console.log(result2); // [1, 3, 5]

const data = [1, 2, 3, 4, 5, 6];
const initialValue = [];
const reducer = (accumulator, value) => {
  if (value % 2 != 0) {
    accumulator.push(value * 2);
  }
  return accumulator;
}
const result1 = data.reduce(reducer, initialValue);
console.log(result1); // [2, 6, 10]
const result2 = data.filter(x => x % 2 != 0).map(x => x * 2);
console.log(result2); // [2, 6, 10]

Array.prototype.filter(callback: (value: T, index: number, array: Array) => any, thisArg?: any): T[]

Array.prototype.map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]

Array.prototype.forEach(callback: (value: T, index: number, array: T[]) => void, thisArg?: any): void