---
title: "Risolvi l’errore Minified React #418 e #185 con il messaggio completo e la tua riga di codice"
description: "Un errore Minified React è un numero che sta al posto di un messaggio più lungo. Apri il link react.dev/errors che stampa per leggerlo. Abbiamo provocato #418 e #185 in Next.js 16 e li abbiamo risolti entrambi."
canonical: "https://logbrew.co/it/errors/minified-react-error"
last_updated: "2026-11-20"
---

# Risolvi l’errore Minified React #418 e #185 con il messaggio completo e la tua riga di codice

Un errore Minified React è un numero che sta al posto di un messaggio più lungo. Apri il link `react.dev/errors` che stampa per leggerlo. Abbiamo provocato #418 e #185 in Next.js 16 e li abbiamo risolti entrambi.

Testato il 20 novembre 2026 con Next.js 16.4.6, React 19.2.7, Chrome 157 e @logbrew/next 0.1.18

Di [Furkan Erday](https://github.com/furkanerday). Furkan Erday è il fondatore di LogBrew. Sviluppa LogBrew ogni giorno con Claude Code e Codex.

Canonical: https://logbrew.co/it/errors/minified-react-error

## Quali errori React ha intercettato un boundary di errore

| Dove è stato lanciato l’errore | Intercettato dal boundary | Messaggio vero nel browser |
| --- | --- | --- |
| Render di un client component | Sì | Sì |
| `useEffect` | Sì | Sì |
| Handler `onClick` | No | Sì |
| Callback di `setTimeout` | No | Sì |
| Handler async, dopo `await` | No | Sì |
| Server Component | Sì | No, `#441` e un digest |

6 errori in 1 build di produzione Next.js 16.4.6 con React 19.2.7.

## Leggi il messaggio completo, poi trova la riga

### Apri il link nel messaggio

React in produzione lascia il testo dei messaggi fuori dal bundle e stampa al suo posto un numero e un link. Apri il link. La pagina `react.dev/errors` mostra il testo completo e inserisce ogni valore `args[]` preso dall’URL. La build di sviluppo, quella di `next dev`, stampa direttamente il testo completo.

```bash
"use client";
export function RenderedAt() {
  return <p>Rendered at {Date.now()}</p>;
}
```

Output

```text
Error: Minified React error #418; visit https://react.dev/errors/418?args[]=text&args[]= for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### #418 vuol dire che l’HTML del server non corrispondeva al primo render

Il decoder legge #418 come `Hydration failed because the server rendered text didn't match the client`. `args[]=text` vuol dire che un nodo di testo era diverso, come con `Date.now()` sopra. `args[]=HTML` vuol dire che gli elementi erano diversi. Un `<div>` dentro un `<p>` ci ha dato `HTML`, perché il browser chiude il `<p>` prima del `<div>`. In entrambe le esecuzioni React ha renderizzato la versione del browser e la pagina ha continuato a funzionare.

```bash
export default function Page() { return <p>Order total <div>12 USD</div></p>; }
```

Output

```text
Error: Minified React error #418; visit https://react.dev/errors/418?args[]=HTML&args[]= for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### #423 non è comparso su React 19.2

Il decoder legge #423 come `There was an error while hydrating but React was able to recover by instead client rendering the entire root.` Abbiamo creato 3 discrepanze su React 19.2.7, 1 dentro `<Suspense>`, e React ha stampato #418 ogni volta, mai #423. Se i tuoi log mostrano #423, cerca le stesse cause di #418.

### #185 nasce da un layout effect che cambia lo state dopo ogni render

Il decoder legge #185 come `Maximum update depth exceeded`. Il nostro `useLayoutEffect` senza lista di dipendenze cambiava lo state dopo ogni render, React ha fermato il ciclo con #185 e Next.js ha sostituito la pagina con `This page couldn’t load`. Lo stesso codice in `useEffect` non ha stampato nessun errore. In 2 esecuzioni il contatore segnava 228.936 e 231.224 quando abbiamo letto la pagina.

```bash
"use client";
import { useLayoutEffect, useState } from "react";

export default function Page() {
  const [count, setCount] = useState(0);
  useLayoutEffect(() => {
    setCount(count + 1);
  });
  return <p>{count}</p>;
}
```

Output

```text
Error: Minified React error #185; visit https://react.dev/errors/185 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### Riporta lo stack al tuo file con la source map

Imposta `productionBrowserSourceMaps: true` in `next.config` e rifai la build. Turbopack dà a ogni map un nome con hash diverso, quindi `resolve.mjs` legge il nome dall’ultima riga del chunk e poi cerca la posizione con la classe `SourceMap` integrata in Node. Gli abbiamo dato l’unico frame dello stack di #185 fuori da React, `2-5_qr0vv7do_.js:1:254`, e ha indicato `setCount` alla riga 7 della nostra pagina.

```bash
// node resolve.mjs <chunk.js> <line> <column>
import { readFileSync } from "node:fs";
import { SourceMap } from "node:module";
import { dirname, join } from "node:path";

const [chunk, line, column] = process.argv.slice(2);
const mapName = readFileSync(chunk, "utf8").match(/sourceMappingURL=(\S+)\s*$/)[1];
const map = new SourceMap(JSON.parse(readFileSync(join(dirname(chunk), mapName), "utf8")));
const { originalSource, originalLine, originalColumn, name } = map.findEntry(line - 1, column - 1);
console.log(`${name ?? "?"} ${originalSource}:${originalLine + 1}:${originalColumn + 1}`);
```

Output

```text
setCount turbopack:///[project]/app/loop-layout-effect/page.tsx:7:5
```

## Risolvi la causa, poi intercetta il resto

### Risolvi #418 renderizzando lo stesso output sul server e al primo caricamento

Leggi i valori che esistono solo nel browser, come `Date.now()`, `window` o `localStorage`, dentro `useEffect`. Gira solo nel browser, dopo l’hydration, quindi il primo render corrisponde all’HTML del server, e nella nostra esecuzione #418 è sparito. Per un `<div>` dentro un `<p>`, cambia 1 dei 2 tag. Uno `<span>` dentro il `<p>` non ha stampato nessun errore.

```bash
"use client";
import { useEffect, useState } from "react";

export function RenderedAt() {
  const [renderedAt, setRenderedAt] = useState<number | null>(null);
  useEffect(() => setRenderedAt(Date.now()), []);
  return <p>Rendered at {renderedAt ?? "…"}</p>;
}
```

### Usa `suppressHydrationWarning` solo per 1 valore che non puoi rendere uguale

`suppressHydrationWarning` ha fermato #418 nella nostra esecuzione, ma la pagina ha tenuto il testo del server. Mostrava l’ora della build, non quella del browser. Funziona solo a 1 livello di profondità, e React lo definisce una via di fuga.

```bash
"use client";
export function RenderedAt() {
  return <p suppressHydrationWarning>Rendered at {Date.now()}</p>;
}
```

### Risolvi #185 dando all’effect una lista di dipendenze

Con `[]`, il layout effect è girato una volta e la pagina ha mostrato 1, senza errori. Elenca i valori che l’effect legge e cambia lo state solo quando uno di questi è cambiato.

```bash
"use client";
import { useLayoutEffect, useState } from "react";

export default function Page() {
  const [count, setCount] = useState(0);
  useLayoutEffect(() => {
    setCount(count + 1);
  }, []);
  return <p>{count}</p>;
}
```

### Intercetta gli errori di render con un boundary di errore

Un boundary di errore è un componente di classe. `getDerivedStateFromError` lo fa passare a un fallback e `componentDidCatch` segnala l’errore. Il nostro ha intercettato il `TypeError` di `taps.map` durante il render e un errore lanciato in `useEffect`. Gli sono sfuggiti gli errori lanciati in un handler `onClick`, in una callback di `setTimeout` e dopo `await` in un handler async. Questi sono arrivati a window come errori non gestiti, quindi intercettali dove li lanci.

```bash
"use client";
import { Component, type ReactNode } from "react";

export class ErrorBoundary extends Component<{ children: ReactNode }, { error: Error | null }> {
  state: { error: Error | null } = { error: null };

  static getDerivedStateFromError(error: Error) {
    return { error };
  }

  componentDidCatch(error: Error) {
    console.error("ErrorBoundary caught:", error.message);
  }

  render() {
    if (this.state.error) return <p>This part of the page failed to load.</p>;
    return this.props.children;
  }
}
```

Output

```text
ErrorBoundary caught: Cannot read properties of undefined (reading 'map')
```

### In Next.js, aggiungi `error.tsx` e invia l’errore a LogBrew

Next.js avvolge ogni segmento di route in un boundary di errore che renderizza `error.tsx`. Il nostro `error.tsx` ha intercettato lo stesso errore di render e `captureNextClientError()` di `@logbrew/next` l’ha inviato come 1 problema. La demo passa un transport che registra. Togli `transport` e il client invia a LogBrew con `fetch`.

```bash
// app/next-error.tsx
"use client";
import { useEffect } from "react";
import { captureNextClientError, createLogBrewNextBrowserClient } from "@logbrew/next/client";
import { RecordingTransport } from "@logbrew/sdk";

const transport = RecordingTransport.alwaysAccept();
const logbrew = createLogBrewNextBrowserClient({
  clientKey: process.env.NEXT_PUBLIC_LOGBREW_CLIENT_KEY,
  transport
});

export function ReportError({ error, route }: { error: Error & { digest?: string }; route: string }) {
  useEffect(() => {
    void captureNextClientError(logbrew, error, { routeTemplate: route }).then((response) => {
      console.log(JSON.stringify(response));
      console.log(transport.lastBody());
    });
  }, [error, route]);
  return <p>This page failed to load.</p>;
}

// app/next-boundary/error.tsx
"use client";
import { ReportError } from "../next-error";

export default function Error({ error }: { error: Error & { digest?: string } }) {
  return <ReportError error={error} route="/next-boundary" />;
}
```

Output

```text
{"statusCode":202,"attempts":1,"batches":1}
```

## Cosa abbiamo visto nei test

Abbiamo compilato 1 app Next.js 16.4.6 con React 19.2.7 tramite `next build` con Turbopack, l’abbiamo servita con `next start` e abbiamo aperto ogni pagina in Chrome 157 headless. Abbiamo creato 3 discrepanze di hydration, 2 cicli di aggiornamento e 6 errori in punti diversi, poi abbiamo provato ogni soluzione sulla stessa build.

Ogni discrepanza di hydration ha stampato #418, mai #423. Solo il ciclo nel layout effect ha stampato #185. Il boundary di errore ha intercettato 3 errori su 6, e il browser ha visto il messaggio vero per 5 di questi.

L’errore del Server Component è il caso a parte. La pagina ha risposto 500, e il browser ha ricevuto `Minified React error #441` con il `digest` `1331393307` al posto del nostro messaggio. Il log del server ha stampato `Orders database is down` con lo stesso digest, quindi il digest ti porta all’errore vero.

Output

```text
⨯ Error: Orders database is down
    at b (.next/server/chunks/ssr/[root-of-the-server]__0e6swfn4zoar-._.js:1:1281) {
  digest: '1331393307'
}
```

## Perché React in produzione stampa numeri invece di messaggi

La build di produzione di React tiene solo il codice di ogni errore, per inviare meno byte. I testi stanno in `scripts/error-codes/codes.json` nel repository di React, e la pagina del decoder inserisce gli argomenti presi dall’URL. #441 è diverso. React toglie apposta il messaggio di un Server Component nelle build di produzione, così i dettagli del server non arrivano mai al browser.

Anche lo stack è minificato. Per #418 una source map aiuta poco. Ogni frame dei nostri stack di #418 portava a `react-dom-client.production.js`, nessuno al nostro codice. Il valore `args[]` e il componente che hai cambiato per ultimo portano prima alla causa.

vercel/next.js#50245 mostra perché il testo decodificato conta. A maggio 2023 segnalava errori Minified React che comparivano solo in produzione. Un maintainer ha scritto che le persone nel thread avevano probabilmente problemi diversi dietro lo stesso messaggio, e la issue su GitHub è stata chiusa ad agosto 2024 senza una riproduzione. Il messaggio decodificato e la riga di codice distinguono questi casi.

## Cosa registra LogBrew

`captureNextClientError()` ha inviato 1 problema con titolo `TypeError` al livello `error`, con il messaggio, il meccanismo `nextjs.error_boundary` e `handled: false`. Ha tenuto 10 frame dello stack, ognuno con file, riga, colonna e funzione. Il primo frame era `19k2sxe-2yvvy.js` alla riga 1, colonna 220, e la nostra source map l’ha riportato a `taps.map` alla riga 5 della pagina.

LogBrew raggruppa le ripetizioni per tipo di errore e per quel primo frame, con la chiave `nextjs.error_boundary:TypeError:` seguita dall’URL del chunk. Il problema ha tenuto il testo del messaggio, e la voce della sua catena delle cause ha segnato il messaggio come `redacted`.

Per l’errore del Server Component, il problema riportava il messaggio di #441 e l’`errorDigest` `1331393307`, lo stesso valore del log del server. La catena indicava `stackFramesState: "not_captured"`, perché il browser non ha mai avuto lo stack del server.

## Domande frequenti

### Cos’è un errore Minified React?

Un errore di una build di produzione di React. React sostituisce il messaggio con un numero e un link a `react.dev/errors`, e quella pagina mostra il testo completo. La build di sviluppo stampa direttamente il testo completo.

### Cosa vuol dire l’errore Minified React #418?

Che l’hydration non è riuscita. L’HTML del server non corrispondeva al primo render nel browser. `args[]=text` indica un nodo di testo, `args[]=HTML` gli elementi. Lo causano `Date.now()`, i controlli `typeof window`, le date nel locale dell’utente e un `<div>` dentro un `<p>`.

### Come risolvo un errore di hydration in un layout Next.js?

Trova cosa cambia tra server e browser in quel layout, come per qualsiasi componente. Nel root layout lo causa anche uno script del tema o un’estensione del browser che cambia `<html>` o `<body>` prima che React si carichi. `suppressHydrationWarning` su quell’elemento nasconde l’errore a 1 livello di profondità.

### Cosa vuol dire l’errore Minified React #185?

Che è stata superata la profondità massima di aggiornamenti. Un componente ha cambiato lo state di continuo mentre React applicava i suoi aggiornamenti. Nella nostra esecuzione lo ha causato `useLayoutEffect` senza lista di dipendenze. Aggiungi una lista di dipendenze o cambia lo state solo quando il valore è cambiato.

### Cosa non intercetta un boundary di errore?

Nella nostra esecuzione gli sono sfuggiti gli errori lanciati in un handler `onClick`, in una callback di `setTimeout` e dopo `await`. Ha intercettato gli errori nel render, in `useEffect` e da un Server Component, ma quest’ultimo è arrivato come #441 senza il suo messaggio.

### Perché vedo un errore Minified React su ChatGPT o su un altro sito?

Il sito usa una build di produzione di React e il suo codice ha incontrato un errore. Solo i suoi sviluppatori possono correggere quel codice. Anche un’estensione del browser che cambia la pagina prima che React si carichi può causare #418, quindi prova una finestra in incognito con le estensioni disattivate.

## Intercetta ogni errore React in produzione

L’SDK Next.js di LogBrew invia ogni errore che arriva a error.tsx con i frame dello stack e il digest del server, e LogBrew raggruppa le ripetizioni in 1 problema. Inizia con il generoso piano gratuito, senza carta.

[Inizia gratis](https://logbrew.co/it)

## Fonti

- [React docs, Error decoder](https://react.dev/errors)
- [React docs, Catching rendering errors with an error boundary](https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)
- [React docs, Common props (suppressHydrationWarning)](https://react.dev/reference/react-dom/components/common#common-props)
- [Next.js docs, Text content does not match server-rendered HTML](https://nextjs.org/docs/messages/react-hydration-error)
- [Next.js docs, error.js](https://nextjs.org/docs/app/api-reference/file-conventions/error)
- [Next.js docs, productionBrowserSourceMaps](https://nextjs.org/docs/app/api-reference/config/next-config-js/productionBrowserSourceMaps)
- [vercel/next.js#50245](https://github.com/vercel/next.js/issues/50245)

## Altre soluzioni agli errori

- [Risolvi l’errore di script che nasconde messaggio, file e riga](https://logbrew.co/it/errors/script-error)
- [Risolvi l’errore Failed to fetch e distingui le sue 3 cause](https://logbrew.co/it/errors/failed-to-fetch)
- [Risolvi java.lang.NullPointerException in Kotlin e Android partendo dal messaggio](https://logbrew.co/it/errors/nullpointerexception)
- [Errori che abbiamo riprodotto, e come risolvere ciascuno](https://logbrew.co/it/errors)
