ReactDOMServer

El objeto ReactDOMServer te permite renderizar componentes a un marcado estático. Normalmente, se usa en un servidor de Node:

// módulos ES
import * as ReactDOMServer from 'react-dom/server';
// CommonJS
var ReactDOMServer = require('react-dom/server');

Resumen

Estos métodos solo están disponibles en los entornos con Streams de Node.js:

renderToPipeableStream()
renderToNodeStream() (Deprecated)
renderToStaticNodeStream()

Estos métodos solo están disponibles en los entornos con Streams Web (esto incluye navegadores, Deno y algunos runtimes modernos de edge computing):

renderToReadableStream()

Los siguientes métodos se pueden utilizar en entornos que no tienen disponibles streams:

renderToString()
renderToStaticMarkup()

Referencia

`renderToPipeableStream()`

ReactDOMServer.renderToPipeableStream(element, options)

Renderiza un elemento React a su HTML inicial. Devuelve un stream (flujo) con un método pipe(res) que conduce la salida y abort() para abortar la petición. Es completamente compatible con Suspense y con la realización de streaming de HTML con bloques de contenido «demorados» que luego «aparecen» usando etiquetas <script>. Lee más en.

Si llamas ReactDOM.hydrateRoot() en un nodo que ya tiene este marcado de servidor, React lo conservará y solo adjuntará controladores de eventos, lo que te permitirá tener una experiencia de primera carga muy eficaz.

let didError = false;
const stream = renderToPipeableStream(
  <App />,
  {
    onShellReady() {
      // The content above all Suspense boundaries is ready.
      // If something errored before we started streaming, we set the error code appropriately.
      res.statusCode = didError ? 500 : 200;
      res.setHeader('Content-type', 'text/html');
      stream.pipe(res);
    },
    onShellError(error) {
      // Something errored before we could complete the shell so we emit an alternative shell.
      res.statusCode = 500;
      res.send(
        '<!doctype html><p>Loading...</p><script src="clientrender.js"></script>'
      );
    },
    onAllReady() {
      // If you don't want streaming, use this instead of onShellReady.
      // This will fire after the entire page content is ready.
      // You can use this for crawlers or static generation.

      // res.statusCode = didError ? 500 : 200;
      // res.setHeader('Content-type', 'text/html');
      // stream.pipe(res);
    },
    onError(err) {
      didError = true;
      console.error(err);
    },
  }
);

Mira la lista completa de opciones.

Nota:

Esta es una API específica de Node.js. Los entornos con Streams Web, como Deno y runtimes modernos de edge computing, deberían usar en su lugar renderToReadableStream.

`renderToReadableStream()`

ReactDOMServer.renderToReadableStream(element, options);

Streams a React element to its initial HTML. Returns a Promise that resolves to a Readable Stream. Fully supports Suspense and streaming of HTML. Read more

If you call ReactDOM.hydrateRoot() on a node that already has this server-rendered markup, React will preserve it and only attach event handlers, allowing you to have a very performant first-load experience.

let controller = new AbortController();
let didError = false;
try {
  let stream = await renderToReadableStream(
    <html>
      <body>Success</body>
    </html>,
    {
      signal: controller.signal,
      onError(error) {
        didError = true;
        console.error(error);
      }
    }
  );
  
  // This is to wait for all Suspense boundaries to be ready. You can uncomment
  // this line if you want to buffer the entire HTML instead of streaming it.
  // You can use this for crawlers or static generation:

  // await stream.allReady;

  return new Response(stream, {
    status: didError ? 500 : 200,
    headers: {'Content-Type': 'text/html'},
  });
} catch (error) {
  return new Response(
    '<!doctype html><p>Loading...</p><script src="clientrender.js"></script>',
    {
      status: 500,
      headers: {'Content-Type': 'text/html'},
    }
  );
}

See the full list of options.

Note:

This API depends on Web Streams. For Node.js, use renderToPipeableStream instead.

`renderToNodeStream()` (Deprecated)

ReactDOMServer.renderToNodeStream(element)

Renderiza un elemento React a su HTML inicial. Devuelve un Readable stream de Node.js que genera una cadena HTML. La salida HTML de este flujo es exactamente igual a lo que devolvería ReactDOMServer.renderToString Puede usar este método para generar HTML en el servidor y enviar el marcado en la solicitud inicial para que las páginas se carguen más rápido y permitir que los motores de búsqueda rastreen sus páginas con fines de SEO.

Nota:

Solo para el servidor. Esta API no está disponible en el navegador.

El flujo devuelto por este método devolverá un flujo de bytes codificado en utf-8. Si necesita un flujo en otra codificación, observa un proyecto como iconv-lite, que proporciona flujos de transformación para la transcodificación de texto.

`renderToStaticNodeStream()`

ReactDOMServer.renderToStaticNodeStream(element)

Similar a renderToNodeStream, excepto que esto no crea atributos DOM adicionales que React usa internamente, como data-reactroot. Esto es útil si desea utilizar React como un simple generador de páginas estáticas, ya que eliminar los atributos adicionales puede ahorrar algunos bytes.

La salida HTML de este flujo es exactamente igual a lo que ReactDOMServer.renderToStaticMarkup devolvería.

Si planeas usar React en el cliente para hacer que el marcado sea interactivo, no use este método. En su lugar, utilice renderToNodeStream en el servidor y ReactDOM.hydrateRoot() en el cliente.

Nota:

Solo para el servidor. Esta API no está disponible en el navegador.

El flujo devuelto por este método devolverá un flujo de bytes codificado en utf-8. Si necesita un flujo en otra codificación, chequea un proyecto como iconv-lite, que proporciona flujos de transformación para la transcodificación de texto.

`renderToString()`

ReactDOMServer.renderToString(element)

Renderiza un elemento React a su HTML inicial. React devolverá HTML en una cadena de texto. Puedes usar este método para generar HTML en el servidor y enviar el marcado en la solicitud inicial para que las páginas se carguen más rápido y permitir que los motores de búsqueda rastreen tus páginas con fines de SEO.

Si llamas ReactDOM.hydrateRoot() a un nodo que ya tiene este marcado desde el servidor, React lo conservará y solo adjuntará los controladores de eventos, lo que te permitirá tener una experiencia de primera carga muy eficaz.

Nota

Esta API tiene compatibilidad limitada con Suspense y no permite realizar streaming.

En el servidor, se recomienda usar en cambio, o bien renderToPipeableStream (para Node.js) o renderToReadableStream (para Streams Web).

`renderToStaticMarkup()`

ReactDOMServer.renderToStaticMarkup(element)

Similar a renderToString, excepto que esto no crea atributos DOM adicionales que React usa internamente, como data-reactroot. Esto es útil si desea utilizar React como un simple generador de páginas estáticas, ya que eliminar los atributos adicionales puede ahorrar algunos bytes.

Si planeas usar React en el cliente para hacer que el marcado sea interactivo, no uses este método. En su lugar, usa renderToString en el servidor y ReactDOM.hydrateRoot() en el cliente.

¿Es útil esta página?Edita esta página

Resumen

Referencia

renderToPipeableStream()

renderToReadableStream()

renderToNodeStream() (Deprecated)

renderToStaticNodeStream()