diff --git a/src/content/reference/react/useDeferredValue.md b/src/content/reference/react/useDeferredValue.md
index 6d055f1f9..942d4b7a6 100644
--- a/src/content/reference/react/useDeferredValue.md
+++ b/src/content/reference/react/useDeferredValue.md
@@ -4,7 +4,7 @@ title: useDeferredValue
 
 <Intro>
 
-`useDeferredValue` is a React Hook that lets you defer updating a part of the UI.
+`useDeferredValue` é um Hook do React que permite adiar a atualização de uma parte da interface do usuário.
 
 ```js
 const deferredValue = useDeferredValue(value)
@@ -16,11 +16,11 @@ const deferredValue = useDeferredValue(value)
 
 ---
 
-## Reference {/*reference*/}
+## Referência {/*reference*/}
 
 ### `useDeferredValue(value, initialValue?)` {/*usedeferredvalue*/}
 
-Call `useDeferredValue` at the top level of your component to get a deferred version of that value.
+Chame `useDeferredValue` no nível mais alto do seu componente para obter uma versão adiada desse valor.
 
 ```js
 import { useState, useDeferredValue } from 'react';
@@ -32,47 +32,47 @@ function SearchPage() {
 }
 ```
 
-[See more examples below.](#usage)
+[Veja mais exemplos abaixo.](#usage)
 
-#### Parameters {/*parameters*/}
+#### Parâmetros {/*parameters*/}
 
-* `value`: The value you want to defer. It can have any type.
-* <CanaryBadge title="This feature is only available in the Canary channel" /> **optional** `initialValue`: A value to use during the initial render of a component. If this option is omitted, `useDeferredValue` will not defer during the initial render, because there's no previous version of `value` that it can render instead.
+* `value`: O valor que você deseja adiar. Ele pode ter qualquer tipo.
+* <CanaryBadge title="Esse recurso está disponível apenas no canal Canary" /> **opcional** `initialValue`: Um valor a ser utilizado durante a renderização inicial de um componente. Se esta opção for omitida, `useDeferredValue` não irá adiar durante a renderização inicial, pois não há uma versão anterior de `value` para renderizar em vez disso.
 
 
-#### Returns {/*returns*/}
+#### Retornos {/*returns*/}
 
-- `currentValue`: During the initial render, the returned deferred value will be the same as the value you provided. During updates, React will first attempt a re-render with the old value (so it will return the old value), and then try another re-render in the background with the new value (so it will return the updated value).
+- `currentValue`: Durante a renderização inicial, o valor adiado retornado será o mesmo que o valor fornecido. Durante as atualizações, o React primeiro tentará uma nova renderização com o valor antigo (portanto, retornará o valor antigo) e, em seguida, tentará outra renderização em segundo plano com o novo valor (portanto, retornará o valor atualizado).
 
 <Canary>
 
-In the latest React Canary versions, `useDeferredValue` returns the `initialValue` on initial render, and schedules a re-render in the background with the `value` returned.
+Nas versões mais recentes do React Canary, `useDeferredValue` retorna o `initialValue` na renderização inicial e agenda uma nova renderização em segundo plano com o `value` retornado.
 
 </Canary>
 
-#### Caveats {/*caveats*/}
+#### Ressalvas {/*caveats*/}
 
-- When an update is inside a Transition, `useDeferredValue` always returns the new `value` and does not spawn a deferred render, since the update is already deferred.
+- Quando uma atualização está dentro de uma Transição, `useDeferredValue` sempre retorna o novo `value` e não gera uma renderização adiada, já que a atualização já está adiada.
 
-- The values you pass to `useDeferredValue` should either be primitive values (like strings and numbers) or objects created outside of rendering. If you create a new object during rendering and immediately pass it to `useDeferredValue`, it will be different on every render, causing unnecessary background re-renders.
+- Os valores que você passa para `useDeferredValue` devem ser valores primitivos (como strings e números) ou objetos criados fora da renderização. Se você criar um novo objeto durante a renderização e imediatamente passá-lo para `useDeferredValue`, ele será diferente a cada renderização, causando renderizações em segundo plano desnecessárias.
 
-- When `useDeferredValue` receives a different value (compared with [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)), in addition to the current render (when it still uses the previous value), it schedules a re-render in the background with the new value. The background re-render is interruptible: if there's another update to the `value`, React will restart the background re-render from scratch. For example, if the user is typing into an input faster than a chart receiving its deferred value can re-render, the chart will only re-render after the user stops typing.
+- Quando `useDeferredValue` recebe um valor diferente (comparado com [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is)), além da renderização atual (quando ainda usa o valor anterior), ele agenda uma nova renderização em segundo plano com o novo valor. A nova renderização em segundo plano é interrompível: se houver outra atualização para o `value`, o React reiniciará a nova renderização em segundo plano do zero. Por exemplo, se o usuário estiver digitando em um campo de entrada mais rápido do que um gráfico recebendo seu valor adiado pode renderizar, o gráfico só será re-renderizado após o usuário parar de digitar.
 
-- `useDeferredValue` is integrated with [`<Suspense>`.](/reference/react/Suspense) If the background update caused by a new value suspends the UI, the user will not see the fallback. They will see the old deferred value until the data loads.
+- `useDeferredValue` é integrado com [`<Suspense>`](/reference/react/Suspense). Se a atualização em segundo plano causada por um novo valor suspender a interface do usuário, o usuário não verá a opção de recuperação. Eles verão o antigo valor adiado até que os dados sejam carregados.
 
-- `useDeferredValue` does not by itself prevent extra network requests.
+- `useDeferredValue` não por si só impede requisições de rede extras.
 
-- There is no fixed delay caused by `useDeferredValue` itself. As soon as React finishes the original re-render, React will immediately start working on the background re-render with the new deferred value. Any updates caused by events (like typing) will interrupt the background re-render and get prioritized over it.
+- Não há um atraso fixo causado pelo próprio `useDeferredValue`. Assim que o React termina a renderização original, ele começará imediatamente a trabalhar na nova renderização em segundo plano com o novo valor adiado. Quaisquer atualizações causadas por eventos (como digitação) interromperão a nova renderização em segundo plano e terão prioridade sobre ela.
 
-- The background re-render caused by `useDeferredValue` does not fire Effects until it's committed to the screen. If the background re-render suspends, its Effects will run after the data loads and the UI updates.
+- A nova renderização em segundo plano causada por `useDeferredValue` não dispara Efeitos até que esteja comprometida na tela. Se a nova renderização em segundo plano for suspensa, seus Efeitos serão executados após os dados serem carregados e a interface do usuário for atualizada.
 
 ---
 
-## Usage {/*usage*/}
+## Uso {/*usage*/}
 
-### Showing stale content while fresh content is loading {/*showing-stale-content-while-fresh-content-is-loading*/}
+### Mostrando conteúdo defasado enquanto o conteúdo fresco é carregado {/*showing-stale-content-while-fresh-content-is-loading*/}
 
-Call `useDeferredValue` at the top level of your component to defer updating some part of your UI.
+Chame `useDeferredValue` no nível mais alto do seu componente para adiar a atualização de alguma parte da sua interface.
 
 ```js [[1, 5, "query"], [2, 5, "deferredQuery"]]
 import { useState, useDeferredValue } from 'react';
@@ -84,26 +84,26 @@ function SearchPage() {
 }
 ```
 
-During the initial render, the <CodeStep step={2}>deferred value</CodeStep> will be the same as the <CodeStep step={1}>value</CodeStep> you provided.
+Durante a renderização inicial, o <CodeStep step={2}>valor adiado</CodeStep> será o mesmo que o <CodeStep step={1}>valor</CodeStep> que você forneceu.
 
-During updates, the <CodeStep step={2}>deferred value</CodeStep> will "lag behind" the latest <CodeStep step={1}>value</CodeStep>. In particular, React will first re-render *without* updating the deferred value, and then try to re-render with the newly received value in the background.
+Durante as atualizações, o <CodeStep step={2}>valor adiado</CodeStep> irá "atrasar-se" em relação ao <CodeStep step={1}>valor</CodeStep> mais recente. Em particular, o React primeiro re-renderizará *sem* atualizar o valor adiado e, em seguida, tentará re-renderizar com o novo valor recebido em segundo plano.
 
-**Let's walk through an example to see when this is useful.**
+**Vamos percorrer um exemplo para ver quando isso é útil.**
 
 <Note>
 
-This example assumes you use a Suspense-enabled data source:
+Este exemplo assume que você usa uma fonte de dados habilitada para Suspense:
 
-- Data fetching with Suspense-enabled frameworks like [Relay](https://relay.dev/docs/guided-tour/rendering/loading-states/) and [Next.js](https://nextjs.org/docs/getting-started/react-essentials)
-- Lazy-loading component code with [`lazy`](/reference/react/lazy)
-- Reading the value of a Promise with [`use`](/reference/react/use)
+- Busca de dados com frameworks habilitados para Suspense, como [Relay](https://relay.dev/docs/guided-tour/rendering/loading-states/) e [Next.js](https://nextjs.org/docs/getting-started/react-essentials)
+- Carregamento lento do código do componente com [`lazy`](/reference/react/lazy)
+- Lendo o valor de uma Promise com [`use`](/reference/react/use)
 
-[Learn more about Suspense and its limitations.](/reference/react/Suspense)
+[Saiba mais sobre Suspense e suas limitações.](/reference/react/Suspense)
 
 </Note>
 
 
-In this example, the `SearchResults` component [suspends](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading) while fetching the search results. Try typing `"a"`, waiting for the results, and then editing it to `"ab"`. The results for `"a"` get replaced by the loading fallback.
+Neste exemplo, o componente `SearchResults` [suspende](/reference/react/Suspense#displaying-a-fallback-while-content-is-loading) enquanto busca os resultados da pesquisa. Tente digitar `"a"`, aguarde os resultados e então edite para `"ab"`. Os resultados para `"a"` são substituídos pela opção de recuperação de carregamento.
 
 <Sandpack>
 
@@ -131,10 +131,10 @@ export default function App() {
   return (
     <>
       <label>
-        Search albums:
+        Pesquisar álbuns:
         <input value={query} onChange={e => setQuery(e.target.value)} />
       </label>
-      <Suspense fallback={<h2>Loading...</h2>}>
+      <Suspense fallback={<h2>Carregando...</h2>}>
         <SearchResults query={query} />
       </Suspense>
     </>
@@ -145,11 +145,11 @@ export default function App() {
 ```js src/SearchResults.js hidden
 import { fetchData } from './data.js';
 
-// Note: this component is written using an experimental API
-// that's not yet available in stable versions of React.
+// Nota: este componente foi escrito usando uma API experimental
+// que ainda não está disponível nas versões estáveis do React.
 
-// For a realistic example you can follow today, try a framework
-// that's integrated with Suspense, like Relay or Next.js.
+// Para um exemplo realista que você pode seguir hoje, tente um framework
+// que seja integrado com Suspense, como Relay ou Next.js.
 
 export default function SearchResults({ query }) {
   if (query === '') {
@@ -157,7 +157,7 @@ export default function SearchResults({ query }) {
   }
   const albums = use(fetchData(`/search?q=${query}`));
   if (albums.length === 0) {
-    return <p>No matches for <i>"{query}"</i></p>;
+    return <p>Sem correspondências para <i>"{query}"</i></p>;
   }
   return (
     <ul>
@@ -170,8 +170,8 @@ export default function SearchResults({ query }) {
   );
 }
 
-// This is a workaround for a bug to get the demo running.
-// TODO: replace with real implementation when the bug is fixed.
+// Este é um trabalho em volta de um erro para fazer a demonstração funcionar.
+// TODO: substituir por uma implementação real quando o erro for corrigido.
 function use(promise) {
   if (promise.status === 'fulfilled') {
     return promise.value;
@@ -197,9 +197,9 @@ function use(promise) {
 ```
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: a forma como você faria busca de dados depende do
+// framework que você usa junto com Suspense.
+// Normalmente, a lógica de cache estaria dentro de um framework.
 
 let cache = new Map();
 
@@ -214,12 +214,12 @@ async function getData(url) {
   if (url.startsWith('/search?q=')) {
     return await getSearchResults(url.slice('/search?q='.length));
   } else {
-    throw Error('Not implemented');
+    throw Error('Não implementado');
   }
 }
 
 async function getSearchResults(query) {
-  // Add a fake delay to make waiting noticeable.
+  // Adiciona um atraso falso para tornar a espera notável.
   await new Promise(resolve => {
     setTimeout(resolve, 500);
   });
@@ -295,7 +295,7 @@ input { margin: 10px; }
 
 </Sandpack>
 
-A common alternative UI pattern is to *defer* updating the list of results and to keep showing the previous results until the new results are ready. Call `useDeferredValue` to pass a deferred version of the query down: 
+Um padrão comum de interface do usuário é *adicionar* a atualização da lista de resultados e continuar mostrando os resultados anteriores até que os novos resultados estejam prontos. Chame `useDeferredValue` para passar uma versão adiada da consulta para baixo: 
 
 ```js {3,11}
 export default function App() {
@@ -304,10 +304,10 @@ export default function App() {
   return (
     <>
       <label>
-        Search albums:
+        Pesquisar álbuns:
         <input value={query} onChange={e => setQuery(e.target.value)} />
       </label>
-      <Suspense fallback={<h2>Loading...</h2>}>
+      <Suspense fallback={<h2>Carregando...</h2>}>
         <SearchResults query={deferredQuery} />
       </Suspense>
     </>
@@ -315,9 +315,9 @@ export default function App() {
 }
 ```
 
-The `query` will update immediately, so the input will display the new value. However, the `deferredQuery` will keep its previous value until the data has loaded, so `SearchResults` will show the stale results for a bit.
+A `query` será atualizada imediatamente, então o campo de entrada exibirá o novo valor. No entanto, o `deferredQuery` manterá seu valor anterior até que os dados tenham sido carregados, de modo que `SearchResults` mostrará os resultados desatualizados por um tempo.
 
-Enter `"a"` in the example below, wait for the results to load, and then edit the input to `"ab"`. Notice how instead of the Suspense fallback, you now see the stale result list until the new results have loaded:
+Digite `"a"` no exemplo abaixo, aguarde o carregamento dos resultados e, em seguida, edite a entrada para `"ab"`. Observe como, ao invés da opção de recuperação do Suspense, você agora vê a lista de resultados desatualizada até que os novos resultados tenham sido carregados:
 
 <Sandpack>
 
@@ -346,10 +346,10 @@ export default function App() {
   return (
     <>
       <label>
-        Search albums:
+        Pesquisar álbuns:
         <input value={query} onChange={e => setQuery(e.target.value)} />
       </label>
-      <Suspense fallback={<h2>Loading...</h2>}>
+      <Suspense fallback={<h2>Carregando...</h2>}>
         <SearchResults query={deferredQuery} />
       </Suspense>
     </>
@@ -360,11 +360,11 @@ export default function App() {
 ```js src/SearchResults.js hidden
 import { fetchData } from './data.js';
 
-// Note: this component is written using an experimental API
-// that's not yet available in stable versions of React.
+// Nota: este componente foi escrito usando uma API experimental
+// que ainda não está disponível nas versões estáveis do React.
 
-// For a realistic example you can follow today, try a framework
-// that's integrated with Suspense, like Relay or Next.js.
+// Para um exemplo realista que você pode seguir hoje, tente um framework
+// que é integrado com Suspense, como Relay ou Next.js.
 
 export default function SearchResults({ query }) {
   if (query === '') {
@@ -372,7 +372,7 @@ export default function SearchResults({ query }) {
   }
   const albums = use(fetchData(`/search?q=${query}`));
   if (albums.length === 0) {
-    return <p>No matches for <i>"{query}"</i></p>;
+    return <p>Sem correspondências para <i>"{query}"</i></p>;
   }
   return (
     <ul>
@@ -385,8 +385,8 @@ export default function SearchResults({ query }) {
   );
 }
 
-// This is a workaround for a bug to get the demo running.
-// TODO: replace with real implementation when the bug is fixed.
+// Este é um trabalho em volta de um erro para fazer a demonstração funcionar.
+// TODO: substituir por uma implementação real quando o erro for corrigido.
 function use(promise) {
   if (promise.status === 'fulfilled') {
     return promise.value;
@@ -412,9 +412,9 @@ function use(promise) {
 ```
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: a forma como você faria busca de dados depende do
+// framework que você usa junto com Suspense.
+// Normalmente, a lógica de cache estaria dentro de um framework.
 
 let cache = new Map();
 
@@ -429,12 +429,12 @@ async function getData(url) {
   if (url.startsWith('/search?q=')) {
     return await getSearchResults(url.slice('/search?q='.length));
   } else {
-    throw Error('Not implemented');
+    throw Error('Não implementado');
   }
 }
 
 async function getSearchResults(query) {
-  // Add a fake delay to make waiting noticeable.
+  // Adiciona um atraso falso para tornar a espera notável.
   await new Promise(resolve => {
     setTimeout(resolve, 500);
   });
@@ -512,25 +512,25 @@ input { margin: 10px; }
 
 <DeepDive>
 
-#### How does deferring a value work under the hood? {/*how-does-deferring-a-value-work-under-the-hood*/}
+#### Como funciona o adiamento de um valor nos bastidores? {/*how-does-deferring-a-value-work-under-the-hood*/}
 
-You can think of it as happening in two steps:
+Você pode pensar que isso acontece em duas etapas:
 
-1. **First, React re-renders with the new `query` (`"ab"`) but with the old `deferredQuery` (still `"a")`.** The `deferredQuery` value, which you pass to the result list, is *deferred:* it "lags behind" the `query` value.
+1. **Primeiro, o React re-renderiza com a nova `query` (`"ab"`) mas com o antigo `deferredQuery` (ainda `"a"`).** O valor de `deferredQuery`, que você passa para a lista de resultados, está *adiado:* ele "atrasou-se" em relação ao valor de `query`.
 
-2. **In the background, React tries to re-render with *both* `query` and `deferredQuery` updated to `"ab"`.** If this re-render completes, React will show it on the screen. However, if it suspends (the results for `"ab"` have not loaded yet), React will abandon this rendering attempt, and retry this re-render again after the data has loaded. The user will keep seeing the stale deferred value until the data is ready.
+2. **Em segundo plano, o React tenta re-renderizar com *os dois* `query` e `deferredQuery` atualizados para `"ab"`.** Se essa nova renderização for concluída, o React a mostrará na tela. No entanto, se ela suspender (os resultados para `"ab"` ainda não foram carregados), o React abandonará essa tentativa de renderização e tentará mais uma vez após os dados terem sido carregados. O usuário continuará vendo o valor adiado desatualizado até que os dados estejam prontos.
 
-The deferred "background" rendering is interruptible. For example, if you type into the input again, React will abandon it and restart with the new value. React will always use the latest provided value.
+A renderização "em segundo plano" adiada é interrompível. Por exemplo, se você digitar no campo de entrada novamente, o React abandonará essa renderização e reiniciará com o novo valor. O React sempre usará o valor mais recente fornecido.
 
-Note that there is still a network request per each keystroke. What's being deferred here is displaying results (until they're ready), not the network requests themselves. Even if the user continues typing, responses for each keystroke get cached, so pressing Backspace is instant and doesn't fetch again.
+Observe que ainda existe uma requisição de rede para cada tecla digitada. O que está sendo adiado aqui é a exibição de resultados (até que estejam prontos), não as requisições de rede em si. Mesmo se o usuário continuar digitando, as respostas para cada tecla digitada são armazenadas em cache, então pressionar Backspace é instantâneo e não busca novamente.
 
 </DeepDive>
 
 ---
 
-### Indicating that the content is stale {/*indicating-that-the-content-is-stale*/}
+### Indicando que o conteúdo está desatualizado {/*indicating-that-the-content-is-stale*/}
 
-In the example above, there is no indication that the result list for the latest query is still loading. This can be confusing to the user if the new results take a while to load. To make it more obvious to the user that the result list does not match the latest query, you can add a visual indication when the stale result list is displayed:
+No exemplo acima, não há indicação de que a lista de resultados para a consulta mais recente ainda está carregando. Isso pode ser confuso para o usuário se os novos resultados demorarem a carregar. Para deixar mais óbvio para o usuário que a lista de resultados não corresponde à consulta mais recente, você pode adicionar uma indicação visual quando a lista de resultados desatualizada é exibida:
 
 ```js {2}
 <div style={{
@@ -540,7 +540,7 @@ In the example above, there is no indication that the result list for the latest
 </div>
 ```
 
-With this change, as soon as you start typing, the stale result list gets slightly dimmed until the new result list loads. You can also add a CSS transition to delay dimming so that it feels gradual, like in the example below:
+Com essa mudança, assim que você começar a digitar, a lista de resultados desatualizada será ligeiramente diminuída até que a nova lista de resultados carregue. Você também pode adicionar uma transição CSS para atrasar a diminuição de modo que se sinta gradual, como no exemplo abaixo:
 
 <Sandpack>
 
@@ -570,10 +570,10 @@ export default function App() {
   return (
     <>
       <label>
-        Search albums:
+        Pesquisar álbuns:
         <input value={query} onChange={e => setQuery(e.target.value)} />
       </label>
-      <Suspense fallback={<h2>Loading...</h2>}>
+      <Suspense fallback={<h2>Carregando...</h2>}>
         <div style={{
           opacity: isStale ? 0.5 : 1,
           transition: isStale ? 'opacity 0.2s 0.2s linear' : 'opacity 0s 0s linear'
@@ -589,11 +589,11 @@ export default function App() {
 ```js src/SearchResults.js hidden
 import { fetchData } from './data.js';
 
-// Note: this component is written using an experimental API
-// that's not yet available in stable versions of React.
+// Nota: este componente foi escrito usando uma API experimental
+// que ainda não está disponível nas versões estáveis do React.
 
-// For a realistic example you can follow today, try a framework
-// that's integrated with Suspense, like Relay or Next.js.
+// Para um exemplo realista que você pode seguir hoje, tente um framework
+// que é integrado com Suspense, como Relay ou Next.js.
 
 export default function SearchResults({ query }) {
   if (query === '') {
@@ -601,7 +601,7 @@ export default function SearchResults({ query }) {
   }
   const albums = use(fetchData(`/search?q=${query}`));
   if (albums.length === 0) {
-    return <p>No matches for <i>"{query}"</i></p>;
+    return <p>Sem correspondências para <i>"{query}"</i></p>;
   }
   return (
     <ul>
@@ -614,8 +614,8 @@ export default function SearchResults({ query }) {
   );
 }
 
-// This is a workaround for a bug to get the demo running.
-// TODO: replace with real implementation when the bug is fixed.
+// Este é um trabalho em volta de um erro para fazer a demonstração funcionar.
+// TODO: substituir por uma implementação real quando o erro for corrigido.
 function use(promise) {
   if (promise.status === 'fulfilled') {
     return promise.value;
@@ -641,9 +641,9 @@ function use(promise) {
 ```
 
 ```js src/data.js hidden
-// Note: the way you would do data fetching depends on
-// the framework that you use together with Suspense.
-// Normally, the caching logic would be inside a framework.
+// Nota: a forma como você faria busca de dados depende do
+// framework que você usa junto com Suspense.
+// Normalmente, a lógica de cache estaria dentro de um framework.
 
 let cache = new Map();
 
@@ -658,12 +658,12 @@ async function getData(url) {
   if (url.startsWith('/search?q=')) {
     return await getSearchResults(url.slice('/search?q='.length));
   } else {
-    throw Error('Not implemented');
+    throw Error('Não implementado');
   }
 }
 
 async function getSearchResults(query) {
-  // Add a fake delay to make waiting noticeable.
+  // Adiciona um atraso falso para tornar a espera notável.
   await new Promise(resolve => {
     setTimeout(resolve, 500);
   });
@@ -741,11 +741,11 @@ input { margin: 10px; }
 
 ---
 
-### Deferring re-rendering for a part of the UI {/*deferring-re-rendering-for-a-part-of-the-ui*/}
+### Adiando re-renderizações para uma parte da interface do usuário {/*deferring-re-rendering-for-a-part-of-the-ui*/}
 
-You can also apply `useDeferredValue` as a performance optimization. It is useful when a part of your UI is slow to re-render, there's no easy way to optimize it, and you want to prevent it from blocking the rest of the UI.
+Você também pode aplicar `useDeferredValue` como uma otimização de desempenho. Isso é útil quando uma parte da sua interface do usuário está lenta para re-renderizar, não há uma maneira fácil de otimizá-la e você deseja evitar que isso bloqueie o restante da interface.
 
-Imagine you have a text field and a component (like a chart or a long list) that re-renders on every keystroke:
+Imagine que você tem um campo de texto e um componente (como um gráfico ou uma lista longa) que re-renderiza a cada tecla pressionada:
 
 ```js
 function App() {
@@ -759,7 +759,7 @@ function App() {
 }
 ```
 
-First, optimize `SlowList` to skip re-rendering when its props are the same. To do this, [wrap it in `memo`:](/reference/react/memo#skipping-re-rendering-when-props-are-unchanged)
+Primeiro, otimize `SlowList` para pular a re-renderização quando suas props forem as mesmas. Para fazer isso, [envolva-o em `memo`:](/reference/react/memo#skipping-re-rendering-when-props-are-unchanged)
 
 ```js {1,3}
 const SlowList = memo(function SlowList({ text }) {
@@ -767,9 +767,9 @@ const SlowList = memo(function SlowList({ text }) {
 });
 ```
 
-However, this only helps if the `SlowList` props are *the same* as during the previous render. The problem you're facing now is that it's slow when they're *different,* and when you actually need to show different visual output.
+No entanto, isso só ajuda se as props do `SlowList` forem *as mesmas* que durante a renderização anterior. O problema que você enfrenta agora é que ele é lento quando são *diferentes*, e quando você realmente precisa mostrar uma saída visual diferente.
 
-Concretely, the main performance problem is that whenever you type into the input, the `SlowList` receives new props, and re-rendering its entire tree makes the typing feel janky. In this case, `useDeferredValue` lets you prioritize updating the input (which must be fast) over updating the result list (which is allowed to be slower):
+Concretamente, o principal problema de desempenho é que, sempre que você digita no campo de entrada, o `SlowList` recebe novas props e a re-renderização de toda a sua árvore faz com que a digitação pareça estranha. Nesse caso, `useDeferredValue` permite que você priorize a atualização do campo de entrada (que deve ser rápida) em relação à atualização da lista de resultados (que pode ser mais lenta):
 
 ```js {3,7}
 function App() {
@@ -784,13 +784,13 @@ function App() {
 }
 ```
 
-This does not make re-rendering of the `SlowList` faster. However, it tells React that re-rendering the list can be deprioritized so that it doesn't block the keystrokes. The list will "lag behind" the input and then "catch up". Like before, React will attempt to update the list as soon as possible, but will not block the user from typing.
+Isso não torna a re-renderização do `SlowList` mais rápida. No entanto, diz ao React que a re-renderização da lista pode ser despriorizada, para que isso não bloqueie as teclas digitadas. A lista irá "atrasar-se" em relação à entrada e depois "recuperar-se". Como antes, o React tentará atualizar a lista o mais rápido possível, mas não bloqueará o usuário de digitar.
 
-<Recipes titleText="The difference between useDeferredValue and unoptimized re-rendering" titleId="examples">
+<Recipes titleText="A diferença entre useDeferredValue e re-renderização não otimizada" titleId="examples">
 
-#### Deferred re-rendering of the list {/*deferred-re-rendering-of-the-list*/}
+#### Re-renderização adiada da lista {/*deferred-re-rendering-of-the-list*/}
 
-In this example, each item in the `SlowList` component is **artificially slowed down** so that you can see how `useDeferredValue` lets you keep the input responsive. Type into the input and notice that typing feels snappy while the list "lags behind" it.
+Neste exemplo, cada item no componente `SlowList` é **artificialmente desacelerado** para que você possa ver como `useDeferredValue` permite que você mantenha a entrada responsiva. Digite no campo de entrada e note que a digitação parece rápida enquanto a lista "atrasada" é exibida.
 
 <Sandpack>
 
@@ -814,8 +814,8 @@ export default function App() {
 import { memo } from 'react';
 
 const SlowList = memo(function SlowList({ text }) {
-  // Log once. The actual slowdown is inside SlowItem.
-  console.log('[ARTIFICIALLY SLOW] Rendering 250 <SlowItem />');
+  // Log uma vez. A desaceleração real está dentro do SlowItem.
+  console.log('[ARTIFICIALMENTE LENTO] Renderizando 250 <SlowItem />');
 
   let items = [];
   for (let i = 0; i < 250; i++) {
@@ -831,12 +831,12 @@ const SlowList = memo(function SlowList({ text }) {
 function SlowItem({ text }) {
   let startTime = performance.now();
   while (performance.now() - startTime < 1) {
-    // Do nothing for 1 ms per item to emulate extremely slow code
+    // Não faz nada por 1 ms por item para emular código extremamente lento
   }
 
   return (
     <li className="item">
-      Text: {text}
+      Texto: {text}
     </li>
   )
 }
@@ -864,11 +864,11 @@ export default SlowList;
 
 <Solution />
 
-#### Unoptimized re-rendering of the list {/*unoptimized-re-rendering-of-the-list*/}
+#### Re-renderização não otimizada da lista {/*unoptimized-re-rendering-of-the-list*/}
 
-In this example, each item in the `SlowList` component is **artificially slowed down**, but there is no `useDeferredValue`.
+Neste exemplo, cada item no componente `SlowList` é **artificialmente desacelerado**, mas não há `useDeferredValue`.
 
-Notice how typing into the input feels very janky. This is because without `useDeferredValue`, each keystroke forces the entire list to re-render immediately in a non-interruptible way.
+Note como digitar no campo de entrada parece muito estranho. Isso acontece porque, sem `useDeferredValue`, cada tecla pressionada força toda a lista a re-renderizar imediatamente de uma maneira não interrompível.
 
 <Sandpack>
 
@@ -891,8 +891,8 @@ export default function App() {
 import { memo } from 'react';
 
 const SlowList = memo(function SlowList({ text }) {
-  // Log once. The actual slowdown is inside SlowItem.
-  console.log('[ARTIFICIALLY SLOW] Rendering 250 <SlowItem />');
+  // Log uma vez. A desaceleração real está dentro do SlowItem.
+  console.log('[ARTIFICIALMENTE LENTO] Renderizando 250 <SlowItem />');
 
   let items = [];
   for (let i = 0; i < 250; i++) {
@@ -908,12 +908,12 @@ const SlowList = memo(function SlowList({ text }) {
 function SlowItem({ text }) {
   let startTime = performance.now();
   while (performance.now() - startTime < 1) {
-    // Do nothing for 1 ms per item to emulate extremely slow code
+    // Não faz nada por 1 ms por item para emular código extremamente lento
   }
 
   return (
     <li className="item">
-      Text: {text}
+      Texto: {text}
     </li>
   )
 }
@@ -945,25 +945,25 @@ export default SlowList;
 
 <Pitfall>
 
-This optimization requires `SlowList` to be wrapped in [`memo`.](/reference/react/memo) This is because whenever the `text` changes, React needs to be able to re-render the parent component quickly. During that re-render, `deferredText` still has its previous value, so `SlowList` is able to skip re-rendering (its props have not changed). Without [`memo`,](/reference/react/memo) it would have to re-render anyway, defeating the point of the optimization.
+Essa otimização requer que `SlowList` seja envolto em [`memo`.](/reference/react/memo) Isso ocorre porque, sempre que o `text` muda, o React precisa ser capaz de re-renderizar rapidamente o componente pai. Durante essa re-renderização, `deferredText` ainda tem seu valor anterior, então `SlowList` é capaz de pular a re-renderização (suas props não mudaram). Sem [`memo`,](/reference/react/memo) ele teria que re-renderizar de qualquer maneira, o que anularia o propósito da otimização.
 
 </Pitfall>
 
 <DeepDive>
 
-#### How is deferring a value different from debouncing and throttling? {/*how-is-deferring-a-value-different-from-debouncing-and-throttling*/}
+#### Como o adiamento de um valor é diferente de debouncing e throttling? {/*how-is-deferring-a-value-different-from-debouncing-and-throttling*/}
 
-There are two common optimization techniques you might have used before in this scenario:
+Existem duas técnicas comuns de otimização que você pode ter usado antes neste cenário:
 
-- *Debouncing* means you'd wait for the user to stop typing (e.g. for a second) before updating the list.
-- *Throttling* means you'd update the list every once in a while (e.g. at most once a second).
+- *Debouncing* significa que você esperaria o usuário parar de digitar (por exemplo, por um segundo) antes de atualizar a lista.
+- *Throttling* significa que você atualizaria a lista de vez em quando (por exemplo, no máximo uma vez por segundo).
 
-While these techniques are helpful in some cases, `useDeferredValue` is better suited to optimizing rendering because it is deeply integrated with React itself and adapts to the user's device.
+Embora essas técnicas sejam úteis em alguns casos, `useDeferredValue` é mais adequado para otimizar renderização porque está profundamente integrado com o próprio React e se adapta ao dispositivo do usuário.
 
-Unlike debouncing or throttling, it doesn't require choosing any fixed delay. If the user's device is fast (e.g. powerful laptop), the deferred re-render would happen almost immediately and wouldn't be noticeable. If the user's device is slow, the list would "lag behind" the input proportionally to how slow the device is.
+Ao contrário de debouncing ou throttling, não requer que você escolha nenhum atraso fixo. Se o dispositivo do usuário for rápido (por exemplo, um laptop potente), a nova renderização adiada ocorreria quase imediatamente e não seria notável. Se o dispositivo do usuário for lento, a lista "atrasaria-se" em relação à entrada proporcionalmente à lentidão do dispositivo.
 
-Also, unlike with debouncing or throttling, deferred re-renders done by `useDeferredValue` are interruptible by default. This means that if React is in the middle of re-rendering a large list, but the user makes another keystroke, React will abandon that re-render, handle the keystroke, and then start rendering in the background again. By contrast, debouncing and throttling still produce a janky experience because they're *blocking:* they merely postpone the moment when rendering blocks the keystroke.
+Além disso, ao contrário do debouncing ou throttling, as novas renderizações em segundo plano feitas por `useDeferredValue` são interrompíveis por padrão. Isso significa que, se o React estiver no meio da re-renderização de uma lista grande, mas o usuário fizer outra tecla, o React abandonará essa re-renderização, lidará com a tecla e, em seguida, começará a renderizar em segundo plano novamente. Em contraste, debouncing e throttling ainda produzem uma experiência estranha porque são *bloqueadores:* eles apenas postergam o momento em que a renderização bloqueia a tecla.
 
-If the work you're optimizing doesn't happen during rendering, debouncing and throttling are still useful. For example, they can let you fire fewer network requests. You can also use these techniques together.
+Se o trabalho que você está otimizando não acontecer durante a renderização, debouncing e throttling ainda são úteis. Por exemplo, eles podem permitir que você faça menos requisições de rede. Você também pode usar essas técnicas juntas.
 
-</DeepDive>
+</DeepDive>
\ No newline at end of file