News for hackers. Stuff that matters.
Re:Advice on JSX Conditionals by eyelidlessness on Wednesday March 09, 2022 @02:51PM (#30619170)
Okay: only evaluates <Anything /> if someBool is true. The value of someBool quite literally controls which code path is taken. It’s even more clear with a fallback:

    { someBool && <Anything /> || <Fallback /> }
Which would more idiomatically be written as a ternary conditional, but still. It doesn’t matter where the expression is placed, it’s the same if you assign it to a variable:

    const el = someBool && <Anything /> || <Fallback />;
Or even just as an expression statement:

    someBool && <Anything /> || <Fallback />;
Re:Advice on JSX Conditionals by jameshart on Wednesday March 09, 2022 @05:27PM (#30620813)
But the short circuiting doesn’t matter.

You could go

   let x = <Anything />;
   return someBool && x;
And the result (assuming well behaved react code) would be the same. <Anything /> is just a literal expression. It doesn’t matter whether it gets evaluated or not.

You’re not using && shortcircuiting to prevent <Anything/> from being evaluated - it doesn’t matter if it gets evaluated. You are using it to decide which value to return.

This really isn’t ‘using shortcircuiting for control flow’. It’s just using && as an operator in an expression evaluation.

Re:Advice on JSX Conditionals by eyelidlessness on Wednesday March 09, 2022 @07:13PM (#30621696)
Edit: I read this back to myself and realized it may come off as harsh or mean. I don’t intend it as such, and I apologize if it’s received that way. I think being precise about this is worth pursuing, for the sake of both developers thinking about it and users experiencing what we build.

- - -

Of course it matters.

“Well behaved react code” isn’t side-effect free, as much as it tries hard to look almost like it is. You can write perfectly idiomatic components which follow all best practices, and evaluating a component when you don’t intend to use it will still:

1. Execute the code (duh), which at minimum uses CPU resources

2. Perform relevant hooks and call lifecycle methods, including those which have side effects (hint: “effect” is in the hook’s name, for this reason): starting timers, loading resources, calling non-React APIs, pretty much anything goes by design, even if you follow all the rules and other best practices.

3. Prepare for a new, potentially concurrent, render. This may speculatively interrupt/pause a render in progress which would otherwise complete without interruption. Which may, in turn, cause seemingly unrelated components to be called again, cascading this entire set of potential side effects to them, and so on.

4. Call any components in that cascade whether they’re well behaved in your control, or epic shit show dependencies.

Being in an expression position does not mean it’s side effect free. If you don’t believe me, run this code:

    const isPure = (value) => (
      value = 'NOPE',
      console.log('There is no code block in sight, this function has zero statements. Is it pure?', value),
      value
    );

    isPure('yeah?');
And sure, React and most JSX implementations are designed to make evaluating JSX side effects local as much as possible. But that’s limited because it’s exposed to APIs not under its control by design, first of all. And more importantly, I would hope that, on HN of all places, a knowable answer to a factual question “is code executed?” is not treated as subjective. This is the exact same question as “is it control flow?”
Re:Advice on JSX Conditionals by rimunroe on Wednesday March 09, 2022 @08:40PM (#30622290)
> 1. Execute the code (duh), which at minimum uses CPU resources

In this case it really is quite a minimum use of CPU, as React's createElement function doesn't do a whole lot. As far as I know, in a production build it's really just going to do a teeny amount of work to create an object (which looks like {type: Login, props: {}, /* ...some other properties */}). "Evaluating a component" isn't something the user ever does directly. The React runtime is the only thing which ever invokes a component's render method.

> 2. Perform relevant hooks and call lifecycle methods, including those which have side effects (hint: “effect” is in the hook’s name, for this reason): starting timers, loading resources, calling non-React APIs, pretty much anything goes by design, even if you follow all the rules and other best practices.

> 3. Prepare for a new, potentially concurrent, render. This may speculatively interrupt/pause a render in progress which would otherwise complete without interruption. Which may, in turn, cause seemingly unrelated components to be called again, cascading this entire set of potential side effects to them, and so on.

> 4. Call any components in that cascade whether they’re well behaved in your control, or epic shit show dependencies.

It won't do any of these things. React won't try to actually render a component (call its render function) unless an element referring to it ends up being returned by the render function of another component which gets rendered.

Re:Advice on JSX Conditionals by jameshart on Wednesday March 09, 2022 @08:57PM (#30622406)
I'm sorry, but you're just mistaken about how JSX works.

<Foo /> does not translate into a call to Foo(). It translates into React.createElement(Foo).

And Foo will only be called if the element returned from that call winds up being examined by some renderer like ReactDOM, mounted as a component, and actually rendered.

Here:

    function UnrenderedComponent() {
      console.log("UnrenderedComponent does not get executed");

      React.useEffect(() => {
        console.log("this effect never runs")
      });

      return "This won't get rendered"
    }

    function RenderedComponent() {
      console.log("Rendered Component running")

      React.useEffect(() => {
        console.log("this effect runs")
      });

      const x = <UnrenderedComponent/>;

      return "This will get rendered";
    }


    ReactDOM.render(
      <RenderedComponent />,
      document.getElementById('container')
    );

I'll save you copy/pasting - here's a jsFiddle: https://jsfiddle.net/gr4kxq81/

That code unconditionally includes the evaluation of <UnrenderedComponent/> in the context of a render method.

But the UnrenderedComponent() function does not get called, its useEffect call never happens, its effect code never gets executed, because the resulting element doesn't make its way back to ReactDOM to be mounted.

someBoolean && <MyComponent/> is not control flow, it's a simple expression that conditionally evaluates to an instruction to either not render anything, or to mount and render a MyComponent. It's cheap and side effect free.

My comment about 'assuming well behaved React code' was more directed at the fact that technically you can plug in a custom JSX pragma so you might not just be handing it to React.createElement, in which case all bets are off for what happens. But React doesn't call render methods for components unless they're mounted.

Re:Advice on JSX Conditionals by eyelidlessness on Wednesday March 09, 2022 @11:21PM (#30623192)
> I'm sorry, but you're just mistaken about how JSX works.

No, I’m not. JSX doesn’t do anything. But it’s an expression and evaluated according to the rules of JS expressions. You might expect React or whatever to evaluate it one way today, and it can be evaluated another way tomorrow. React.createElement isn’t the API you’re using, neither is react/jsx-runtime. You’re using an expression with some special angle brackets and curly braces. You have no idea if your component is being called, but semantically you have every reason to believe it is and will be.

Bool && otherExpression is control flow because it’s specifically defined as an expression in the host language. Anything else is assuming compiler magic you were never promised.

Re:Advice on JSX Conditionals by jameshart on Thursday March 10, 2022 @08:06AM (#30626455)
You said that “evaluating a component when you don’t intend to use it” will do a bunch of things which React manifestly doesn’t do. I shared a link to some code you can run that demonstrates this. The question of whether or not some code gets executed is, as you said, knowable.

But you are, I think, retreating to a position that, because the JavaScript && operator shortcircuits (ie does not evaluate the second operand of the first operand is truthy) it is always a control flow - a point which I can sort of agree with, but which I think is just a weak position, since it doesn’t help us make decisions about what code is good or bad.

Because if we back up to the top of the thread the point being raised was that use of && for conditionals in react feels like using && to perform control flow, and that is idiomatically bad JS.

But you can’t have it both ways - if using && for control flow is bad and && is always a control flow operation then every use of it is bad. But if there are some times where && use is good, then there must be cases where using &&, even though it shortcircuits, does not count as using it for evil control flow.

But even in simple idiomatic JavaScript we rely on && shortcircuiting for good and valuable purposes like nullsafety:

   if (person !== null && person.name === ‘foo’)
So is that using && for control flow, which is bad?

What about here?

   return person && person.name;
Or

   return person && `Name: ${person.name}`;
.. or even

   return person && <Person name={person.name}/>
(Notice what I’m guarding against here is not against incorrect evaluation of the Person control - I’m guarding against incorrect evaluation of one of its parameters)

My position is, && shortcircuiting is a feature and you can use it as such, but if your code relies in a nonobvious way on the shortcircuiting behavior for correctness, then you are using && as a control flow tool, and you have made it brittle, harder to refactor, and harder to parse.

But if your code would still be correct even if JavaScript did not guarantee that it would not evaluate the second parameter if the first was truthy, then you’re not even relying on shortcircuiting, and using && is clean and valid.

And since JSX literals in react are really just shorthand for a special kind of object literal, and in general therefore it doesn’t matter if they are evaluated or not, I take the position that using them within JS && expressions is legitimate, and not an abuse of && to perform complex control flow.

Re:Advice on JSX Conditionals by eyelidlessness on Thursday March 10, 2022 @11:52AM (#30629081)
> But you are, I think, retreating to a position that, because the JavaScript && operator shortcircuits (ie does not evaluate the second operand of the first operand is truthy) it is always a control flow

I’m not retreating to anything. This was my only point and I explicitly said so.

> a point which I can sort of agree with, but which I think is just a weak position, since it doesn’t help us make decisions about what code is good or bad.

I’m not trying to change the world with the point. Just to establish the basic fact.

Re:Advice on JSX Conditionals by 9wzYQbTYsAIc on Wednesday March 09, 2022 @03:19PM (#30619449)
> It doesn’t matter where the expression is placed, it’s the same if you assign it to a variable

If you separate the concern of the condition definition from the conditional rendering, by pulling the conditional’s definition into a variable, you do get enhanced portability, though.

Much easier to port between languages and frameworks if your conditional definition can be copy-and-pasted out without having to mess with untwining the previous developers expression statements.

Re:Advice on JSX Conditionals by eyelidlessness on Wednesday March 09, 2022 @05:01PM (#30620559)
I’m not sure whether I agree or disagree with this. But I do want to clarify that my intent was not to argue for or against conditional expressions in any code position, only to address the factual question of whether they constitute control flow.