4 ms·

Push returns the length of the array, though, so that won't work.

ReleaseCandidat 5y ago
Ah, sorry, so you have to concat the arrays using `concat`. [1, 2, 3, 4, 5].reduce((acc, n) => n % 2 === 1 ? acc.concat([2*n]) : acc, [])
- spiralx 5y ago
  Surely the spread operator is nicer here? [1, 2, 3, 4, 5].reduce((acc, n) => n % 2 === 1 ? [ ...acc, 2 * n ] : acc, [])
  - v413 5y ago
    This is not efficient. Each iteration creates a new array instance due to the spread operator.
    - spiralx 5y ago
      `acc.concat()` also creates a new array instance, so I don't get your point.
- jasonkillian 5y ago
  Wouldn't recommend doing this - if the original array is of significant length this'll get quite slow because `acc.concat` has to create a brand new array of slightly longer length on each iteration it's called. Better to just use `push` like you suggested before and then return the array if you want to use `reduce`.
  - ReleaseCandidat 5y ago
    Yes, of course, that's why I used `push` at first.
    - jacobolus 5y ago
      Use the comma operator: (acc.push(2*n), acc) will return acc. Or e.g. [1, 2, 3, 4, 5].reduce((acc, n) => (n % 2 ? acc.push(2*n) : null, acc), [])
      - wk_end 5y ago
        If you're just iterating through the array and mutating an object on each iteration, just use a for loop.
        jacobolus 5y ago
        Obviously you can alternately write: let input = [1, 2, 3, 4, 5], output = []; for (let i = 0; i < input.length; ++i) { let n = input[i]; if (n % 2) output.push(2*n); } return output; But in some circumstances the other style can be more convenient / legible. The immediate question was about pushing to an array and then returning the array, for which the comma operator can be handy.
        wk_end 5y ago
        No argument that the comma operator is a neat trick when you need it. FWIW, it's 2022: const output = []; for (const n of [1, 2, 3, 4, 5]) { if (n % 2) output.push(2 * n); }
        eyelidlessness 5y ago
        Minority opinion: please `let` your mutable references. I know `const` doesn’t signal immutability, but we as humans with eyeballs and limited attention span certainly benefit from knowing when a value might change at runtime.
        wk_end 5y ago
        Disagree: virtually everything in JS is mutable, so this almost means "never use the `const` keyword". Pretending that the `const` keyword means something that it doesn't makes things harder for my limited human mind to understand, not easier. Plus using `let` inappropriately makes my linter yells at me, and I usually like to just do whatever my linter tells me. Anyway, I use TypeScript, so if I really want to assert that my array is immutable (as immutable as stuff in JS-land gets anyway) I just write: const input: readonly number[] = [1, 2, 3, 4, 5]; or even const input = [1, 2, 3, 4, 5] as const;
eyelidlessness 5y ago
Comma operator to the rescue: (acc.push(2*n), acc) In an expression position, the push statement will be executed, then its return will be discarded, and the final expression will be the result of the expression. Is it “better”? Almost certainly not. But it lets you stay in expression syntax while executing statements. (Much more useful for logging than meaningful runtime side effects IMO, but I think it should be more widely known in general.) Edit: and I’m glad to see another reference to it down thread!

Ah, sorry, so you have to concat the arrays using `concat`. [1, 2, 3, 4, 5].reduce((acc, n) => n % 2 === 1 ? acc.concat([2*n]) : acc, [])

spiralx 5y ago
Surely the spread operator is nicer here? [1, 2, 3, 4, 5].reduce((acc, n) => n % 2 === 1 ? [ ...acc, 2 * n ] : acc, [])
- v413 5y ago
  This is not efficient. Each iteration creates a new array instance due to the spread operator.
  - spiralx 5y ago
    `acc.concat()` also creates a new array instance, so I don't get your point.
jasonkillian 5y ago
Wouldn't recommend doing this - if the original array is of significant length this'll get quite slow because `acc.concat` has to create a brand new array of slightly longer length on each iteration it's called. Better to just use `push` like you suggested before and then return the array if you want to use `reduce`.
- ReleaseCandidat 5y ago
  Yes, of course, that's why I used `push` at first.
  - jacobolus 5y ago
    Use the comma operator: (acc.push(2*n), acc) will return acc. Or e.g. [1, 2, 3, 4, 5].reduce((acc, n) => (n % 2 ? acc.push(2*n) : null, acc), [])
    - wk_end 5y ago
      If you're just iterating through the array and mutating an object on each iteration, just use a for loop.
      - jacobolus 5y ago
        Obviously you can alternately write: let input = [1, 2, 3, 4, 5], output = []; for (let i = 0; i < input.length; ++i) { let n = input[i]; if (n % 2) output.push(2*n); } return output; But in some circumstances the other style can be more convenient / legible. The immediate question was about pushing to an array and then returning the array, for which the comma operator can be handy.
        wk_end 5y ago
        No argument that the comma operator is a neat trick when you need it. FWIW, it's 2022: const output = []; for (const n of [1, 2, 3, 4, 5]) { if (n % 2) output.push(2 * n); }
        eyelidlessness 5y ago
        Minority opinion: please `let` your mutable references. I know `const` doesn’t signal immutability, but we as humans with eyeballs and limited attention span certainly benefit from knowing when a value might change at runtime.
        wk_end 5y ago
        Disagree: virtually everything in JS is mutable, so this almost means "never use the `const` keyword". Pretending that the `const` keyword means something that it doesn't makes things harder for my limited human mind to understand, not easier. Plus using `let` inappropriately makes my linter yells at me, and I usually like to just do whatever my linter tells me. Anyway, I use TypeScript, so if I really want to assert that my array is immutable (as immutable as stuff in JS-land gets anyway) I just write: const input: readonly number[] = [1, 2, 3, 4, 5]; or even const input = [1, 2, 3, 4, 5] as const;

eyelidlessness 5y ago

Comma operator to the rescue: (acc.push(2*n), acc) In an expression position, the push statement will be executed, then its return will be discarded, and the final expression will be the result of the expression. Is it “better”? Almost certainly not. But it lets you stay in expression syntax while executing statements. (Much more useful for logging than meaningful runtime side effects IMO, but I think it should be more widely known in general.) Edit: and I’m glad to see another reference to it down thread!