Adicionando Interatividade

Alguns elementos na tela se atualizam em resposta às entradas do usuário. Por exemplo, ao clicar em uma galeria de imagens, a imagem ativa é trocada. Em React, os dados que mudam ao longo do tempo são chamados de state. Você pode adicionar states a qualquer componente, e atualizá-los quando necessário. Neste capítulo, você aprenderá como escrever componentes que gerenciam interações, atualizam seus states, e apresentam diferentes saídas ao longo do tempo.

Respondendo a eventos

Componentes embutidos, a exemplo do <button> apenas são compatíveis com eventos de navegador, como onClick.

No entanto, você também pode criar seus próprios componentes e atribuir aos props de seus manipuladores de eventos quaisquer nomes específicos da aplicação que considerar adequados.

export default function App() {
  return (
    <Toolbar
      onPlayMovie={() => alert('Playing!')}
      onUploadImage={() => alert('Uploading!')}
    />
  );
}

function Toolbar({ onPlayMovie, onUploadImage }) {
  return (
    <div>
      <Button onClick={onPlayMovie}>
        Play Movie
      </Button>
      <Button onClick={onUploadImage}>
        Upload Image
      </Button>
    </div>
  );
}

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

Ready to learn this topic?

Leia Respondendo a Eventos para aprender como adicionar manipuladores de eventos.

Read More

State: A memória de um componente

Componentes necessitam de alterar frequentemente o que está na tela como resultado de uma interação. O campo de entrada será atualizado ao digitar em um formulário, a imagem exibida será trocada ao clicar em “próxima” em um carrossel de imagens, um produto é colocado no carrinho de compras ao clicar em “comprar”. Componentes precisam “memorizar” informações: o valor de entrada ou a imagem atual, assim como o carrinho de compras, por exemplo. Em React, este tipo de memória específica de componente é chamada de state.

É possível adicionar states a componentes com um Hook useState. Hooks são funções especiais que possibilitam que seus componentes utilizem recursos do React (como o state, por exemplo). O Hook useState possibilita a declaração de uma variável de estado. Este recurso recebe o state inicial e retorna um par de valores: o state atual e uma função setter, que possibilita atualizá-lo.

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

Veja como uma galeria de imagens utiliza e atualiza um state com cliques:

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}>
        Next
      </button>
      <h2>
        <i>{sculpture.name} </i>
        by {sculpture.artist}
      </h2>
      <h3>
        ({index + 1} of {sculptureList.length})
      </h3>
      <button onClick={handleMoreClick}>
        {showMore ? 'Hide' : 'Show'} details
      </button>
      {showMore && <p>{sculpture.description}</p>}
      <img
        src={sculpture.url}
        alt={sculpture.alt}
      />
    </>
  );
}

Ready to learn this topic?

Leia State: A Memória de um Componente para aprender como memorizar um valor e atualizá-lo com interatividade.

Read More

Renderizar e confirmar

Antes que seus componentes sejam exibidos na tela, eles devem ser renderizados pelo React.

O entendimento dos passos neste processo irá ajudá-lo a pensar sobre como o seu código executa e explicará seu comportamento.

Imagine que seus componentes são chefs na cozinha, montando pratos saborosos a partir de ingredientes. Neste cenário, o React é o garçom que recebe as solicitações dos clientes e lhes traz o que foi pedido. Este processo de solicitar e servir a UI consiste em tres etapas:

  1. Acionamento da renderização (entrega do pedido do cliente à cozinha)
  2. Renderização do componente (preparo da solicitação na cozinha)
  3. Confirmação ao DOM (disponibilização do pedido na mesa)
  1. O React como um garçom em um restaurante, obtendo as solicitações dos usuários e entregando-as à cozinha dos componentes.
    Acionamento
  2. O chef Card fornece ao React um componente de Card preparado na hora.
    Renderização
  3. O React disponibiliza o Card para o usuário em sua mesa.
    Confirmação

Illustrated by Rachel Lee Nabors

Ready to learn this topic?

Leia Renderizar e Confirmar para aprender sobre a atualização do ciclo de vida de uma UI.

Read More

State como uma foto instantânea

Diferentemente de variáveis regulares do JavaScript, o state do React se comporta mais como uma foto instantânea. Definí-lo não altera a variável state que você já possui, mas ao invés disso, ativa uma nova renderização. Isso pode ser surpreendente no início!

console.log(count); // 0
setCount(count + 1); // Solicitação de uma nova renderização com 1
console.log(count); // Ainda 0!

Este comportamento lhe ajuda a evitar bugs sutis. Aqui está um pequeno aplicativo de mensagens. Tente supor o que acontece se você pressionar “Send” primeiramente e depois alterar o destinatário para Bob. Qual nome aparecerá no alert após cinco segundos?

import { useState } from 'react';

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

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

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

Ready to learn this topic?

Leia State como uma Foto Instantânea para aprender por que o state parece “fixo” e imutável dentro dos manipuladores de eventos.

Read More

Enfileirando uma série de atualizações no state

Este componente contém bugs: clicar em “+3” incrementa a pontuação em apenas uma unidade.

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>Score: {score}</h1>
    </>
  )
}

State como uma Foto Instantânea explica por que isso está acontecendo. Definir o state solicita uma nova renderização, mas não o altera no código já em execução. Então score continua a ser 0 logo depois de você chamar 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

Você pode consertar isso passando uma função de atualização ao definir o state. Perceba como a substituição de setScore(score + 1) por setScore(s => s + 1) conserta o botão “+3”. Isso lhe possibilita enfileirar múltiplas atualizações de state.

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>Score: {score}</h1>
    </>
  )
}

Ready to learn this topic?

Leia Enfileirando uma Série de Atualizações no State para aprender como enfileirar uma sequência de atualizações no state.

Read More

Atualizando objetos no state

O state pode conter qualquer tipo de valor do JavaScript, inclusive objetos. Mas você não deve alterar diretamente os objetos e arrays que mantém no state do React. Em vez disso, quando desejar atualizar um objeto e array, você precisa criar um novo (ou fazer uma cópia de um existente) e, em seguida, definir o state para usar essa cópia.

Normalmente, você utilizará a sintaxe de spread ... para copiar objetos e arrays que deseja alterar. Por exemplo, a atualização de um objeto aninhado funcionaria assim:

import { useState } from 'react';

export default function Form() {
  const [person, setPerson] = useState({
    name: 'Niki de Saint Phalle',
    artwork: {
      title: 'Blue Nana',
      city: 'Hamburg',
      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>
        Name:
        <input
          value={person.name}
          onChange={handleNameChange}
        />
      </label>
      <label>
        Title:
        <input
          value={person.artwork.title}
          onChange={handleTitleChange}
        />
      </label>
      <label>
        City:
        <input
          value={person.artwork.city}
          onChange={handleCityChange}
        />
      </label>
      <label>
        Image:
        <input
          value={person.artwork.image}
          onChange={handleImageChange}
        />
      </label>
      <p>
        <i>{person.artwork.title}</i>
        {' by '}
        {person.name}
        <br />
        (located in {person.artwork.city})
      </p>
      <img
        src={person.artwork.image}
        alt={person.artwork.title}
      />
    </>
  );
}

Caso copiar objetos no código fique entediante, você pode utilizar uma biblioteca como Immer para reduzir o código repetitivo:

{
  "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": {}
}

Ready to learn this topic?

Leia Atualizando Objetos no State para aprender como atualizar objetos corretamente.

Read More

Atualizando arrays no state

Arrays são outro tipo de objetos mutáveis do JavaScript que podem ser armazenados no state. É recomendado que sejam tratados como somente leitura. Assim como objetos, ao atualizar um array armazenado no state, é necessário criar um novo (ou realizar a cópia de um existente), e depois definir o state para utilizar o novo array:

import { useState } from 'react';

const initialList = [
  { id: 0, title: 'Big Bellies', seen: false },
  { id: 1, title: 'Lunar Landscape', seen: false },
  { id: 2, title: 'Terracotta Army', 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>Art Bucket List</h1>
      <h2>My list of art to see:</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>
  );
}

Caso copiar arrays no código fique entediante, você pode utilizar uma biblioteca como Immer para reduzir o código repetitivo:

{
  "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": {}
}

Ready to learn this topic?

Leia Atualizando Arrays no State para aprender como atualizar arrays corretamente.

Read More

O que vem a seguir?

Vá até Respondendo a Eventos para começar a ler este capítulo página por página!

Ou, se você já está familiarizado com estes tópicos, por que não ler sobre Gerenciando o Estado?