Atención

El uso de cloneElement no es com√ļn y puede conducir a un c√≥digo fr√°gil. Mira alternativas comunes.

cloneElement te permite crear un nuevo elemento de React usando otro elemento como punto de partida.

const clonedElement = cloneElement(element, props, ...children)

Referencia

cloneElement(elemento, props, ...children)

Llama a cloneElement para crear un elemento React basado en el elemento, pero con diferentes props y children:

import { cloneElement } from 'react';

// ...
const clonedElement = cloneElement(
<Row title="Cabbage">
Hello
</Row>,
{ isHighlighted: true },
'Goodbye'
);

console.log(clonedElement); // <Row title="Cabbage">Goodbye</Row>

Ver m√°s ejemplos debajo.

Par√°metros

  • elemento: El argumento elemento debe ser un elemento de React v√°lido. Por ejemplo, podr√≠a ser un nodo JSX como <Something />, el resultado de llamar a createElement, o el resultado de otra llamada a cloneElement.

  • props: El argumento props debe ser un objeto o null. Si pasas null, el elemento clonado mantendr√° todos los element.props originales. De lo contrario, para cada propiedad en el objeto props, el elemento devuelto ‚Äúpreferir√°‚ÄĚ el valor de props sobre el valor de element.props. El resto de las propiedades se completar√°n a partir de los element.props originales. Si pasas props.key o props.ref, reemplazar√°n a los originales.

  • opcional ...children: Cero o m√°s nodos hijo. Pueden ser cualquier nodo React, incluidos elementos de React, cadenas, n√ļmeros, portales, nodos vac√≠os (null, undefined, true, y false), y arrays de nodos de React. Si no pasas ning√ļn argumento ...children, se conservar√°n los element.props.children originales.

Devuelve

cloneElement devuelve un objeto de elemento de React con algunas propiedades:

  • type: Igual que element.type.
  • props: El resultado de mezclar superficialmente element.props con las props que has pasado para sobrescribirlas.
  • ref: El element.ref original, a menos que se haya sobrescrito con props.ref.
  • key: El element.key original, a menos que se haya sobrescrito con props.key.

Usualmente, devolverás el elemento desde tu componente o lo harás hijo de otro elemento. Aunque puedes leer las propiedades del elemento, es mejor tratar a cada elemento como opaco después de que se crea, y solo renderizarlo.

Advertencias

  • Clonar un elemento no modifica el elemento original.

  • Solo debes pasar hijos como m√ļltiples argumentos a createElement si todos son conocidos est√°ticamente, como cloneElement(element, null, child1, child2, child3). Si tus hijos son din√°micos, pasa todo el array como tercer argumento: cloneElement(element, null, listItems). Esto garantiza que React te advierta sobre las keys que faltan para cualquier lista din√°mica. Para listas est√°ticas no es necesario porque nunca se reordenan.

  • cloneElement hace que sea m√°s dif√≠cil rastrear el flujo de datos, por lo que prueba las alternativas en su lugar.


Uso

Sobrescribir props de un elemento

Para sobrescribir las props de alg√ļn elemento de React, p√°salo a cloneElement con las props que quieres sobrescribir:

import { cloneElement } from 'react';

// ...
const clonedElement = cloneElement(
<Row title="Cabbage" />,
{ isHighlighted: true }
);

Aquí, el elemento clonado resultante será <Row title="Cabbage" isHighlighted={true} />.

Veamos un ejemplo para ver cu√°ndo es √ļtil.

Imagina un componente List que renderiza sus children como una lista de filas seleccionables con un bot√≥n ‚ÄúNext‚ÄĚ que cambia qu√© fila est√° seleccionada. El componente List necesita renderizar la Row seleccionada de manera diferente, por lo que clona cada hijo <Row> que ha recibido y agrega una propiedad extra isHighlighted: true o isHighlighted: false:

export default function List({ children }) {
const [selectedIndex, setSelectedIndex] = useState(0);
return (
<div className="List">
{Children.map(children, (child, index) =>
cloneElement(child, {
isHighlighted: index === selectedIndex
})
)}

Digamos que el JSX original recibido por List se ve así:

<List>
<Row title="Cabbage" />
<Row title="Garlic" />
<Row title="Apple" />
</List>

Clonando sus hijos, List puede pasar información adicional a cada Row dentro. El resultado se ve así:

<List>
<Row
title="Cabbage"
isHighlighted={true}
/>
<Row
title="Garlic"
isHighlighted={false}
/>
<Row
title="Apple"
isHighlighted={false}
/>
</List>

Observa c√≥mo al presionar ‚ÄúNext‚ÄĚ se actualiza el estado del List, y resalta una fila diferente:

import { Children, cloneElement, useState } from 'react';

export default function List({ children }) {
  const [selectedIndex, setSelectedIndex] = useState(0);
  return (
    <div className="List">
      {Children.map(children, (child, index) =>
        cloneElement(child, {
          isHighlighted: index === selectedIndex 
        })
      )}
      <hr />
      <button onClick={() => {
        setSelectedIndex(i =>
          (i + 1) % Children.count(children)
        );
      }}>
        Next
      </button>
    </div>
  );
}

Para resumir, List clonó los elementos <Row /> que recibió y les agregó una propiedad extra.

Atención

Al clonar los hijos se hace difícil saber cómo fluye la información a través de tu aplicación. Intenta una de las alternativas.


Alternativas

Pasar datos con una prop de renderizado

En vez de usar cloneElement, considera aceptar una render prop (o prop de renderizado) como renderItem. Aquí, List recibe renderItem como una prop. List llama a renderItem para cada elemento y pasa isHighlighted como un argumento:

export default function List({ items, renderItem }) {
const [selectedIndex, setSelectedIndex] = useState(0);
return (
<div className="List">
{items.map((item, index) => {
const isHighlighted = index === selectedIndex;
return renderItem(item, isHighlighted);
})}

La prop renderItem se llama una ‚Äúrender prop‚ÄĚ porque es una propiedad que especifica c√≥mo renderizar algo. Por ejemplo, puedes pasar una implementaci√≥n de renderItem que renderice un <Row> con el valor isHighlighted dado:

<List
items={products}
renderItem={(product, isHighlighted) =>
<Row
key={product.id}
title={product.title}
isHighlighted={isHighlighted}
/>
}
/>

El resultado final es el mismo que con cloneElement:

<List>
<Row
title="Cabbage"
isHighlighted={true}
/>
<Row
title="Garlic"
isHighlighted={false}
/>
<Row
title="Apple"
isHighlighted={false}
/>
</List>

Sin embargo, puedes rastrear claramente de dónde viene el valor isHighlighted.

import { useState } from 'react';

export default function List({ items, renderItem }) {
  const [selectedIndex, setSelectedIndex] = useState(0);
  return (
    <div className="List">
      {items.map((item, index) => {
        const isHighlighted = index === selectedIndex;
        return renderItem(item, isHighlighted);
      })}
      <hr />
      <button onClick={() => {
        setSelectedIndex(i =>
          (i + 1) % items.length
        );
      }}>
        Next
      </button>
    </div>
  );
}

Este patrón es preferido a cloneElement porque es más explícito.


Pasar datos a través del contexto

Otra alternativa a cloneElement es pasar datos a través del contexto.

Por ejemplo, puedes llamar a createContext para definir un HighlightContext:

export const HighlightContext = createContext(false);

Tu componente List puede envolver cada elemento que renderiza en un proveedor de HighlightContext:

export default function List({ items, renderItem }) {
const [selectedIndex, setSelectedIndex] = useState(0);
return (
<div className="List">
{items.map((item, index) => {
const isHighlighted = index === selectedIndex;
return (
<HighlightContext.Provider key={item.id} value={isHighlighted}>
{renderItem(item)}
</HighlightContext.Provider>
);
})}

Con este enfoque, Row no necesita recibir una propiedad isHighlighted en absoluto. En su lugar, lee del contexto:

export default function Row({ title }) {
const isHighlighted = useContext(HighlightContext);
// ...

Esto permite que el componente que llama no sepa o se preocupe por pasar isHighlighted a <Row>:

<List
items={products}
renderItem={product =>
<Row title={product.title} />
}
/>

En vez de eso, List y Row coordinan la lógica de resaltado a través del contexto.

import { useState } from 'react';
import { HighlightContext } from './HighlightContext.js';

export default function List({ items, renderItem }) {
  const [selectedIndex, setSelectedIndex] = useState(0);
  return (
    <div className="List">
      {items.map((item, index) => {
        const isHighlighted = index === selectedIndex;
        return (
          <HighlightContext.Provider
            key={item.id}
            value={isHighlighted}
          >
            {renderItem(item)}
          </HighlightContext.Provider>
        );
      })}
      <hr />
      <button onClick={() => {
        setSelectedIndex(i =>
          (i + 1) % items.length
        );
      }}>
        Next
      </button>
    </div>
  );
}

Aprende más sobre pasar datos a través del contexto.


Extraer lógica en un Hook personalizado

Otro enfoque que puedes probar es extraer la l√≥gica ‚Äúno visual‚ÄĚ en tu propio Hook, y usar la informaci√≥n devuelta por tu Hook para decidir qu√© renderizar. Por ejemplo, puedes escribir un Hook personalizado useList como este:

import { useState } from 'react';

export default function useList(items) {
const [selectedIndex, setSelectedIndex] = useState(0);

function onNext() {
setSelectedIndex(i =>
(i + 1) % items.length
);
}

const selected = items[selectedIndex];
return [selected, onNext];
}

Luego puedes usarlo así:

export default function App() {
const [selected, onNext] = useList(products);
return (
<div className="List">
{products.map(product =>
<Row
key={product.id}
title={product.title}
isHighlighted={selected === product}
/>
)}
<hr />
<button onClick={onNext}>
Next
</button>
</div>
);
}

El flujo de datos es explícito, pero el estado está dentro del Hook personalizado useList que puedes usar desde cualquier componente:

import Row from './Row.js';
import useList from './useList.js';
import { products } from './data.js';

export default function App() {
  const [selected, onNext] = useList(products);
  return (
    <div className="List">
      {products.map(product =>
        <Row
          key={product.id}
          title={product.title}
          isHighlighted={selected === product}
        />
      )}
      <hr />
      <button onClick={onNext}>
        Next
      </button>
    </div>
  );
}

Este enfoque es particularmente √ļtil si quieres reutilizar esta l√≥gica entre diferentes componentes.