Run results for: fastest filter and map

Test name	Executions per second
✓ base line	11,879,310 Ops/sec
plain for loop	11,333,868 Ops/sec
no copy2	10,894,472 Ops/sec
two passes	8,476,422 Ops/sec
no copy	4,104,495 Ops/sec
typeof before clone	85,773 Ops/sec
just clone	70,534 Ops/sec
Script Preparation code:
var testArray = [
  {
    description: 'Random description.',
    testNumber: 123456789,
    testBoolean: true,
    testObject: {
      testString: 'test string',
      testNumber: 12345,
    },
    testArray: [
      {
        myName: 'test name',
        myNumber: 123245,
      },
    ],
  },
  {
    description: 'Random description.',
    testNumber: 123456789,
    testBoolean: true,
    testObject: {
      testString: 'test string',
      testNumber: 12345,
    },
    testArray: [
      {
        myName: 'test name',
        myNumber: 123245,
      },
    ],
  },

  {
    description: 'Random description.',
    testNumber: 123456789,
    testBoolean: true,
    testObject: {
      testString: 'test string',
      testNumber: 12345,
    },
    testArray: [
      {
        myName: 'test name',
        myNumber: 123245,
      },
    ],
  },

  {
    description: 'Random description.',
    testNumber: 123456789,
    testBoolean: true,
    testObject: {
      testString: 'test string',
      testNumber: 12345,
    },
    testArray: [
      {
        myName: 'test name',
        myNumber: 123245,
      },
    ],
  },

  {
    description: 'Random description.',
    testNumber: 123456789,
    testBoolean: true,
    testObject: {
      testString: 'test string',
      testNumber: 12345,
    },
    testArray: [
      {
        myName: 'test name',
        myNumber: 123245,
      },
    ],
  },
];

var testStringArray = [
  'Random description.',
  'Random description.',
  'Random description.',
  'Random description.',
];

var merged = testStringArray.concat(testArray);

var baseLine = () => {
  return merged.map(elem => elem);
};

const filterMapA = (array, predicate, mapFn) => {
  return array.reduce((accumulator, element, index) => {
    if (!predicate(element, index, array)) {
      return accumulator;
    }
    const shouldClone = typeof element === 'object' || Array.isArray(element);
    return [
      ...accumulator,
      mapFn(
        shouldClone ? structuredClone(element) : element,
        accumulator.length - 1,
      ),
    ];
  }, []);
};

const filterMapB = (array, predicate, mapFn) => {
  return array.reduce((accumulator, element, index) => {
    if (!predicate(element, index, array)) {
      return accumulator;
    }

    return [
      ...accumulator,
      mapFn(structuredClone(element), accumulator.length - 1),
    ];
  }, []);
};

const filterMapC = (array, predicate, mapFn) => {
  return array.reduce((accumulator, element, index) => {
    if (!predicate(element, index, array)) {
      return accumulator;
    }

    return [...accumulator, mapFn(element, accumulator.length - 1)];
  }, []);
};

const filterMapD = (array, predicate, mapFn) => {
  return array.reduce((accumulator, element, index) => {
    if (!predicate(element, index, array)) {
      return accumulator;
    }
    accumulator.push(mapFn(element, accumulator.length - 1));
    return accumulator;
  }, []);
};

const filterMapE = (array, predicate, mapFn) => {
  const length = array.length;
  const result = [];
  for (let index = 0; index < length; index++) {
    const value = array[index];
    if (predicate(value, index, array)) {
      result.push(mapFn(value, result.length - 1));
    }
  }
  return result;
};

var checkBeforeClone = () => {
  filterMapA(
    merged,
    value => !!value,
    value => value,
  );
};

var justClone = () => {
  filterMapB(
    merged,
    value => !!value,
    value => value,
  );
};

var twoPass = () => {
  merged.filter(value => !!value).map(value => value);
};

var noCopy = () => {
  filterMapC(
    merged,
    value => !!value,
    value => value,
  );
};

var noCopy2 = () => {
  filterMapD(
    merged,
    value => !!value,
    value => value,
  );
};

var forLoopFilterMap = () => {
  filterMapE(
    merged,
    value => !!value,
    value => value,
  );
};
Run results for: fastest filter and map

base line

typeof before clone

just clone

two passes

no copy

no copy2

plain for loop
