<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Samuel Nakazawa on Medium]]></title>
        <description><![CDATA[Stories by Samuel Nakazawa on Medium]]></description>
        <link>https://medium.com/@samuelnakazawa895?source=rss-682339587106------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*b_RK_ZQdxxxKzhYe0DXM9A.jpeg</url>
            <title>Stories by Samuel Nakazawa on Medium</title>
            <link>https://medium.com/@samuelnakazawa895?source=rss-682339587106------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:31:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@samuelnakazawa895/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Reducing Complexity and Improving Performance with React and Basic Algorithm Concepts]]></title>
            <link>https://medium.com/@samuelnakazawa895/reducing-complexity-and-improving-performance-with-react-and-basic-algorithm-concepts-3f46249083e7?source=rss-682339587106------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f46249083e7</guid>
            <category><![CDATA[big-o-notation]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Samuel Nakazawa]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 19:13:18 GMT</pubDate>
            <atom:updated>2026-10-23T19:13:18.724Z</atom:updated>
            <content:encoded><![CDATA[<p>In day-to-day frontend work, it’s common to run into problems with performance and resource consumption. In this article, we’ll talk about algorithm complexity (and a bit of React) with a practical focus, and how this knowledge can help you solve hard problems in a simpler way.</p><h3>What Is Complexity and Why Should You Care?</h3><p>An algorithm’s complexity tells us how much time or how many resources it will consume as the amount of data grows. A common example is code that ran fine with a few elements but became slow once the data volume increased.</p><p>It’s like comparing an elevator and a staircase: both get you to the 10th floor, but one does it with far less effort. In code the idea is the same: we always want the most efficient solution.</p><p>Below are some practical examples of how different complexities affect our applications.</p><h3>O(1): Constant Complexity</h3><p>This is the ideal complexity. No matter the size of the input, the operation always takes the same amount of time. A classic example is accessing a specific item in an array by its index (array[index]). Another common case is checking whether an item exists in a Set or Map, which usually takes constant time.</p><h3>O(log n): Logarithmic Complexity</h3><p>When we need to find an item in a sorted list, we can use efficient strategies like binary search, which cuts the search space in half on each iteration. Balanced trees are another example of a structure that guarantees operations with this complexity.</p><h3>O(n): Linear Complexity</h3><p>Many common JavaScript methods fall into this category. Functions like .map(), .filter(), .find() and .forEach() go through an entire array, doing some work on each element. If the array has n elements, the running time grows in proportion to n.</p><h3>O(n log n): Linearithmic Complexity</h3><p>The most efficient general-purpose sorting algorithms, like QuickSort and MergeSort, run in this complexity. JavaScript’s .sort() method, for example, is built on one of these approaches. This is the best we can do when sorting data in the general case.</p><h3>O(n²): Quadratic Complexity</h3><p>If you’ve ever had to compare every element of an array against every other one, you’ve run into a quadratic problem. A classic example is looking for duplicate pairs without using a Set. For each element, we go through all the others, so the running time is proportional to n².</p><h3>O(2ⁿ): Exponential Complexity</h3><p>This is where problems quickly become impractical for large inputs. Algorithms with excessive recursion, like the naive solution for the Fibonacci sequence, are typical examples of exponential complexity. As n grows, the running time doubles with each step, which makes this approach unworkable for large values.</p><h3>O(n!): Factorial Complexity</h3><p>This level of complexity shows up in problems where we need to consider every possible permutation of a set of elements. A practical example would be generating every possible ordering of the items in a navigation menu, which quickly becomes impossible to compute as the number of items grows.</p><h3>How to Calculate Complexity Without the Pain</h3><p>A practical way to understand complexity is to look at how many times a piece of code repeats certain operations. The more repetitions, the higher the cost.</p><h3>1. Identify the Loops</h3><p>Most bottlenecks come from loops. Say you have a loop that goes through a list of n elements:</p><pre>for (let i = 0; i &lt; n; i++) {<br>  console.log(i);<br>}</pre><p>The code runs n times. In Big O notation, we say it has O(n) (linear) complexity.</p><p>Now let’s look at nested loops:</p><pre>for (let i = 0; i &lt; n; i++) {<br>  // The outer loop runs &#39;n&#39; times<br>  for (let j = 0; j &lt; n; j++) {<br>    // The inner loop runs &#39;n&#39; times<br>    // for each iteration of the outer loop<br>    console.log(i, j);<br>  }<br>}</pre><p>Here, the inner loop runs n times for every iteration of the outer loop, for a total of n * n = n² operations. The complexity becomes O(n²) (quadratic), which grows much faster than the previous one.</p><h3>2. The Power of O(log n)</h3><p>We don’t always need to go through every element of a data structure. In many cases, we can drastically reduce the number of operations with techniques like divide and conquer. A real example in frontend development is list virtualization. When we render a long list in React, instead of showing all the items at once, we can use libraries like react-window or react-virtualized, which render only the items visible on screen and improve performance a lot.</p><p>Binary search is a classic O(log n) case:</p><pre>function binarySearch(arr, target) {<br>  let left = 0;<br>  let right = arr.length - 1;</pre><pre>  while (left &lt;= right) {<br>    let mid = Math.floor((left + right) / 2);<br>    if (arr[mid] === target) return mid;<br>    if (arr[mid] &lt; target) left = mid + 1;<br>    else right = mid - 1;<br>  }<br>  return -1;<br>}</pre><p>On each iteration, we cut the search space in half. This makes binary search run much faster than a linear search, especially with large amounts of data.</p><p>Think about looking up a name in a phone book. Instead of flipping through it page by page [O(n)], you open it in the middle and look only at the half that contains the name, without ever touching the other half. That’s the impact of O(log n).</p><h3>3. Drop the Details That Don’t Matter</h3><p>Suppose we have something like this:</p><pre>for (let i = 0; i &lt; n; i++) {<br>  for (let j = 0; j &lt; n; j++) {<br>    for (let k = 0; k &lt; 10; k++) {<br>      console.log(i, j, k);<br>    }<br>  }<br>}</pre><p>We can simplify the analysis. The last loop always runs 10 times, regardless of n, so that number is a constant and can be ignored. What matters are the two main loops, which perform n * n = n² operations. The complexity is still O(n²).</p><h3>Improvements with useMemo and useCallback</h3><p>useMemo and useCallback are very handy React hooks when the goal is to optimize performance and avoid unnecessary renders or calculations. They can help a lot, but they should be used with care.</p><h3>useMemo</h3><p>useMemo memoizes the value returned by a function so it isn’t recalculated on every render. This is useful when we have expensive calculations, or when we pass objects or arrays as dependencies to child components and want to avoid recreating them on every render.</p><p>For example, if we have a filtering function that is expensive to run:</p><pre>const filteredList = useMemo(() =&gt; {<br>  return list.filter(item =&gt; item.includes(search));<br>}, [search, list]);</pre><p>In this case, the filter only runs again when search or list change, which avoids unnecessary calculations.</p><h3>useCallback</h3><p>useCallback is similar to useMemo, but instead of memoizing a value, it memoizes the function itself. This is useful when we pass functions as props to child components and want to avoid recreating them on every render.</p><p>For example, in a component with a click handler:</p><pre>const handleClick = useCallback(() =&gt; {<br>  console.log(&#39;Button clicked!&#39;);<br>}, []);</pre><p>Here, the handleClick function isn’t recreated on every render, which can prevent unnecessary re-renders in child components.</p><h3>When Do These Hooks Hurt More Than They Help?</h3><p>Although useMemo and useCallback can be very useful, they can also cause problems when misused. The main risk is using them to optimize very cheap operations, like a simple multiplication or addition, where the cost of memoizing can be higher than the benefit of skipping a trivial calculation.</p><h3>An unnecessary useMemo</h3><pre>const valueWithTax = useMemo(() =&gt; price * 1.1, [price]);</pre><p>Multiplication is a cheap operation. This useMemo only adds complexity with no real benefit.</p><p>Another case where useMemo can backfire is when its dependency changes very often. If a value is recalculated constantly, useMemo can end up creating more work for React, which has to keep track of memoized values that are thrown away right away.</p><h3>A useMemo done right</h3><pre>const filteredList = useMemo(() =&gt; {<br>  return list.filter(item =&gt; item.includes(search));<br>}, [search, list]);</pre><p>Now the filter only runs again when search or list change, which avoids unnecessary calculations.</p><h3>An unnecessary useCallback</h3><p>Imagine a simple component, like a button that increments a counter. useCallback is applied to the click handler, but the function is simple and performance wouldn’t be affected either way. Here, useCallback only adds needless complexity.</p><pre>import React, { useState, useCallback } from &#39;react&#39;;</pre><pre>const Counter = () =&gt; {<br>  const [count, setCount] = useState(0);</pre><pre>  // Unnecessary useCallback<br>  const increment = useCallback(() =&gt; {<br>    setCount(prev =&gt; prev + 1);<br>  }, []); // The dependency array is empty,<br>          // so the function never changes</pre><pre>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;Count: {count}&lt;/p&gt;<br>      &lt;button onClick={increment}&gt;Increment&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>};</pre><pre>export default Counter;</pre><h3>Why is useCallback unnecessary here?</h3><p><strong>Needless cost:</strong> useCallback memoizes the increment function so it isn’t recreated on every render. But the function is very simple and has no meaningful impact on performance. Recreating it on every render is not a performance problem.</p><p><strong>Extra complexity:</strong> In this case, useCallback only makes the code more complicated without any benefit. React is already efficient enough at re-rendering the component, and increment is not an expensive calculation that justifies memoization.</p><h3>A better approach</h3><p>Here, we don’t need useCallback at all. The code is simpler and more readable without it:</p><pre>import React, { useState } from &#39;react&#39;;</pre><pre>const Counter = () =&gt; {<br>  const [count, setCount] = useState(0);</pre><pre>  const increment = () =&gt; {<br>    setCount(prev =&gt; prev + 1);<br>  };</pre><pre>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;Count: {count}&lt;/p&gt;<br>      &lt;button onClick={increment}&gt;Increment&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>};</pre><pre>export default Counter;</pre><p>useCallback is useful when you need to avoid recreating functions in components that re-render often, especially when you pass those functions as props to child components that depend on a stable reference to avoid unnecessary renders. But when it’s applied to simple functions with no real performance impact, it can end up doing more harm than good by adding complexity with no performance gain.</p><h3>How to Spot Room for Improvement and Optimize Your Code</h3><ul><li><strong>Check for unnecessary loops:</strong> Sometimes a map or filter can be replaced by a more efficient structure.</li><li><strong>Look at your React state:</strong> Not everything needs to live in useState. Keeping less there can reduce re-renders.</li><li><strong>Avoid repeated calculations:</strong> Whenever a calculation is heavy and its result can be saved, consider whether memoization makes sense.</li><li><strong>Prefer algorithmic solutions over more dependencies:</strong> Often, a good algorithm saves you from adding a new library.</li></ul><h3>References for Going Deeper</h3><ul><li><a href="https://www.bigocheatsheet.com/">Big-O Cheat Sheet</a>: a quick guide to algorithm complexity.</li><li><a href="https://visualgo.net/">VisuAlgo</a>: an interactive site for visualizing algorithms.</li><li><a href="https://cs50.harvard.edu/">CS50 Harvard</a>: a free course that covers data structures and complexity.</li><li><a href="https://developer.mozilla.org/en-US/docs/Web/Performance">MDN, Performance</a>: Mozilla’s guide to web performance and optimization.</li><li><a href="https://react.dev/reference/react/useCallback">React Docs: useCallback</a>: the official React documentation for useCallback.</li><li><a href="https://react.dev/reference/react/useMemo">React Docs: useMemo</a>: the official React documentation for useMemo.</li></ul><p>If you enjoyed this, share it with your colleagues and let’s write more performant code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f46249083e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Reduzindo Complexidade e Melhorando Performance com React e Conceitos Básicos de Algoritmo]]></title>
            <link>https://medium.com/@samuelnakazawa895/reduzindo-complexidade-e-melhorando-performance-com-react-e-conceitos-b%C3%A1sicos-de-algoritmo-1e57f49e5de1?source=rss-682339587106------2</link>
            <guid isPermaLink="false">https://medium.com/p/1e57f49e5de1</guid>
            <category><![CDATA[tips]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[big-o-notation]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Samuel Nakazawa]]></dc:creator>
            <pubDate>Tue, 18 Mar 2025 00:36:22 GMT</pubDate>
            <atom:updated>2025-03-18T01:02:14.167Z</atom:updated>
            <content:encoded><![CDATA[<p>No dia a dia do frontend, é comum que nos deparemos com problemas relacionados a performance e consumo de recursos. Neste artigo, vamos falar sobre complexidade de algoritmos (e um pouco de React), voltado a pratica e como esse conhecimento pode te ajudar a resolver problemas complexos de uma forma mais simples.</p><h3>O que é Complexidade e por que se importar?</h3><p>A complexidade de um algoritmo nos diz <strong>quanto tempo</strong> ou <strong>quantos recursos</strong> ele vai consumir conforme a quantidade de dados aumenta. Um exemplo disso é um código que rodava bem com poucos elementos, mas ficou lento quando o volume de dados cresceu.</p><p>É como comparar um elevador e uma escada: ambos levam você ao 10º andar, mas um faz isso com muito menos esforço. No código, a ideia é a mesma: queremos sempre a solução mais eficiente.</p><p>Abaixo, vamos ver alguns exemplos práticos que ilustram como diferentes complexidades afetam nossas aplicações.</p><h3>O(1) — Complexidade Constante</h3><p>Essa é a complexidade ideal! Significa que, independentemente do tamanho da entrada, a operação sempre leva o mesmo tempo para ser executada. Um exemplo clássico é acessar um item específico em um array por índice (array[index]). Outra aplicação comum é a verificação de existência de um item em um Set ou Map, que geralmente ocorre em tempo constante.</p><h3>O(log n) — Complexidade Logarítmica</h3><p>Quando precisamos buscar um item em uma lista ordenada, usamos estratégias eficientes como a <strong>busca binária</strong>, reduzindo o espaço de busca pela metade a cada iteração. Além disso, estruturas como <strong>árvores balanceadas</strong> (por exemplo, Map e Set) garantem operações otimizadas com essa complexidade.</p><h3>O(n) — Complexidade Linear</h3><p>Vários métodos comuns em JavaScript seguem essa complexidade. Funções como .map(), .filter(), .find() e .forEach() percorrem um array inteiro, realizando operações em cada elemento. Se o array tem <strong>n</strong> elementos, o tempo de execução cresce proporcionalmente a <strong>n</strong>.</p><h3>O(n log n) — Complexidade Linear-Logarítmica</h3><p>Os algoritmos de ordenação mais eficientes, como <strong>QuickSort e MergeSort</strong>, operam dentro dessa complexidade. O método .sort() em JavaScript, por exemplo, é implementado com um desses algoritmos. Essa é a melhor complexidade que conseguimos ao ordenar dados de maneira geral.</p><h3>O(n²) — Complexidade Quadrática</h3><p>Se já precisou comparar todos os elementos de um array entre si, você encontrou um problema de complexidade quadrática. Um exemplo clássico é verificar pares duplicados sem o uso de um Set. Para cada elemento, percorremos todos os outros, resultando em um tempo de execução proporcional a <strong>n²</strong>.</p><h3>O(2ⁿ) — Complexidade Exponencial</h3><p>Aqui começam os problemas que se tornam rapidamente impraticáveis para entradas grandes. Algoritmos de <strong>recursão excessiva</strong>, como a resolução ingênua da sequência de Fibonacci, são exemplos típicos de complexidade exponencial. Conforme <strong>n</strong> cresce, o tempo de execução dobra a cada passo, tornando esse tipo de abordagem inviável para valores altos.</p><h3>O(n!) — Complexidade Fatorial</h3><p>Esse nível de complexidade acontece em problemas onde precisamos considerar todas as permutações possíveis de um conjunto de elementos. Um exemplo prático seria gerar todas as <strong>combinações possíveis</strong> de um menu de navegação, o que rapidamente se torna impossível de calcular para muitos itens.</p><h3>Como calcular complexidade sem sofrer?</h3><p>Uma forma prática de entender complexidade é olhando para <strong>quantas vezes um código repete certas operações</strong>. Quanto mais repetições, maior o custo.</p><h3>1. Identifique os Loops</h3><p>A maior parte dos gargalos vem de loops. Se você tem um loop que percorre uma lista de n elementos:</p><pre>for (let i = 0; i &lt; n; i++) {<br>  console.log(i);<br>}</pre><p>Isso significa que o código roda <strong>n vezes</strong>. Em notação Big O, dizemos que ele tem complexidade <strong>O(n)</strong> (linear).</p><p>Agora, se temos loops aninhados:</p><pre>for (let i = 0; i &lt; n; i++) { <br>  // The outer loop runs &#39;n&#39; times<br>  for (let j = 0; j &lt; n; j++) {<br>    // The inner loop runs &#39;n&#39; times<br>    // for each iteration of the outer loop<br>    console.log(i, j);<br>  } <br>}</pre><p>Aqui, o loop interno roda n vezes para <strong>cada</strong> valor do loop externo. Isso dá um total de n * n = n² operações. A complexidade passa a ser <strong>O(n²)</strong> (quadrática), ou seja, cresce <strong>muito mais rápido</strong> do que a anterior.</p><h3>2. O Poder do O(log n)</h3><p>Nem sempre precisamos percorrer todos os elementos de uma estrutura de dados. Em muitos casos, podemos reduzir drasticamente o número de operações usando técnicas como <strong>divisão e conquista</strong>. Um exemplo real no desenvolvimento front-end é a <strong>virtualização de listas</strong>. Quando renderizamos uma lista longa no React, em vez de exibir todos os itens de uma vez, podemos usar bibliotecas como react-window ou react-virtualized, que aplicam a estratégia de divisão para renderizar apenas os itens visíveis na tela, melhorando drasticamente a performance.</p><p>Por exemplo, a <strong>busca binária</strong> é um clássico caso de <strong>O(log n)</strong>:</p><pre>function binarySearch(arr, targ) {<br>  let left = 0;<br>  let right = arr.length - 1;<br>  <br>  while (left &lt;= right) {<br>    let middle = Math.floor((left + right) / 2);<br>    if (arr[mid] === target) return mid;<br>    if (arr[mid] &lt; target) left = mid + 1;<br>    else right = mid- 1;<br>  }<br>  return -1;<br>}</pre><p>A cada iteração, cortamos o espaço de busca pela metade. Isso faz com que a busca binária rode <strong>muito mais rápido</strong> do que uma busca linear, especialmente para grandes volumes de dados.</p><p>Imagine que você está procurando um nome na lista telefônica. Em vez de folear pagina por pagina [<strong>O(n)</strong>]. Você abre no meio, olhando somente para a metade em que esta contida o nome, sem precisar passar pela outra metade. Esse é o impacto do <strong>O(log n)</strong>!</p><h3>3. Elimine os Detalhes que Não Importam</h3><p>Se tivermos algo como:</p><pre>for (let i = 0; i &lt; n; i++) {<br>  for (let j = 0; j &lt; n; j++) {<br>    for (let k = 0; k &lt; 10; k++) {<br>      console.log(i, j, k);<br>    }<br>  }<br>}</pre><p>Podemos simplificar a análise. O último loop sempre roda 10 vezes, independentemente de n, então esse número é <strong>constante</strong> e pode ser ignorado. O que importa são os dois loops principais, que fazem n * n = n² operações. A complexidade continua sendo <strong>O(n²)</strong>.</p><h3>Melhorias com useMemo e useCallback</h3><p>useMemo e useCallback são hooks muito úteis em React quando o objetivo é otimizar o desempenho e evitar renderizações ou cálculos desnecessários. Eles podem ajudar significativamente, mas devem ser usados com cautela.</p><h4>useMemo</h4><p>O useMemo memoriza o valor retornado de uma função para que não seja recalculado a cada renderização. Isso pode ser muito útil quando temos cálculos caros ou quando passamos objetos ou arrays como dependências para componentes filhos, evitando que esses valores sejam recriados em cada renderização.</p><p>Por exemplo, se temos uma função de filtragem que é cara de se executar:</p><pre>const filteredList = useMemo(() =&gt; {<br>  return list.filter(item =&gt; item.includes(search));<br>}, [search, list]);</pre><p>Neste caso, o filtro só será refeito quando <em>search </em>ou <em>list </em>mudarem, evitando cálculos desnecessários.</p><p>O useCallback é semelhante ao useMemo, mas ao invés de memorizar um valor, ele memoriza a função em si. Isso é útil quando passamos funções como props para componentes filhos e queremos evitar que essas funções sejam recriadas a cada renderização.</p><p>Por exemplo, em um componente que usa um evento de click:</p><pre>const handleClick = useCallback(() =&gt; {<br>  console.log(&#39;Button clicked!&#39;);<br>}, []);</pre><p>Aqui, a função handleClick não será recriada a cada renderização, o que pode evitar re-renderizações desnecessárias nos componentes filhos.</p><h3>Quando esses hooks mais atrapalham do que ajudam?</h3><p>Embora useMemo e useCallback possam ser muito úteis, eles também podem causar problemas quando mal utilizados. O principal risco é usar esses hooks para otimizar operações que são muito baratas, como uma simples multiplicação ou adição, onde o custo de memorização pode ser maior do que o benefício de evitar um cálculo simples.</p><h3>Exemplo de useMemo utilizado sem necessidade</h3><pre>const valueWithTax = useMemo(() =&gt; price * 1.1, [price]);</pre><p>Multiplicação é uma operação barata. Esse useMemo só adiciona complexidade sem benefício real.</p><p>Outro caso onde useMemo pode ser ruim é quando a dependência muda com muita frequência. Se um valor recalcula constantemente, useMemo pode gerar mais trabalho para o React ao tentar reter estados memorizados.</p><h3>Exemplo de useMemo implementado corretamente</h3><pre>const filteredList = useMemo(() =&gt; {<br>  return list.filter(item =&gt; item.includes(search));<br>}, [search, list]);</pre><p>Agora, o filtro só é refeito quando <em>search </em>ou <em>list </em>mudam, evitando cálculos desnecessários.</p><h3>Exemplo de useCallback desnecessário</h3><p>Imagine que você tem um componente simples, como um botão que incrementa um contador. O useCallback é aplicado na função que lida com o clique, mas, nesse caso, a função é simples e a performance não seria impactada de qualquer forma. O useCallback neste caso só adiciona complexidade desnecessária.</p><pre>import React, { useState, useCallback } from &#39;react&#39;;<br><br>const Counter = () =&gt; {<br>  const [count, setCount] = useState(0);<br><br>  // Unnecessary useCallback<br>  const increment = useCallback(() =&gt; {<br>    setCount(prev =&gt; prev + 1);<br>  }, []);  // The dependency is empty,<br>           // meaning the function will never change<br><br>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;Count: {count}&lt;/p&gt;<br>      &lt;button onClick={increment}&gt;Increment&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>};<br><br>export default Counter;</pre><h3>Por que useCallback é desnecessário aqui?</h3><p><strong>Custo desnecessário</strong>: O useCallback memoriza a função incrementar para evitar que ela seja recriada a cada renderização. No entanto, a função é muito simples e não tem impacto significativo na performance. Recriar essa função a cada renderização não causa um problema de desempenho.</p><p><strong>Complexidade extra</strong>: Usar o useCallback neste caso só aumenta a complexidade do código sem trazer benefícios. O React já é eficiente o suficiente para re-renderizar o componente, e a função incrementar não é um cálculo complexo que justifique memorização.</p><h3>Melhor abordagem</h3><p>Neste caso, não é necessário usar useCallback. O código ficaria mais simples e legível sem ele:</p><pre>import React, { useState } from &#39;react&#39;;<br><br>const Counter = () =&gt; {<br>  const [count, setCount] = useState(0);<br><br>  const increment = () =&gt; {<br>    setCount(prev =&gt; prev + 1);<br>  };<br><br>  return (<br>    &lt;div&gt;<br>      &lt;p&gt;Count: {count}&lt;/p&gt;<br>      &lt;button onClick={increment}&gt;Increment&lt;/button&gt;<br>    &lt;/div&gt;<br>  );<br>};<br><br>export default Counter;</pre><p>useCallback é útil quando você precisa evitar a recriação de funções em componentes que são re-renderizados com frequência, especialmente quando você passa essas funções como props para componentes filhos que dependem da estabilidade da função para evitar renderizações desnecessárias. Mas, quando aplicado a funções simples que não têm um impacto de desempenho real, ele pode acabar atrapalhando ao adicionar complexidade sem ganho de performance.</p><h3>Como Identificar Pontos de Melhoria e Otimizar Código?</h3><ol><li><strong>Verifique loops desnecessários</strong>: Às vezes, um map ou filter pode ser substituído por uma estrutura mais eficiente.</li><li><strong>Analise os estados no React</strong>: Nem tudo precisa estar no useState, o que pode reduzir re-renderizações.</li><li><strong>Evite cálculos repetidos</strong>: Sempre que um cálculo for pesado e puder ser salvo, vale pensar se a memorização faz sentido.</li><li><strong>Prefira soluções algorítmicas ao invés de mais dependências</strong>: Muitas vezes, um bom algoritmo evita precisar adicionar uma nova biblioteca.</li></ol><h3>Referências para se aprofundar</h3><ul><li><a href="https://www.bigocheatsheet.com/">Big-O Cheat Sheet</a> — Um guia rápido sobre complexidade de algoritmos.</li><li>VisuAlgo — Site interativo para visualizar algoritmos.</li><li><a href="https://cs50.harvard.edu/">CS50 Harvard — Estruturas de Dados</a> — Curso gratuito que explica estruturas de dados e complexidade.</li><li><a href="https://developer.mozilla.org/en-US/docs/Web/Performance">MDN — Performance e Otimização</a> — Guia do Mozilla sobre otimizações no desenvolvimento web.</li><li><a href="https://react.dev/reference/react/useCallback">React Docs — useCallback </a>— Documentação oficial do React sobre useCallback.</li><li><a href="https://react.dev/reference/react/useMemo">React Docs — useMemo</a> — Documentação oficial do React sobre useMemo.</li></ul><p>Se curtiu esse conteúdo, compartilhe com seus colegas e bora escrever código mais performático! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1e57f49e5de1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>