Reducing array , modifying the accumulator

Question

Is this way of reducing an array (counting occurrences) not recommended? I mean modifying the accumulator is maybe bad?

function countOccurrencesReduceOwn(array, searchElement) //seems to work but is maybe not recommended ?
  {
    const count = array.reduce((accumulator, currentValue) => {
      if(currentValue === searchElement)
      {
        accumulator++; //do not do this?
      }  
      return accumulator; 
    }, 0);
    return count;
  }

Another similar is the following code which does not work. It's meant for getting the largest value of the array.

function getMaxReduceOwn(array) //does not work 
  {
    if(array.length<=0)
    {
      return undefined;
    }
    const largest = array.reduce((largest, currentValue) => { 
      if(currentValue > largest)
      {  
        largest =currentValue; //do not do this?
      }
      return largest;
    }, array[0]);
  }

Answer 1

Yes, this is unusual. Apart from "modifying parameters", reduce comes from functional programming where mutable variable are despised. You should rather simply return a new value:

const count = array.reduce((accumulator, currentValue) => {
  if (currentValue === searchElement) return accumulator + 1;
  else return accumulator; 
}, 0);

const largest = array.reduce((largest, currentValue) => { 
  if (currentValue > largest) return currentValue;
  else return largest;
});

If you were to reassign the accumulator variable, there's no reason to use the reduce method at all, you could simply write a normal for loop to the same effect, which would be shorter and more idiomatic than the unusal reduce:

let count = 0;
for (const currentValue of array) {
  if(currentValue === searchElement) {
    count++;
  }
}
return count;

if (array.length <= 0) {
  return undefined;
}
let largest = array[0];
for (const currentValue of array.slice(1)) {
  if (currentValue > largest) {  
    largest = currentValue;
  }
}
return largest;