Diego Valdes
Tengo duda con las children, en que parte del curso se vieron? en esta clase solo se vieron las props
Fernando Orozco Velasquez
Recuerda que "children" es una propiedad que viene dentro del objeto "prop"
Cuando trabajas con componentes en React y TypeScript, los props son simplemente un objeto al que le defines tipos como harías con cualquier otro objeto. Entender esto te permite construir componentes reutilizables, seguros y libres del temido any. Aquí vas a ver cómo pasar una imagen como prop desde un componente padre y cómo tipar correctamente esa propiedad.
¿Qué son los props en React y cómo se tipan con TypeScript?
Los props son los valores que un componente padre le pasa a un componente hijo. En el ejemplo del componente RandomPhoto, la imagen estaba definida dentro del propio componente, pero la idea es moverla para que el index.tsx decida qué imagen mostrar.
Apenas haces ese cambio, TypeScript te avisa que ese atributo no existe. Y tiene razón: nunca le dijiste a tu función que aceptaba props. Por eso necesitas declarar explícitamente qué recibe tu componente y de qué tipo es cada valor [01:00].
¿Qué es un prop en React? Es un objeto con los valores que un componente padre le envía a un componente hijo. En TypeScript lo tipas como cualquier otro objeto, definiendo cada propiedad y su tipo.
¿Cómo definir el tipo de los props directamente en la función?
La primera forma de tiparlos es hacerlo en línea, justo en los parámetros de la función. Si dejas el parámetro sin tipo, TypeScript lo marca como any, y recuerda: any es el enemigo de un código predecible.
Una versión inicial sería declarar que props es un objeto con una propiedad image de tipo string. Así, cuando uses props.image dentro del src de la etiqueta <img>, TypeScript queda satisfecho porque el tipo coincide con lo que espera el atributo.
Esta forma funciona, pero tiene un problema: a medida que agregas más propiedades al componente, el tipado en línea se vuelve difícil de mantener [02:10].
¿Cuál es la forma más limpia de tipar props en un componente?
La práctica más común es extraer el tipo a un alias llamado Props con P mayúscula. Defines ese tipo como un objeto que lista cada propiedad con su tipo correspondiente, y luego se lo asignas al parámetro de la función.
Pasos para tipar props de forma escalable
Props que describa el objeto.image: string.Con esto consigues claridad, autocompletado y un único lugar donde mantener la forma del objeto cuando el componente crezca.
¿Qué es destructuring y por qué se usa con props?
En lugar de recibir props y luego escribir props.image cada vez, puedes hacer destructuring directamente en los parámetros: ({ image }: Props). Ojo, aquí no estás cambiando el tipo, solo la forma en que accedes al valor.
El resultado es código más corto y legible. Dentro del componente usas image directamente, sin el prefijo props., y TypeScript sigue validando que esa propiedad exista en el objeto.
¿Para qué sirve el destructuring en props? Permite extraer las propiedades del objeto props como variables individuales, haciendo el código más limpio sin alterar los tipos definidos.
¿Cómo agregar más props a un componente sin romper los tipos?
Si quieres soportar nuevas propiedades, como un alt para la imagen, TypeScript te detendrá hasta que las declares. El flujo es siempre el mismo: agregas la propiedad al tipo Props con su tipo correcto y luego la consumes dentro del componente.
Por ejemplo, si necesitas un texto alternativo, añades alt: string al tipo Props, lo incluyes en el destructuring y lo usas en la etiqueta. Si intentas usar alt sin haberlo declarado, TypeScript te avisa de inmediato, igual que pasó al inicio con image [03:40].
Este patrón se repite para cada nuevo prop:
Props.La lógica es la misma sin importar cuántas propiedades agregues. Lo que cambia es la cantidad de campos que listas en tu tipo Props, manteniendo el componente predecible y fácil de mantener.
Si te quedó alguna duda sobre cómo estructurar tus tipos o por qué evitar any, déjala en los comentarios y conversemos.
Mis Apuntes
Para poder usar las props con TSX primero tenemos que tipar el objeto de props. Lo hacemos asignándole un tipo por cada prop que tengamos, y para hacerlo mas mantenible, separamos esos tipos en un objeto aparte (ya sea con type o interface).
// RandomFox.tsx type Props = { image: string; alt: string; // another prop }; export const RandomFox = ({ image, alt }: Props): JSX.Element => { // Lo que hicimos fue desestructurar el objeto props para // quedarnos solo con lo que necesitamos (image y alt) return ( <img width={320} height='auto' src={image} alt={alt} className='rounded' /> ); };
Nota: En dado caso de que queramos añadir una nueva prop, hay que definirle su tipo o sino TS nos da un error
// index.tsx import { NextPage } from 'next'; import Head from 'next/head' import { RandomFox } from '@/components/RandomFox'; const random = (): number => Math.floor(Math.random() * 123) + 1; const Home: NextPage = () => { return ( <> <Head> <title>React con TypeScript</title> <meta name="description" content="Generated by me" /> <meta name="viewport" content="width=device-width, initial-scale=1" /> <link rel="icon" href="/favicon.ico" /> </Head> <main> <RandomFox alt='zorrito' image={`https://randomfox.ca/images/${random()}.jpg`} /> {/* Si tenemos que mandar otra prop hay que definirla en nuestro tipo Props */} </main> <footer> El mejor footer de la historia </footer> </> ) } export default Home;
Diego Valdes
Tengo duda con las children, en que parte del curso se vieron? en esta clase solo se vieron las props
Fernando Orozco Velasquez
Recuerda que "children" es una propiedad que viene dentro del objeto "prop"
Enrique Aguilera
Recuerden que any es el enemigo🤣
César Augusto Cortés Labrada
Diego Reyes Cabrera
En todos lados he visto que el tipado que se le debe dar a children es React.ReactNode bro. No sé si es el estándar. En el video no se habla nada sobre children.
César Augusto Cortés Labrada
José Luis Manco Velásquez
Any = PELIGRO!!!
Juan Camilo Noreña López
Una pregunta de typescript, ¿como se puede definir un dato que no sea obligatorio ?
Juan David Saldarriaga Ospina
Podríamos usar el signo ? al definir las props, de esta forma lo tomará como un valor opcional:
interface Props { name: string; age?: number; }
Para casos en que podamos recibir propiedades opcionales se debe tener cuidado, o definir algún valor por defecto para que no genere error en la vista si esta propiedad opcional no la recibe el componente
Armando Rivera
Cuándo y porqué usar type en lugar de interface
Fernando Orozco Velasquez
La diferencia radica que al usar Interface podes aplicar Herencia en cambio con Type no
Jose Ever Muñoz Muñoz
type es para typar algo rapidamente sin pensar en que mas adelante tendremos otro tipo similar.
interface se utiliza cuando tenemos un archivo espefico con todos los tipos que puede ser types.ts o types/index.ts. Dentro de este archivo a veces nos encontramos con que algunos tipos son muy similares asi que creamos una interface para heredar aquellas propiedades que son las mismas y cambiar las que no.
Edgar Molina
Los props, son propiedades de los componentes. Es un objeto que se tipea como cualquier objeto.
Harold Zurita Simon
Jhon Eduard Bocanegra Ortiz
Alguien sabe cual es el tema que usa?
Ismael Cruz Procel
En lo personal se me hace dificil de leer:
Antony Jose Cabeza Rauseo
Cuál sería el tipo para el children? No me terminó de quedar claro 😥
Juan David Saldarriaga Ospina
Para hacer uso de un elemento children podemos usar el tipo que también React nos brinda, React. ReactNode de esta forma:
interface Props { children: React.ReactNode; } export const Component = ({ children }: Props) => { return <ul>{children}</ul>; };
Saul Florez
Si quisiera que typescript me permita pasar como props más atributos de la etiqueta Img debo definirlos uno a uno o existe otra solución?
Ejemplo
type Props = { image: string alt: string width: number … }
Juan Carlos Montilla Sánchez
Hola, Saul.
Al parecer sí, yo en la mayoría de código que he visto en TS se escriben por separados, ya sea sus alias (types) o interface.
Lo que he visto que en types pueden ser opcional los valores, según veo un ejemplo de la documentación de Typescript
type Person = { name: string; age: number; }; function greet(person: Person) { return "Hello " + person.name; }
Alexander Gonzalez
CÓMO TIPAR UN CHILDREN: https://blog.logrocket.com/using-react-children-prop-with-typescript/
Recordemos que children es una propiedad que viene dentro del objeto prop EJEMPLO 1:
Aquí vemos que le paso la etiqueta <figcaption> como children a <RandomFox>
import { RandomFox } from '@/components/RandomFox'; const randomNum = ()=> Math.floor(Math.random()*123 + 1); export default function Home() { return ( <div> <main> <p>Chikorita Papu!!</p> <RandomFox img={randomNum()}> <figcaption>Fox image</figcaption> //children </RandomFox> </main> </div> ) }
Ahora veamos el componente como se ve:
Vemos que, usando un alias creo el type props y este guarda la propiedad img y la propiedad children; img es tipado como number en mi caso y children es tipado como JSX.Element. De esta manera no obtenemos error.
type props = { img: number; children: JSX.Element; } function RandomFox({img, children}: props ) : JSX.Element{ return ( <figure> <img src={`https://randomfox.ca/images/${img}.jpg`} alt="fox img" width={320} height={"auto"} className="mt-3"/> {children} </figure> ) } export {RandomFox}
¿Y si queremos más de un hijo? Recordemos que más hijos forman un array de hijos.
<RandomFox img={randomNum()}> <figcaption>Fox image</figcaption> <p>Other child</p> </RandomFox>
En el componente sólo debemos decir que queremos que nuestro children admita también un array de JSX.Element.
type props = { img: number; children: JSX.Element | JSX.Element[]; } function RandomFox({img, children}: props ) : JSX.Element{ return ( <figure> <img src={`https://randomfox.ca/images/${img}.jpg`} alt="fox img" width={320} height={"auto"} className="mt-3"/> {children} </figure> ) } export {RandomFox}
Al menos así entendí como se debe hacer, espero correcciones si son necesarias.
Si, también es una manera. En el artículo que compartí se habla de usar ReactNode
import { ReactNode } from 'react' type FooProps = { name: 'foo' // look here 👇 children: ReactNode } export const Foo = (props: FooProps) => { return props.children }
Explican que esto se puede debido a la forma en que está definido el tipo PropsWithChildren
type PropsWithChildren<P> = P & { children?: ReactNode };
🧩 Formas de tipar props en un componente con TypeScript
En React + TypeScript, existen varias maneras de definir las props de un componente. Veamos las más comunes 👇
🟨 1️⃣ Tipado directo en los parámetros
export const RandomFox = (props: { image: string }): JSX.Element => { return <img width={320} height="auto" src={props.image} className="rounded" />; };
📌 Aquí estamos diciendo que props es un objeto con una propiedad:
image: string 🖼️⚠️ Funciona, pero no es muy mantenible si el componente crece o tiene muchas props.
🟦 2️⃣ Crear un tipo para las props
type Props = { image: string }; export const RandomFox = (props: Props): JSX.Element => { return <img width={320} height="auto" src={props.image} className="rounded" />; };
💡 Ventajas:
🟪 3️⃣ Desestructuración de props
type Props = { image: string }; export const RandomFox = ({ image }: Props): JSX.Element => { return <img width={320} height="auto" src={image} className="rounded" />; };
✨ Aquí usamos destructuring:
props.image, obtenemos la prop directamente: image🔑 Recomendación práctica
type Props y destructuringJSX.Element para más claridad 💎Hay dos formas para poder enviar los props, sin embargo el tiparlo es la más recomendada y fácil de mantener.
Está es la forma recomendada y estándar, ya que es más especifica.
type Props = { image: string, } // destructing de las props es mejor export const RandomFox = ({image}: Props): JSX.Element => { return ( <img src={image} width="420" height='auto' className="rounded" /> ) }
Aún no es la recomendada es otra opción.
type Props = { image: string, } export const RandomFox = (props: Props): JSX.Element => { return ( <img src={props.image} width="420" height='auto' className="rounded" /> ) }
Está es otra forma pero no se recomienda su uso ya que es díficil de mantener.
export const RandomFox = (props: {image: string}): JSX.Element => {; return ( <img src={props.image} width="420" height='auto' className="rounded" /> ) }