4 ms·

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 sl

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
        I realize I could be clearer in what I’m asking for: please use const when you use reference types as values, and use let when you intend to mutate the reference. Using const and then changing a value is certainly allowed but it’s confusing and it’s missing an opportunity to signal in the code where changes might happen.
        eyelidlessness 5y ago
        I `readonly` and `as const` everything I possibly can. I do know that const doesn’t mean immutable, as I said, but I think it should and I think there’s value in establishing the idiom even if it’s not currently adopted. Because otherwise const basically means nothing unless you’re mutating everything already.

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
        I realize I could be clearer in what I’m asking for: please use const when you use reference types as values, and use let when you intend to mutate the reference. Using const and then changing a value is certainly allowed but it’s confusing and it’s missing an opportunity to signal in the code where changes might happen.
        eyelidlessness 5y ago
        I `readonly` and `as const` everything I possibly can. I do know that const doesn’t mean immutable, as I said, but I think it should and I think there’s value in establishing the idiom even if it’s not currently adopted. Because otherwise const basically means nothing unless you’re mutating everything already.