return count + 1 vs. return count++

Agree. Neil, my answer didn't really cover the issue - that's me skim-reading as usual!!

I think this might be to do with the use of two return statements. If you code this with one return, as I normally would (I don't use node or js, though!), and just return the value of count at the end, then this behaves how I would expect:

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    count + 1;
  }
  return count;
}, 0);

This returns zero as the value held in count is never altered, so we get the specified initial value of zero, whereas:

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    count++;
  }
  return count;
}, 0);

... returns 4 as we are modifying the value in count with the increment operator, then returning that value at the end.

In this next example, maybe count is an accumulator picking up the returned value on each iteration, perhaps? Thus it would add one (initial value + 1) on each iteration of a letter starting with 'G', storing that in count as an accumulator? A letter not starting with 'G' would 'accumulate' a zero (the initial value) and thus not affect adversely what we would expect to see.

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    return count + 1;
  }
  return count;
}, 0);

But, I don't understand why using return count++ produces, specifically, zero. I would expect it to mess with the loop, perhaps, and maybe generate unexpected results - but not zero. It is as if the reduce function is just not working?!

This doesn't work in my mind:

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    return count++;
  }
  return count;
}, 0);

I can understand this creating odd results, as if we're accumulating G's but adding one to count, the first 'G' would correctly accumulate a 1, but the second would accumulate a 2, the third a 3 etc. Thus we'd get a large number output at the end. But we don't see this - we get, consistently, a zero.

I did some logging - this works very nearly as we would expect:

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    console.log(count++)
    return count;
  }
  return count;
}, 0);

console.log(gNameCount);

I'm logging the value of count at each iteration. I get this output:

treehouse:~/workspace$ node iteration.js                                                         
0                                                                                                
1                                                                                                
2                                                                                                
3                                                                                                
4                                                                                                
5                                                                                                

But that's not right, is it? (although it has fixed the code - which now outputs the right number - I've added an extra 'G' name in the array, hence a 5). Why aren't there two 5s at the end, one mid-code and then the final output from the console.log underneath the method? And how come this works all of a sudden? That got me thinking about timing of the increment. I think that return count++; returns count then increments it. But that change is lost so count remains as zero, the change isn't included in the returned value, as it is returned first, so that change is dropped. I tested this theory with this:

const gNameCount = names.reduce((count, name) => {
  if (name[0] === 'G'){
    console.log(count)
    return ++count;
  }
  return count;
}, 0);

This increments count first by using the increment operator before the variable, and so the change is persisted into the next iteration. This works and solves your problems and answers your question! The reason your were getting zero was because the increment operator hadn't operated by the time the value was returned so the increment never happened. You need to increment with a preceding ++ operator to persist that change - i.e. to return an updated value for count.

The act of returning the value of count must update its value within the reduce method. The use of either + 1 or ++ is irrelevant - it just wants to know what value to store. The count++ method doesn't work as the increment is too late so using either a preceding ++ or just sending back count + 1 is sufficient to update the value held within the iteration.

So, apologies for a few things - 1. the initial nonsense answer I gave back in November, 2. the thought-process post presented here; I literally typed this as I tested!

I hope this now answers the question and I am redeemed.

Your thoughts are welcomed!

Steve.