blog/no-love-for-boolean-parameters

[utterances-bot]

No love for boolean parameters | TkDodo's blog

Innocent looking boolean parameters, or flags, are often the reason for hard to maintain legacy code. Resist the urge of adding them!

https://tkdodo.eu/blog/no-love-for-boolean-parameters

[CalebLovell]

This is great advice. I am totally guilty of that button use case. Gonna go change that right now to variant instead! Thanks!!

[p6l-richard]

Very nice article. It inspired me to rethink table components in react as I've often come across table with an isLoading prop.
Thanks to your article, I now prefer:

<PostsTable
        posts={data}
        setFilters={setFilters}
        columns={columns}
        status={tableStatus}
      />

import {FancyTableHeaders} from "./headers";

interface FancyTableProps {
	status: "success" | "empty" | "error" | "loading" | "idle";
}
function FancyTable ({status}: FancyTableProps) {
	
	return (
    <table>
      <FancyTableHeaders
        variant={status === "success" ? "enabled" : "disabled"}
      />
      <tbody>
			 {/* ✅ little extra boilerplate */}
       {/* ✅ clear conditional rendering */}        
			 {
          {
            success: <PostsTableBody rows={rows} prepareRow={prepareRow} />,
            empty: <EmptyTableBody />,
            error: <ErrorTableBody />,
            loading: <LoadingTableBody />,
            idle: <IdleTableBody />
          }[status]
        }
      </tbody>
    </table>
  );
}

[p6l-richard]

I couldn't find the edit comment option, so:

[eusousalvi]

Really nice article! The only change I would do is change this switch to a object, but it's only a opinion. I think is more readable and clean:

const variants = {
    percent: (value: number): string => `${value}%`, 
    currency: (value: number): string => `ur method - R$${value}` , 
    standard: (value: number): string => String(value) 
}

function formatMetric(
  value: number,
  variant: keyof typeof variants = 'standard'
): string {
  return variants[variant](value);
}

What do you think?

[TkDodo]

@eusousalvi yes, that's another way, and it nicely ties together types (keyof typeof variants) and the implementation. This works best if you can actually derive the type from there, which might not work if the types are defined somewhere else (in a contract or so). Then, you have to make sure that variants conforms to that, but the differences are really minor :)

[ctrlx-altf4]

Thank you so much for this article. I had a lot of "oh" moments as i read the article. Very insightful