Changing the reference of a js function's argument

Question

Lately I write react-redux apps and as a react developer I write pure, functional and predictable code. Even though I do like the experience I've got a doubt whether my code is still handsome or not.

So I have a tree in my state and I need to update a bunch of nodes in the tree. Let's say the tree's API provides a pure method pureUpdate(path, newNode, tree) => newTree which return new tree with the node updated. In ths case my reducer method might look like

function updateNodes(tree, updateRules) {
    updateRules.forEach(updateRule => {
        const { path, node } = updateRule;
        tree = pureUpdate(path, node, tree);
    });
    return tree;
}

But I'm not sure if it's the best could be done.

The first thing which looks nasty is tree = pureUpdate(path, node, tree); . It looks like mutating a parameter, which is discouraged, but I am just reassigning the reference, ain't I? It's explained here in the second part of the answer. But although this trick might be ok, in this discussion said that such code might be unoptimized and reassigning parameters might cause performance issues ( more info with examples ). The simplest fix occured to me is to use an extra variable which will be a clone of the tree.

function updateNodes(tree, updateRules) {
    let newTree = someCloneFunc(tree);
    updateRules.forEach(updateRule => {
        const { path, node } = updateRule;
        newTree = pureUpdate(path, node, newTree);
    });
    return newTree;
}

The question is if I don't miss anything and my code is still pure, handsome and will not cause any issues.

Answer 1

If you're at all concerned about performance, I would not clone tree just to avoid reassigning a parameter.

While you can use forEach here and reassign the parameter, reduce is the correct functional abstraction for your use case, and it's generally a better and more useful abstraction than forEach since it can (and should) be used purely, whereas forEach is always about side effects.

A solution based on reduce makes the question of whether or not to clone and or reassign a function parameter completely moot, as well.

Here's a working reduce solution - no parameter reassignment, no forEach side effects and no reason to clone tree :

const updateNodes = (tree, updateRules) =>
  updateRules.reduce(
    (acc, { path, node }) => pureUpdate(path, node, acc),
    tree // initialize acc (the accumulator)
  )