Functional programming on nested arrays

Question

I'm trying to do more and more functional programming instead of imperative programming.

Let's say I have a nested array data structure and I want to change the values of the deeper inner array, what would be the best way to do it?

Imperative code to transform:

for (let i = 0; i < dataSheet.length; i++) {
    for (let j = 0; j < dataSheet[i].questions.length; j++) {
        for (let k = 0; k < dataSheet[i].questions[j].answers.length; k++) {
            dataSheet[i].questions[j].answers[k].name += ' (edited name)';
            dataSheet[i].questions[j].answers[k].value = 1 + dataSheet[i].questions[j].answers[k].value / 10;
        }
    }
}

I came up with two ways of doing it:

With map():

dataSheet
.map(section => section.questions
    .map(question => question.answers
        .map(answer => (
            {
                ...answer,
                name: answer.name + ' (edited name)',
                value: 1 + (answer.y / 10),
            }),
        ),
    ),
);

With forEach():

dataSheet.forEach(section => section.questions
    .forEach(question => question.answers
        .forEach(answer => (
            {
                ...answer,
                name: answer.name + ' (edited name)',
                value: 1 + (answer.y / 10),
            }),
        ),
    ),
);

All 3 do the same things, but none of them really look better. It does not look better, especially because of the pyramid of doom... And it could be even worse if I had deeper nested arrays.

Going from imperative to functional does not make the code much clearer/readable/maintainable in this case and it is probably slower since it will create a new copy for every object modified.

Hence, in this scenario, do you think it will be better to keep the code in a imperative way? Or is there better way to do it?

you may decide first, if you like to change just the most inner item or return whole new arrays. btw the lasat makes no sense, because the return value does not return (outside of the callback). — Nina Scholz
– Nina Scholz, Commented Sep 19, 2017 at 6:38
I don't think the forEach code would do what the original, nor the .map code does — Jaromanda X
– Jaromanda X, Commented Sep 19, 2017 at 6:54
Usually you would use functional lenses. Lenses treat your nested arrays as if they were persistent data structures. But JS is essentially an impure language (it includes functional parts though). So you need an appropriate lib for this, unless you are willing to implement it all by hand. I would recommend Ramda, as it is great for starters. — user6445533
– user6445533, Commented Sep 19, 2017 at 7:57

Alexandros Panagiotakis · Accepted Answer · 2017-09-22 14:02:51Z

Going from imperative to functional does not make the code much clearer/readable/maintainable in this case and it is probably slower since it will create a new copy for every object modified.

I would argue that

.map(answer => [code block])

is more readable than

for (let k = 0; k < dataSheet[i].questions[j].answers.length; k++) [code block]

Although you do not get to eliminate nesting with your map example you get a lot of benefits that make your code more maintainable.

You do not get to mess with the i,j,k.. variables and introduce bugs.
You get purity and that is "the" big reason to do functional programming. The map may be slower for this simple case but with this way you allow your input to be immutable and be used/stored elsewhere while preserving integrity.

(forEach would not work because it doesn't return anything)

I would suggest you use the functional way, since you do not get any advantages with the imperative one except for a trivial amount of performance.

Collectives™ on Stack Overflow

Functional programming on nested arrays

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related