10 ms·
Pedantic and what always happens when someone posts code on the internet, but, I'd extract the onClick function and provide a default value for the onclick para
by Cthulhu_ 6y ago
Pedantic and what always happens when someone posts code on the internet, but, I'd extract the onClick function and provide a default value for the onclick parameter for readability, and use cleverness to show off:
export const Counter = ({label, counterType, onClick}) => {
const [counter, setCounter] = useState(0);
onClick = onClick || () => {};
const handleClick = () => {
const modifier = counterType === "Increment" ? 1 : -1;
setCounter(counter + modifier);
onClick();
}
return (
<button onClick={handleClick}>
{label}: {counter}
</button>
);
}
There's another commenter that uses Typescript, but I believe PropTypes (https://www.npmjs.com/package/prop-types https://www.npmjs.com/package/prop-types) are still viable as well - although it moves the checking from compile-time to runtime. I do believe VS Code and co can interpret PropTypes to provide in-editor hints though. And JSDoc as well.
- Softcadbury 6y agoYou should also use useCallback for handleClick
- johnrackles 6y agoCan you explain why? I don't think I've ever used useCallback and certainly not for this type of functionality. I'd love to learn
- neolefty 6y agouseCallback memoizes (caches) the function definition. Its main use is to simplify refreshes — since the function isn't redefined every time, components that depend on it such as the <button> can be re-rendered less often. const handleClick = useCallback(() => { const modifier = counterType === "Increment" ? 1 : -1 setCounter(counter + modifier) onClick() }, [onClick, counter, counterType, modifier]) The array at the end is the list of "dependencies" — whenever one of them changes, the function is re-cached. Compiler checks can catch missing dependencies. You might think, "But that function will be redefined pretty much every time," and in this case that's true, and memoization may not help much. But in bigger trees of components, most redraws will be unrelated to any given element, so those dependencies will rarely change. useCallback() (and its twin useMemo(), for non-functional values) gets more useful in deeper component trees, where values may be passed down several levels.
- untog 6y agoI haven’t really dug into React since Hooks were announced and... wow. Am I reading correctly that you use useCallback to avoid redefining your callback function over and over again? The surface level ergonomics of JSC and the VDOM are great but good lord does it look painful at a second glance. I’m glad I took svelte for a spin.
- acemarke 6y agoNot in this example, no. There's zero benefit to memoizing a callback that's passed to a "leaf/host" element like a `<button`> See my extensive post "A (Mostly) Complete Guide to React Rendering) for details: https://blog.isquaredsoftware.com/2020/05/blogged-answers-a-mostly-complete-guide-to-react-rendering-behavior/ https://blog.isquaredsoftware.com/2020/05/blogged-answers-a-...