[ Web Proxy ]
URL:
Viewing: https://es.react.dev/learn/adding-interactivity [Back]  [Original]

Agregar interactividad React

Agregar interactividad

Algunas cosas en la pantalla se actualizan en respuesta a la entrada del usuario. Por ejemplo, hacer clic en una galera de imgenes cambia la imagen activa. En React, los datos que cambian con el tiempo se denominan estado. Puedes agregar estado a cualquier componente y actualizarlo segn sea necesario. En este captulo, aprenders a escribir componentes que controlen interacciones, actualicen tu estado y muestren resultados diferentes a lo largo del tiempo.

Responder a eventos

React te permite agregar controladores de eventos a tu JSX. Los controladores de eventos son tus propias funciones que se activarn en respuesta a las interacciones del usuario, como hacer clic, pasar el mouse, enfocarse en las entradas de un formulario, etc.

Los componentes integrados como <button> solo admiten eventos de navegador integrados como onClick. Sin embargo, tambin puedes crear tus propios componentes y darle a sus props de controladores de eventos los nombres especficos de la aplicacin que desees.

App.js
Reiniciar
export default function App() {
  return (
    <Toolbar
      onPlayMovie={() => alert('Reproduciendo!')}
      onUploadImage={() => alert('Cargando!')}
    />
  );
}

function Toolbar({ onPlayMovie, onUploadImage }) {
  return (
    <div>
      <Button onClick={onPlayMovie}>
        Reproducir pelcula
      </Button>
      <Button onClick={onUploadImage}>
        Cargar imagen
      </Button>
    </div>
  );
}

function Button({ onClick, children }) {
  return (
    <button onClick={onClick}>
      {children}
    </button>
  );
}

Mostrar ms

Listo para aprender este tema?

Lee Responder a eventos para aprender cmo agregar controladores de eventos.

Lee ms

El estado: la memoria de un componente

Los componentes a menudo necesitan cambiar lo que aparece en la pantalla como resultado de una interaccin. Escribir en el formulario debera actualizar el campo de entrada, hacer clic en siguiente en un carrusel de imgenes debera cambiar la imagen que se muestra, hacer clic en comprar pone un producto en el carrito de compras. Los componentes necesitan recordar cosas: el valor de entrada actual, la imagen actual, el carrito de compras. En React, este tipo de memoria especfica del componente se llama estado.

Puedes agregar estado a un componente con un useState Hook. Los Hooks son funciones especiales que permiten que tus componentes usen funciones de React (el estado es una de esas funciones). El Hook useState te permite declarar una variable de estado. Toma el estado inicial y devuelve un par de valores: el estado actual y una funcin de establecimiento de estado que te permite actualizarlo.

const [index, setIndex] = useState(0);
const [showMore, setShowMore] = useState(false);

As es como una galera de imgenes usa y actualiza el estado al hacer clic:

App.js
Reiniciar
import { useState } from 'react';
import { sculptureList } from './data.js';

export default function Gallery() {
  const [index, setIndex] = useState(0);
  const [showMore, setShowMore] = useState(false);
  const hasNext = index < sculptureList.length - 1;

  function handleNextClick() {
    if (hasNext) {
      setIndex(index + 1);
    } else {
      setIndex(0);
    }
  }

  function handleMoreClick() {
    setShowMore(!showMore);
  }

  let sculpture = sculptureList[index];
  return (
    <>
      <button onClick={handleNextClick}>
        Siguiente
      </button>
      <h2>
        <i>{sculpture.name} </i>
        por {sculpture.artist}
      </h2>
      <h3>
        ({index + 1} de {sculptureList.length})
      </h3>
      <button onClick={handleMoreClick}>
        {showMore ? 'Ocultar' : 'Mostrar'} detalles
      </button>
      {showMore && <p>{sculpture.description}</p>}
      <img
        src={sculpture.url}
        alt={sculpture.alt}
      />
    </>
  );
}

Mostrar ms

Listo para aprender este tema?

Lee El estado: la memoria de un componente para aprender a recordar un valor y actualizarlo en la interaccin.

Lee ms

Renderizado y confirmacin

Antes de que tus componentes se muestren en la pantalla, deben ser renderizados por React. Comprender los pasos de este proceso te ayudar a pensar en cmo se ejecuta tu cdigo y explicar su comportamiento.

Imagina que tus componentes son cocineros en la cocina, montando sabrosos platos a partir de los ingredientes. En este escenario, React es el camarero que hace las peticiones de los clientes y les trae sus pedidos. Este proceso de solicitud y servicio de UI tiene tres pasos:

  1. Desencadenamiento de un renderizado (entrega del pedido del cliente a la cocina)
  2. Renderizado del componente (preparacin del pedido en la cocina)
  3. Confirmacin con el DOM (poner el pedido sobre la mesa)

Listo para aprender este tema?

Lee Renderizado y confirmacin para conocer el ciclo de vida de una actualizacin de la interfaz de usuario.

Lee ms

El estado como una instantnea

A diferencia de las variables regulares de JavaScript, el estado de React se comporta ms como una instantnea. Establecerlo no cambia la variable de estado que ya tienes, sino que activa una nuevo renderizado. Esto puede ser sorprendente al principio!

console.log(count); // 0
setCount(count + 1); // Solicitar un nuevo renderizado con 1.
console.log(count); // Todava 0!

Este comportamiento te ayuda a evitar errores sutiles. Aqu hay una pequea aplicacin de chat. Intenta adivinar qu sucede si presionas Enviar primero y luego cambias el destinatario a Bob. El nombre de quin aparecer en la alerta (alert) cinco segundos despus?

App.js
Reiniciar
import { useState } from 'react';

export default function Form() {
  const [to, setTo] = useState('Alice');
  const [message, setMessage] = useState('Hola');

  function handleSubmit(e) {
    e.preventDefault();
    setTimeout(() => {
      alert(`Le dijiste ${message} a ${to}`);
    }, 5000);
  }

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Para:{' '}
        <select
          value={to}
          onChange={e => setTo(e.target.value)}>
          <option value="Alice">Alice</option>
          <option value="Bob">Bob</option>
        </select>
      </label>
      <textarea
        placeholder="Mensaje"
        value={message}
        onChange={e => setMessage(e.target.value)}
      />
      <button type="submit">Enviar</button>
    </form>
  );
}

Mostrar ms

Listo para aprender este tema?

Lee El estado como una instantnea para saber por qu el estado aparece fijo y sin cambios dentro de los controladores de eventos.

Lee ms

Poner en cola una serie de actualizaciones de estado

Este componente tiene errores: hacer clic en +3 incrementa la puntuacin solo una vez.

App.js
Reiniciar
import { useState } from 'react';

export default function Counter() {
  const [score, setScore] = useState(0);

  function increment() {
    setScore(score + 1);
  }

  return (
    <>
      <button onClick={() => increment()}>+1</button>
      <button onClick={() => {
        increment();
        increment();
        increment();
      }}>+3</button>
      <h1>Puntaje: {score}</h1>
    </>
  )
}

Mostrar ms

El estado como una instantnea explica por qu sucede esto. Al establecer el estado se solicita un nuevo rerenderizado, pero no lo cambia en el cdigo que ya se est ejecutando. Entonces score sigue siendo 0 justo despus de llamar a setScore(score + 1).

console.log(score); // 0
setScore(score + 1); // setScore(0 + 1);
console.log(score); // 0
setScore(score + 1); // setScore(0 + 1);
console.log(score); // 0
setScore(score + 1); // setScore(0 + 1);
console.log(score); // 0

Puedes solucionar esto pasando una funcin de actualizacin al configurar el estado. Observa cmo reemplazar setScore(score + 1) con setScore(s => s + 1) corrige el botn +3. Esto te permite poner en cola mltiples actualizaciones de estado.

App.js
Reiniciar
import { useState } from 'react';

export default function Counter() {
  const [score, setScore] = useState(0);

  function increment() {
    setScore(s => s + 1);
  }

  return (
    <>
      <button onClick={() => increment()}>+1</button>
      <button onClick={() => {
        increment();
        increment();
        increment();
      }}>+3</button>
      <h1>Puntaje: {score}</h1>
    </>
  )
}

Mostrar ms

Listo para aprender este tema?

Lee Poner en cola una serie de actualizaciones del estado para obtener informacin sobre cmo poner en cola una secuencia de actualizaciones de estado.

Lee ms

Actualizar objetos en el estado

El estado puede contener cualquier tipo de valor de JavaScript, incluidos los objetos. Pero no debes cambiar los objetos y arrays que tienes en el estado de React directamente. En cambio, cuando desees actualizar un objeto y un array, debes crear uno nuevo (o hacer una copia de uno existente) y luego actualizar el estado para usar esa copia.

Por lo general, usars la sintaxis de propagacin ... para copiar objetos y arrays que desees cambiar. Por ejemplo, actualizar un objeto

App.js
Reiniciar
import { useState } from 'react';

export default function Form() {
  const [person, setPerson] = useState({
    name: 'Niki de Saint Phalle',
    artwork: {
      title: 'Nana azul',
      city: 'Hamburgo',
      image: 'https://i.imgur.com/Sd1AgUOm.jpg',
    }
  });

  function handleNameChange(e) {
    setPerson({
      ...person,
      name: e.target.value
    });
  }

  function handleTitleChange(e) {
    setPerson({
      ...person,
      artwork: {
        ...person.artwork,
        title: e.target.value
      }
    });
  }

  function handleCityChange(e) {
    setPerson({
      ...person,
      artwork: {
        ...person.artwork,
        city: e.target.value
      }
    });
  }

  function handleImageChange(e) {
    setPerson({
      ...person,
      artwork: {
        ...person.artwork,
        image: e.target.value
      }
    });
  }

  return (
    <>
      <label>
        Nombre:
        <input
          value={person.name}
          onChange={handleNameChange}
        />
      </label>
      <label>
        Ttulo:
        <input
          value={person.artwork.title}
          onChange={handleTitleChange}
        />
      </label>
      <label>
        Ciudad:
        <input
          value={person.artwork.city}
          onChange={handleCityChange}
        />
      </label>
      <label>
        Imagen:
        <input
          value={person.artwork.image}
          onChange={handleImageChange}
        />
      </label>
      <p>
        <i>{person.artwork.title}</i>
        {' de '}
        {person.name}
        <br />
        (ubicado en {person.artwork.city})
      </p>
      <img
        src={person.artwork.image}
        alt={person.artwork.title}
      />
    </>
  );
}

Mostrar ms

Si copiar objetos en el cdigo se vuelve tedioso, puedes usar una biblioteca como Immer para reducir el cdigo repetitivo:

package.json
Reiniciar
{
  "dependencies": {
    "immer": "1.7.3",
    "react": "latest",
    "react-dom": "latest",
    "react-scripts": "latest",
    "use-immer": "0.5.1"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject"
  },
  "devDependencies": {}
}

Listo para aprender este tema?

Lee Actualizar objetos en el estado para aprender cmo actualizar objetos correctamente.

Lee ms

Actualizar arrays en el estado

Los arrays son otro tipo de objetos de JavaScript mutables que puedes almacenar en el estado y debes tratar como de solo lectura. Al igual que con los objetos, cuando deseas actualizar un array almacenado en el estado, se debe crear uno nuevo (o hacer una copia de uno existente) y luego configurar el estado para utilizar el nuevo array:

App.js
Reiniciar
import { useState } from 'react';

const initialList = [
  { id: 0, title: 'Grandes barrigas', seen: false },
  { id: 1, title: 'Paisaje lunar', seen: false },
  { id: 2, title: 'Guerreros de terracota', seen: true },
];

export default function BucketList() {
  const [list, setList] = useState(
    initialList
  );

  function handleToggle(artworkId, nextSeen) {
    setList(list.map(artwork => {
      if (artwork.id === artworkId) {
        return { ...artwork, seen: nextSeen };
      } else {
        return artwork;
      }
    }));
  }

  return (
    <>
      <h1>Lista de deseos de arte</h1>
      <h2>Mi lista de arte para ver:</h2>
      <ItemList
        artworks={list}
        onToggle={handleToggle} />
    </>
  );
}

function ItemList({ artworks, onToggle }) {
  return (
    <ul>
      {artworks.map(artwork => (
        <li key={artwork.id}>
          <label>
            <input
              type="checkbox"
              checked={artwork.seen}
              onChange={e => {
                onToggle(
                  artwork.id,
                  e.target.checked
                );
              }}
            />
            {artwork.title}
          </label>
        </li>
      ))}
    </ul>
  );
}

Mostrar ms

Si copiar arrays en el cdigo se vuelve tedioso, puedes usar una biblioteca como Immer para reducir el cdigo repetitivo:

package.json
Reiniciar
{
  "dependencies": {
    "immer": "1.7.3",
    "react": "latest",
    "react-dom": "latest",
    "react-scripts": "latest",
    "use-immer": "0.5.1"
  },
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test --env=jsdom",
    "eject": "react-scripts eject"
  },
  "devDependencies": {}
}

Listo para aprender este tema?

Lee Actualizar arrays en el estado para aprender a actualizar arrays correctamente.

Lee ms

Qu sigue?

Dirgete a Responder a eventos para comenzar a leer este captulo pgina por pgina.

O, si ya ests familiarizado con estos temas, por qu no lees sobre Gestin del estado?


Web Proxy Viewer  |  New URL  |  Original Page