One place for hosting & domains

      Como personalizar os componentes React com props


      O autor selecionou a Creative Commons para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Neste tutorial você criará componentes personalizados passando props (que significa propriedades) aos seus componentes. Props são argumentos que você fornece a um elemento JSX. Elas se parecem com os props padrão do HTML, mas não são pré-definidos e podem ter diferentes tipos de dados JavaScript, incluindo números, strings, funções, matrizes e até mesmo outros componentes React. Seus componentes personalizados utilizam props para exibir dados ou utilizá-los para fazer os componentes interagirem. Os props são parte fundamental da criação de componentes adaptáveis para situações diferentes. Aprender como usá-los dará a você as ferramentas necessárias para desenvolver componentes personalizados para lidar com situações únicas.

      Após adicionar os props aos componentes, você utilizará o PropTypes para definir o tipo de dados que você espera que um componente receba. O PropTypes é um sistema de tipos simples que verifica se os dados correspondem aos tipos esperados no ambiente de execução. Ele serve como uma documentação e verificador de erros que ajudará você a manter seu aplicativo previsível à medida que ele for escalonado.

      Ao final deste tutorial, você utilizará uma variedade de props para desenvolver um aplicativo pequeno que receberá uma matriz de dados de animais. Ela mostrará informações como nome, nome científico, tamanho, dieta e outras informações.

      Nota: o primeiro passo define um projeto em branco no qual você desenvolverá o exercício do tutorial. Se você já tiver um projeto de trabalho e deseja ir diretamente ao trabalho com os props, vá para o Passo 2.

      Pré-requisitos

      Passo 1 — Criando um projeto vazio

      Neste passo, você criará um novo projeto utilizando o Create React App. Em seguida, você excluirá o projeto de exemplo e os arquivos relacionados que foram instalados durante a inicialização dele. Por fim, você criará uma estrutura de arquivos simples para organizar seus componentes.

      Para começar, crie um novo projeto. Em sua linha de comando, execute o script a seguir para instalar um novo projeto usando o create-react-app:

      • npx create-react-app prop-tutorial

      Após o projeto ser finalizado, vá para o diretório:

      Em uma nova guia ou janela do terminal, inicie o projeto usando o script start do Create React App. O navegador irá atualizar automaticamente com as alterações. Dessa forma, deixe este script em execução durante todo o tempo em que você estiver trabalhando:

      Você receberá um servidor local em execução. Se o projeto não abriu na janela de um navegador, você pode abri-lo indo para http://localhost:3000/. Se o estiver executando em um servidor remoto, o endereço será http://your_domain:3000.

      Seu navegador carregará com um aplicativo simples do React, que vem incluído como parte do Create React App:

      Projeto modelo do React

      Você desenvolverá um conjunto completamente novo de componentes personalizados. Você começará seu projeto removendo um pouco do código boilerplate para que você possa ter um projeto vazio.

      Para iniciar, abra o src/App.js em um editor de texto. Esse é o componente raiz que é injetado na página. Todos os componentes iniciarão a partir daqui. Saiba mais sobre o App.js em Como configurar um projeto React com o Create React App.

      Abra o src/App.js com o seguinte comando:

      Você verá um arquivo como este:

      prop-tutorial/src/App.js

      import React from 'react';
      import logo from './logo.svg';
      import './App.css';
      
      function App() {
        return (
          <div className="App">
            <header className="App-header">
              <img src={logo} className="App-logo" alt="logo" />
              <p>
                Edit <code>src/App.js</code> and save to reload.
              </p>
              <a
                className="App-link"
                href="https://reactjs.org"
                target="_blank"
                rel="noopener noreferrer"
              >
                Learn React
              </a>
            </header>
          </div>
        );
      }
      
      export default App;
      

      Exclua a linha import logo from './logo.svg';. Em seguida, substitua tudo na instrução return para retornar um conjunto de tags vazias: <></>. Isso dará a você uma página de validação que não retorna nada. O código final ficará parecido com este:

      prop-tutorial/src/App.js

      
      import React from 'react';
      import './App.css';
      
      function App() {
        return <></>;
      }
      
      export default App;
      

      Salve e saia do editor de texto.

      Por fim, exclua o logo. Você não o usará neste seu aplicativo e é aconselhável remover arquivos não utilizados durante o trabalho. Isso evitará confusões futuras.

      Na janela do terminal, digite o seguinte comando:

      Se você olhar em seu navegador, verá uma tela vazia.

      tela vazia no chrome

      Com o projeto de exemplo do Create React App limpo, crie uma estrutura de arquivos simples. Isso ajudará você a manter os componentes isolados e independentes.

      Crie um diretório chamado components no diretório src. Ele terá todos os seus componentes personalizados.

      Cada componente terá o próprio diretório para armazenar o arquivo de componente com os estilos, imagens (se houver) e testes.

      Crie um diretório para o App:

      Mova todos os arquivos App para esse diretório. Use o curinga * para selecionar quaisquer arquivos que comecem com App., independentemente da extensão. Depois, utilize o comando mv para colocá-los no novo diretório.

      • mv src/App.* src/components/App

      Por fim atualize o caminho de importação relativo em index.js, que é o componente raiz que inicializa todo o processo.

      A instrução de importação precisa apontar para o arquivo Apps.js no diretório App. Portanto, faça a seguinte alteração destacada:

      prop-tutorial/src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import './index.css';
      import App from './components/App/App';
      import * as serviceWorker from './serviceWorker';
      
      ReactDOM.render(
        <React.StrictMode>
          <App />
        </React.StrictMode>,
        document.getElementById('root')
      );
      
      // If you want your app to work offline and load faster, you can change
      // unregister() to register() below. Note this comes with some pitfalls.
      // Learn more about service workers: https://bit.ly/CRA-PWA
      serviceWorker.unregister();
      

      Salve e saia do arquivo.

      Agora que o projeto está configurado, crie o primeiro componente.

      Neste passo, você criará um componente que será modificado com base nas informações de entrada, chamadas props. Os props são argumentos que você passa para uma função ou classe. Como seus componentes são transformados em objetos semelhantes aos HTML pelo JSX, você passará os props como se fossem atributos do HTML. Diferente dos elementos HTML, você pode passar vários tipos de dados diferentes: strings, matrizes. objetos e até mesmo funções.

      Aqui, você criará um componente que exibirá as informações de animais. Esse componente terá o nome e nome científico do animal como strings, o tamanho como um número inteiro, a dieta será uma matriz de strings e as informações adicionais serão um objeto. Você passará as informações para o novo componente como props e as consumirá no componente.

      Ao final deste passo, você terá um componente que consumirá diferentes props. Você também reutilizará o componente para exibir uma matriz de dados usando um componente comum.

      Adicionando dados

      Primeiro, serão necessários dados de exemplo. Crie um arquivo no diretório src/App chamado data.

      • touch src/components/App/data.js

      Abra o novo arquivo em seu editor de texto:

      • nano src/components/App/data.js

      Em seguida, adicione uma matriz de objetos que será usada como exemplo:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: 140,
          diet: ['meat'],
        },
        {
          name: 'Gorilla',
          scientificName: 'Gorilla beringei',
          size: 205,
          diet: ['plants', 'insects'],
          additional: {
            notes: 'This is the eastern gorilla. There is also a western gorilla that is a different species.'
          }
        },
        {
          name: 'Zebra',
          scientificName: 'Equus quagga',
          size: 322,
          diet: ['plants'],
          additional: {
            notes: 'There are three different species of zebra.',
            link: 'https://en.wikipedia.org/wiki/Zebra'
          }
        }
      ]
      

      A matriz de objetos contém uma variedade de dados e dará a você a oportunidade de testar uma variedade de props. Cada objeto é um animal separado com o nome dele, o nome científico, o tamanho, a dieta e um campo opcional chamado additional que contém links ou anotações. Neste código você também exportou a matriz como default.

      Salve e saia do arquivo.

      Criando componentes

      Em seguida, crie um componente de espaço reservado chamado AnimalCard. Este componente eventualmente utilizará props e exibirá os dados.

      Primeiro, crie um diretório em src/components chamado AnimalCard. Em seguida, use o comando touch para criar um arquivo chamado src/components/AnimalCard/AnimalCard.js e um arquivo CSS chamado src/components/AnimalCard/AnimalCard.css.

      • mkdir src/components/AnimalCard
      • touch src/components/AnimalCard/AnimalCard.js
      • touch src/components/AnimalCard/AnimalCard.css

      Abra o AnimalCard.js no seu editor de texto:

      • nano src/components/AnimalCard/AnimalCard.js

      Adicione um componente básico que importa o CSS e retorna uma tag <h2>.

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard() {
        return <h2>Animal</h2>
      }
      

      Salve e saia do arquivo. Agora, é necessário que você importe os dados e os componentes em seu componente base App.

      Abra o src/components/App/App.js:

      • nano src/components/App/App.js

      Importe os dados e os componentes. Em seguida, faça um loop com os dados para retornar os componentes para cada item na matriz:

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      import data from './data';
      import AnimalCard from '../AnimalCard/AnimalCard';
      import './App.css';
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard key={animal.name}/>
            ))}
          </div>
        )
      }
      
      export default App;
      

      Salve e saia do arquivo. Aqui,utilize o método de matriz .map() para iterar os dados. Além da adição deste loop, você também terá uma div de quebra automática com uma classe que você utilizará para aplicação de estilo e uma tag <h1> para rotular seu projeto.

      Quando você salvar, o navegador será recarregado e você verá um rótulo para cada cartão.

      Projeto React no navegador sem estilo

      Em seguida, vamos aplicar o estilo para alinhar os itens. Abra o App.css:

      • nano src/components/App/App.css

      Para organizar os elementos, substitua o conteúdo pelo seguinte:

      prop-tutorial/src/components/App/App.css

      .wrapper {
          display: flex;
          flex-wrap: wrap;
          justify-content: space-between;
          padding: 20px;
      }
      
      .wrapper h1 {
          text-align: center;
          width: 100%;
      }
      

      Isso utilizará o flexbox para reorganizar os dados de modo que fiquem alinhados. O padding coloca um pouco de espaço na janela do navegador. O justify-content espalhará o espaço extra entre os elementos e o .wrapper h1 fornecerá a largura total do rótulo Animal.

      Salve e saia do arquivo. Quando fizer isso, o navegador será recarregado e você verá alguns dados espaçados.

      Projeto React no navegador com dados espaçados

      Adicionando props

      Com seus componentes configurados, adicione seu primeiro prop. Ao fazer o loop com os dados, você terá acesso a cada objeto na matriz data e a cada item que o objeto tem. Você adicionará cada um dos dados em um prop separado que você utilizará depois em seu componente AnimalCard.

      Abra App.js:

      • nano src/components/App/App.js

      Adicione um prop de name para AnimalCard.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard
                key={animal.name}
                name={animal.name}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      Salve e saia do arquivo. O prop name se parece com um atribuito HTML padrão, mas em vez de uma string, você passará a propriedade name do objeto animal entre chaves.

      Agora que você passou um prop para o novo componente, você precisa usá-lo. Abra o AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Todos os props que você passa para o componente são coletados em um objeto que será o primeiro argumento da função. Desestruture o objeto para extrair os props individuais:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      
      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard(props) {
        const { name } = props;
        return (
          <h2>{name}</h2>
        );
      }
      

      Observe que não é necessário desestruturar um prop para usá-lo. Esse é um método útil para lidar os com dados de exemplo neste tutorial.

      Após desestruturar o objeto, você pode usar os dados individuais. Neste caso, você utilizará o título em uma tag <h2>, colocando o valor entre chaves para que o React saiba avaliá-lo como JavaScript.

      Você também pode usar uma propriedade no objeto prop usando a notação de ponto. Por exemplo, crie um elemento <h2> assim: <h2>{props.title}</h2>. A vantagem da desestruturação é que você coleta os props não utilizados e usa o objeto operador rest.

      Salve e saia do arquivo. Quando fizer isso, o navegador será recarregado e você verá o nome específico para cada animal em vez de um espaço reservado.

      Projetos do React com nomes de animais renderizados

      A propriedade name é uma string, mas os props podem ser de qualquer tipo de dados que você poderia passar para uma função JavaScript. Para ver isto em funcionamento, adicione o resto dos dados.

      Abra o arquivo App.js:

      • nano src/components/App/App.js

      Adicione um prop para cada um dos seguintes: scientificName, size, diet e additional. Eles possuem strings, inteiros, matrizes e objetos.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {albums.map(album => (
              <AnimalCard
                additional={animal.additional}
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                scientificName={animal.scientificName}
                size={animal.size}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      Como está criando um objeto, você pode adicioná-los em qualquer ordem que quiser. A ordem alfabética facilita a busca em uma lista de props, principalmente em uma lista muito grande. Você também pode colocá-los na mesma linha. No entanto, separá-los um por linha facilita a leitura.

      Salve e feche o arquivo. Abra o AnimalCard.js.

      • nano src/components/AnimalCard/AnimalCard.js

      Desta vez, desestruture os props na lista de parâmetros das funções e use os dados no componente:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
        additional,
        diet,
        name,
        scientificName,
        size
      }) {
        return (
          <div>
            <h2>{name}</h2>
            <h3>{scientificName}</h3>
            <h4>{size}kg</h4>
            <div>{diet.join(', ')}.</div>
          </div>
        );
      }
      

      Após retirar os dados, adicione o scientificName e o size em tags de cabeçalho. Será necessário converter a matriz em uma string para que o React possa exibi-la na página. Faça isso com o join(', '), que criará uma lista separada por vírgula.

      Salve e feche o arquivo. Quando fizer isso, o navegador recarregará e você verá os dados estruturados.

      Projeto React com os animais com os dados completos

      Você poderia criar uma lista parecida com o objeto additional, mas, em vez disso, adicione uma função para alertar o usuário com os dados. Isso dará a você a chance de passar funções como props e utilizar os dados dentro de um componente ao chamar uma função.

      Abra App.js:

      • nano src/components/App/App.js

      Crie uma função chamada showAdditionalData, que converte o objeto em uma string e a exibirá como um alerta.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      
      function showAdditional(additional) {
        const alertInformation = Object.entries(additional)
          .map(information => `${information[0]}: ${information[1]}`)
          .join('n');
        alert(alertInformation)
      };
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard
                additional={animal.additional}
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                scientificName={animal.scientificName}
                showAdditional={showAdditional}
                size={animal.size}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      A função showAdditional converte o objeto para uma matriz de pares onde o primeiro item é a chave e o segundo é o valor. Em seguida, ele mapeia os dados convertendo o par de chaves para uma string. Depois, ele as junta com uma quebra de linha (n) antes de passar a string completa para a função de alerta.

      Como o JavaScript pode aceitar funções como argumentos, o React também aceita funções como props. Por este motivo, você pode passar o showAdditional para o AnimalCard como um prop chamado showAdditional.

      Salve e feche o arquivo. Abra o AnimalCard:

      • nano src/components/AnimalCard/AnimalCard.js

      Traga a função showAdditional do objeto props. Em seguida, crie um <button> com um evento onClick que chama a função com o objeto additional:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
        additional,
        diet,
        name,
        scientificName,
        showAdditional,
        size
      }) {
        return (
          <div>
            <h2>{name}</h2>
            <h3>{scientificName}</h3>
            <h4>{size}kg</h4>
            <div>{diet.join(', ')}.</div>
            <button onClick={() => showAdditional(additional)}>More Info</button>
          </div>
        );
      }
      

      Salve o arquivo. Quando fizer isso, o navegador será recarregado e você verá um botão após cada cartão. Quando você clicar no botão, receberá um alerta com os dados adicionais.

      Alerta com informações

      Se você tentar clicar em More Info para o Lion, receberá um erro. Isso acontece porque não existem dados adicionais para o leão. Você verá como corrigir isso no Passo 3.

      Finalmente, adicione um pouco de estilo ao cartão de música. Adicione um className de animal-wrapper ao div em AnimalCard:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
        return (
          <div className="animal-wrapper">
      ...
          </div>
        )
      }
      

      Salve e feche o arquivo. Abra o AnimalCard.css:

      • nano src/components/AnimalCard/AnimalCard.css

      Adicione o CSS para dar aos cartões e ao botão uma borda e um preenchimento:

      prop-tutorial/src/components/AnimalCard/AnimalCard.css

      .animal-wrapper {
          border: solid black 1px;
          margin: 10px;
          padding: 10px;
          width: 200px;
      }
      
      .animal-wrapper button {
          font-size: 1em;
          border: solid black 1px;
          padding: 10;
          background: none;
          cursor: pointer;
          margin: 10px 0;
      }
      

      Este CSS adicionará uma borda leve ao cartão e substituirá o estilo padrão do botão para um com borda e preenchimento. O cursor: pointer alterará o cursor quando você passar o mouse por cima do botão.

      Salve e feche o arquivo. Quando fizer isso, o navegador será recarregado e você verá os dados em cartões individuais.

      Projeto React com os cartões de animais com estilos aplicados

      Neste ponto, você criou dois componentes personalizados. Você passou dados para o segundo componente a partir do primeiro componente usando os props. Os props incluíram uma variedade de dados, como strings, números inteiros, matrizes, objetos e funções. Em seu segundo componente, você utilizou os props para criar um componente dinâmico usando o JSX.

      No próximo passo, você utilizará um sistema de tipos chamado de prop-types para especificar a estrutura que o componente espera ver. Este sistema criará uma previsibilidade em seu aplicativo e evitará bugs.

      Neste passo, você adicionará um sistema leve de tipos aos seus componentes com o PropTypes. O PropTypes age da mesma forma que outros sistemas de tipos, definindo explicitamente o tipo de dados que você espera receber de um certo prop. Ele também dá a você a chance de definir dados padronizados nos casos onde o prop não é muito necessário. Ao contrário da maioria dos sistemas de tipos, o PropTypes é um verificador do ambiente de execução. Desta forma, se os props não corresponderem ao tipo, o código ainda compilará, porém, ele exibirá um erro de console.

      Ao final deste passo, você adicionará a previsibilidade ao seu componente personalizado, definindo o tipo para cada prop. Isso garantirá que a próxima pessoa que trabalhar no componente tenha uma ideia clara sobre a estrutura dos dados de que o componente precisará.

      O pacote prop-types está incluído como parte da instalação do Create React App. Por este motivo, tudo que você precisa fazer é importá-lo em seu componente.

      Abra o AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Em seguida, importe o PropTypes do prop-types:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      

      Adicione o PropTypes diretamente à função do componente. Em JavaScript, as funções são objetos. Isso significa que você pode adicionar propriedades usando a sintaxe de ponto. Adicione os seguintes PropTypes para o AnimalCard.js:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      
      AnimalCard.propTypes = {
        additional: PropTypes.shape({
          link: PropTypes.string,
          notes: PropTypes.string
        }),
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
        name: PropTypes.string.isRequired,
        scientificName: PropTypes.string.isRequired,
        showAdditional: PropTypes.func.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Salve e feche o arquivo.

      Como você pode ver, existem vários tipos diferentes de PropTypes. Esta é apenas uma pequena amostra; consulte a documentação oficial do React para ver os outros PropTypes que você pode usar.

      Vamos começar pelo prop name. Aqui, você está especificando que name deve ser do tipo string. A propriedade scientificName é a mesma coisa. O size é um número que pode incluir floats como 1.5 e inteiros como 6. O showAdditional é uma função (func).

      O diet, por outro lado, é um pouco diferente. Neste caso, você está especificando que o diet será uma array, mas você também precisa especificar o que essa matriz conterá. Neste caso, a matriz conterá apenas strings. Se quiser misturar os tipos, utilize outro prop chamado de oneOfType, que recebe uma matriz de PropTypes válidos. Você pode utilizar o oneOfType em qualquer lugar. Se quiser que o size seja tanto um número quanto uma string, modifique-o para isto:

      size: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
      

      O prop additional também é um pouco mais complexo. Neste caso, você está especificando um objeto, mas, para ficar um pouco mais claro, você está declarando o que quer que o objeto contenha. Para fazer isso, utilize o PropTypes.shape, que recebe um objeto com campos adicionais que precisarão de seus próprios PropTypes. Neste caso, o link e o notes são ambos PropTypes.string.

      No momento, todos os dados estão bem estruturados e correspondem aos props. Para ver o que acontece se o PropTypes não for correspondido, abra seus dados:

      • nano src/components/App/data.js

      Modifique o tamanho para uma string no primeiro item:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: '140',
          diet: ['meat'],
        },
      ...
      ]
      

      Salve o arquivo. Quando fizer isso, o navegador recarregará e você verá um erro no console.

      Error

      index.js:1 Warning: Failed prop type: Invalid prop `size` of type `string` supplied to `AnimalCard`, expected `number`. in AnimalCard (at App.js:18) in App (at src/index.js:9) in StrictMode (at src/index.js:8)

      Navegador com erro de tipo

      Ao contrário de outros sistemas de tipos como o TypeScript, o PropTypes não dará um aviso a você no momento da compilação. Enquanto não houver erros, ele ainda compilará. Isso significa que você pode publicar um código com erros de prop acidentalmente.

      Modifique os dados de volta para o tipo correto:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: 140,
          diet: ['meat'],
        },
      ...
      ]
      

      Salve e feche o arquivo.

      Abra o AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Todo prop (com exceção do additional) possui a propriedade isRequired. Isso significa que eles são necessários. Se você não incluir um prop necessário, o código ainda compilará, mas você verá um erro do ambiente de execução no console.

      Se um prop não for necessário, você pode adicionar um valor padrão. Uma boa medida é sempre adicionar um valor padrão para evitar erros do ambiente de execução se um prop não for necessário. Por exemplo, no componente AnimalCard você está chamando uma função com os dados de additional. Se os dados não estiverem lá, a função tentará modificar um objeto que não existe e o aplicativo falhará.

      Para evitar este problema, adicione um defaultProp para o additional:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      
      AnimalCard.propTypes = {
        additional: PropTypes.shape({
          link: PropTypes.string,
          notes: PropTypes.string
        }),
      ...
      }
      
      AnimalCard.defaultProps = {
        additional: {
          notes: 'No Additional Information'
        }
      }
      

      Adicione o defaultProps à função usando a sintaxe de ponto da mesma forma que você fez com o propTypes. Em seguida, adicione um valor padrão que o componente deve usar se o prop for undefined. Neste caso, você está correspondendo o formato do additional incluindo uma mensagem de que não há informações adicionais.

      Salve e feche o arquivo. Quando fizer isso, o navegador recarregará. Após ele recarregar, clique no botão More Info para o Lion. Ele não possui um campo additional nos dados. Por este motivo, o prop está undefined. Porém, o AnimalCard será substituído no prop padrão.

      Navegador com a mensagem padrão no alerta

      Agora seus props estão bem documentados e são necessários ou possuem um padrão para garantir um código previsível. Isso ajudará que futuros desenvolvedores (incluindo você) entendam quais props de que um componente precisa. Ele facilitará a troca e a reutilização dos seus componentes, fornecendo informações completas sobre como o componente utilizará os dados que ele está recebendo.

      Conclusão

      Neste tutorial, você criou vários componentes que usam os props para exibir informações de um pai. Os props fornecem a flexibilidade que você precisa para começar a separar componentes maiores em partes menores e mais focadas. Agora que você não possui mais seus dados fortemente acoplados às informações de exibição, você pode fazer escolhas sobre como segmentar seu aplicativo.

      Os props são ferramentas importantes no desenvolvimento de aplicativos complexos. Eles dão a oportunidade de criar componentes que se adaptam aos dados que recebem. Com o PropTypes, você está criando componentes previsíveis e legíveis que darão a uma equipe a habilidade de reutilizar o trabalho uns dos outros para, desta maneira, criarem uma base de código flexível e estável. Se você quiser analisar mais tutoriais do React, dê uma olhada em nossa página sobre o React ou retorne à página da série Como Programar em React.js.



      Source link

      Настройка компонентов React с помощью свойств


      Автор выбрал Creative Commons для получения пожертвования в рамках программы Write for DOnations.

      Введение

      В этом руководстве вы создадите пользовательские компоненты, передавая свойства в ваш компонент. Свойства — это аргументы, которые вы предоставляете элементу JSX. Они выглядят как стандартные HTML-свойства, но не являются предопределенными и могут использовать несколько типов данных JavaScript, включая числа, строки, функции, массивы и даже другие компоненты React. Ваши пользовательские компоненты могут использовать свойства для отображения данных или использования этих данных, чтобы сделать компоненты интерактивным. Свойства — это ключ к созданию компонентов, которые можно легко адаптировать под разные ситуации, а их знание даст вам инструменты для разработки пользовательских компонентов, которые могут обрабатывать уникальные ситуации.

      После добавления свойств в ваш компонент вы будете использовать PropTypes для определения типа данных, которые ожидает компонент. PropTypes — это простая система типов для проверки того, что данные соответствуют ожидаемым типам во время исполнения. Они будут использоваться как в качестве документации, так и в качестве механизма проверки ошибок, который позволит сохранить прогнозируемое поведение вашего приложения по мере его масштабирования.

      К концу этого руководства вы сможете использовать разные свойства для создания небольшого приложения, которое будет использовать массив данных о животных и отображать информацию, включая имя, научное наименование, размер, питание и дополнительную информацию.

      Примечание. В качестве первого шага необходимо настроить пустой проект, на основе которого вы будете выполнять упражнение из руководства. Если у вас уже есть рабочий проект и вы хотите напрямую работать со свойствами, начните выполнение руководства с шага 2.

      Предварительные требования

      Шаг 1 — Создание пустого проекта

      На этом шаге мы создадим новый проект, используя Create React App. Затем вы удалите пример проекта и связанные файлы, которые устанавливаются при инициализации проекта. В заключение вы создадите простую структуру файлов для организации ваших компонентов.

      Создайте новый проект. В командной строке запустите следующий скрипт для установки нового проекта с помощью create-react-app:

      • npx create-react-app prop-tutorial

      После завершения создания проекта перейдите в его директорию:

      В новой вкладке или окне терминала запустите проект, используя скрипт start Create React App​​​. Браузер будет выполнять автообновление при изменениях, поэтому вы должны оставить этот скрипт работающим все время при работе:

      Вы получите запущенный локальный сервер. Если проект не был открыт в браузере, вы можете открыть его, перейдя на страницу http://localhost:3000/. Если вы запустили приложение на удаленном сервере, воспользуйтесь адресом http://your_IP_address:3000.

      Ваш браузер загрузит простое приложение React в качестве элемента Create React App:

      Шаблон проекта React

      Вы создадите совершенно новый набор пользовательских компонентов. Для начала избавьтесь от шаблонного кода, чтобы получить пустой проект.

      Откройте src/App.js в текстовом редакторе. Это корневой компонент, который встраивается в страницу. Все компоненты будут запускаться отсюда. Дополнительную информацию об App.js можно найти в статье Настройка проекта React с помощью Create React App.

      Откройте src/App.js с помощью следующей команды:

      Вы увидите следующий файл:

      prop-tutorial/src/App.js

      import React from 'react';
      import logo from './logo.svg';
      import './App.css';
      
      function App() {
        return (
          <div className="App">
            <header className="App-header">
              <img src={logo} className="App-logo" alt="logo" />
              <p>
                Edit <code>src/App.js</code> and save to reload.
              </p>
              <a
                className="App-link"
                href="https://reactjs.org"
                target="_blank"
                rel="noopener noreferrer"
              >
                Learn React
              </a>
            </header>
          </div>
        );
      }
      
      export default App;
      

      Удалите строку import logo from './logo.svg';​​. Затем замените весь код оператора return, который должен возвращать набор пустых тегов: <></>​​​. В результате вы получите страницу валидации, которая ничего не возвращает. Окончательный код будет выглядеть следующим образом:

      prop-tutorial/src/App.js

      
      import React from 'react';
      import './App.css';
      
      function App() {
        return <></>;
      }
      
      export default App;
      

      Сохраните изменения и закройте текстовый редактор.

      В заключение удалите логотип. Вы не будете использовать ее в вашем приложении. Кроме того, вам нужно удалить неиспользуемые файлы, которые не пригодятся вам в работе. Это позволит вам избежать путаницы в будущем.

      В окне терминала введите следующую команду:

      Если вы откроете ваш браузер, то увидите пустой экран.

      пустой экран в chrome

      Теперь, когда вы успешно очистили пример проекта Create React App, создайте простую структуру файлов. Это позволит вам поддерживать ваши компоненты изолированными и независимыми.

      Создайте каталог с именем components в каталоге src. В нем будут храниться все ваши пользовательские компоненты.

      Каждый компонент будет иметь собственный каталог для хранения файла компонента, а также стилей, изображений, если таковые имеются, и тестов.

      Создайте каталог для App:

      Переместите все файлы App в этот каталог. Используйте подстановочный символ * для выбора любых файлов, начинающихся с App. вне зависимости от их расширения. Затем используйте команду mv для их отправки в новый каталог.

      • mv src/App.* src/components/App

      В заключение обновите относительный путь импорта в index.js, который представляет собой корневой компонент и инициализирует весь процесс.

      Оператор импорта должен указывать на файл App.js в каталоге App, поэтому необходимо внести следующее изменение:

      prop-tutorial/src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import './index.css';
      import App from './components/App/App';
      import * as serviceWorker from './serviceWorker';
      
      ReactDOM.render(
        <React.StrictMode>
          <App />
        </React.StrictMode>,
        document.getElementById('root')
      );
      
      // If you want your app to work offline and load faster, you can change
      // unregister() to register() below. Note this comes with some pitfalls.
      // Learn more about service workers: https://bit.ly/CRA-PWA
      serviceWorker.unregister();
      

      Сохраните и закройте файл.

      Теперь, когда проект настроен, вы можете создать ваш первый компонент.

      Шаг 2 — Настройка динамических компонентов со свойствами

      На этом шаге вы создадите компонент, который будет изменяться на основе передаваемой информации, т.е. свойств. Свойства — это аргументы, которые вы передаете функции или классу, но так как ваши компоненты трансформируются в HTML-объекты с JSX, вы будете передавать свойства в виде HTML-атрибутов. В отличие от HTML-элементов, вы можете передавать множество разных типов данных, от строк до массивов, объектов и даже функций.

      Здесь вы создадите компонент, который будет отображать информацию о животных. Этот компонент будет получать имя и научное наименование животного в форме строк, размер в форме целого числа, питание в форме массива строк и дополнительную информацию в форме объекта. Вы будете передавать информацию новому компоненту в форме свойств и использовать эти данные в вашем компоненте.

      К концу этого шага у вас будет пользовательский компонент, который будет использовать разные свойства. Также вы сможете повторно использовать компонент для отображения массива данных, используя общий компонент.

      Добавление данных

      Во-первых, вам потребуются шаблонные данные. Создайте файл в каталоге src/App с именем data.

      • touch src/components/App/data.js

      Откройте новый файл в текстовом редакторе:

      • nano src/components/App/data.js

      Далее добавьте массив объектов, который вы будете использовать в качестве примера данных:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: 140,
          diet: ['meat'],
        },
        {
          name: 'Gorilla',
          scientificName: 'Gorilla beringei',
          size: 205,
          diet: ['plants', 'insects'],
          additional: {
            notes: 'This is the eastern gorilla. There is also a western gorilla that is a different species.'
          }
        },
        {
          name: 'Zebra',
          scientificName: 'Equus quagga',
          size: 322,
          diet: ['plants'],
          additional: {
            notes: 'There are three different species of zebra.',
            link: 'https://en.wikipedia.org/wiki/Zebra'
          }
        }
      ]
      

      Массив объектов содержит разные данные и дает вам возможность использовать различные свойства. Каждый объект представляет собой отдельное животное с именем, научным наименованием, размером, питанием и опциональным полем дополнительных данных, которое будет содержать ссылки или заметки. В этом коде вы также экспортировали массив default.

      Сохраните и закройте файл.

      Создание компонентов

      Затем создайте временный компонент AnimalCard. Этот компонент будет получать свойства и отображать данные.

      Сначала создайте каталог в src/components​​​ с названием AnimalCard, а затем файл с именем src/components/AnimalCard/AnimalCard.js и CSS-файл с именем src/components/AnimalCard/AnimalCard.css.

      • mkdir src/components/AnimalCard
      • touch src/components/AnimalCard/AnimalCard.js
      • touch src/components/AnimalCard/AnimalCard.css

      Откройте AnimalCard.js​​​ в текстовом редакторе:

      • nano src/components/AnimalCard/AnimalCard.js

      Добавьте базовый компонент, который импортирует CSS и возвращает тег <h2>.

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard() {
        return <h2>Animal</h2>
      }
      

      Сохраните и закройте файл. Теперь вам нужно импортировать данные и компонент в базовый компонент App.

      Откройте src/components/App/App.js​​​:

      • nano src/components/App/App.js

      Импортируйте данные и компонент, а затем пройдите по данным, возвращая компонент для каждого элемента в массиве:

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      import data from './data';
      import AnimalCard from '../AnimalCard/AnimalCard';
      import './App.css';
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard key={animal.name}/>
            ))}
          </div>
        )
      }
      
      export default App;
      

      Сохраните и закройте файл. Здесь вы используете метод массива .map() для итерации по данным. Кроме добавления цикла у вас также имеется оборачивающий div с классом, который вы будете использовать для стилей, и тег <h1> для наименования вашего проекта.

      После сохранения данных и перезагрузки браузера вы увидите наименование для каждой карточки.

      Проект React в браузере без стилей

      Далее добавьте несколько стилей для выравнивания элементов. Откройте App.css:

      • nano src/components/App/App.css

      Замените его содержимое на следующее для организации элементов:

      prop-tutorial/src/components/App/App.css

      .wrapper {
          display: flex;
          flex-wrap: wrap;
          justify-content: space-between;
          padding: 20px;
      }
      
      .wrapper h1 {
          text-align: center;
          width: 100%;
      }
      

      Здесь используется flexbox для приведения в порядок данных и их выравнивания. padding добавляет некоторое пространство в окне браузера. justify-content будет обеспечивать дополнительное пространство между элементами, а .wrapper h1​​​ будет размещать заголовок Animal на всю его длину.

      Сохраните и закройте файл. Когда вы сделаете это и обновите браузер, то увидите, что между данными теперь есть определенное свободное пространство.

      Проект React в браузере с распределенными данными

      Добавление свойств

      Теперь, когда у вас есть настроенные компоненты, вы можете добавить свое первое свойство. При итерации по данным у вас был доступ к каждому объекту в массиве data и элементам, которые он содержит. Вы будете добавлять каждый элемент данных в отдельное свойство, которое затем будет использоваться в компоненте AnimalCard.

      Откройте App.js:

      • nano src/components/App/App.js

      Добавьте свойство name в AnimalCard.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard
                key={animal.name}
                name={animal.name}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      Сохраните и закройте файл. Свойство name выглядит как стандартный HTML-атрибут, но вместо строки вы передаете свойство name объекта animal в фигурных скобках.

      Теперь, когда вы передали одно свойство в новый компонент, необходимо использовать его. Откройте AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Все свойства, которые вы передаете в компонент, будут собираться в объект, который будет первым аргументом вашей функции. Выполните деструктуризацию объекта для извлечения отдельных свойств:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      
      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard(props) {
        const { name } = props;
        return (
          <h2>{name}</h2>
        );
      }
      

      Обратите внимание, что вам не нужно деструктурировать свойства для его использования, но это полезный метод для работы с шаблонными данными в этом руководстве.

      После деструктурирования объекта вы можете использовать отдельные элементы данных. В данном случае вы будете использовать заголовок в теге <h2>, включающий значение в фигурных скобках, чтобы React мог использовать его в качестве JavaScript.

      Также вы можете использовать свойство в объекте prop, используя запись через точку. В качестве примера вы можете создать элемент <h2>​​​ следующим образом: <h2>{props.title}</h2>​​​. Преимущество деструктурирования состоит в том, что вы можете собирать неиспользуемые свойства и использовать оператор rest объекта.

      Сохраните и закройте файл. Сделав это и перезагрузив браузер, вы увидите конкретное имя для каждого животного вместо заполнителя.

      Проекты React с указанием имен животных

      Свойство name представляет собой строку, но строка может быть любым типом данных, который вы можете передавать функции JavaScript. Чтобы посмотреть, как это работает, добавьте остальные данные.

      Откройте файл App.js:

      • nano src/components/App/App.js

      Добавьте свойство для каждого из следующих элементов: scientificName, size, diet и additional. Они сдержат строки, целые числа, массивы и объекты.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {albums.map(album => (
              <AnimalCard
                additional={animal.additional}
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                scientificName={animal.scientificName}
                size={animal.size}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      Поскольку вы создаете объект, вы можете добавить их в любом желаемом порядке. Использование алфавитного порядка повышает читаемость списка свойств, особенно для больших списков. Также вы можете добавить их в одной строке, но их разделение на отдельные строки делает код более читабельным.

      Сохраните и закройте файл. Откройте AnimalCard.js.

      • nano src/components/AnimalCard/AnimalCard.js

      На этот раз выполните деструктуризацию свойств списка параметров функции и используйте данные в компоненте:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
        additional,
        diet,
        name,
        scientificName,
        size
      }) {
        return (
          <div>
            <h2>{name}</h2>
            <h3>{scientificName}</h3>
            <h4>{size}kg</h4>
            <div>{diet.join(', ')}.</div>
          </div>
        );
      }
      

      После получения данных вы можете добавить scientificName и size в теги заголовка, но вам нужно превратить массив в строку, чтобы React мог отобразить их на странице. Вы можете сделать это с помощью join(', '), который будет создавать разделенный запятой список.

      Сохраните и закройте файл. Сделав это и обновив браузер, вы увидите структурированные данные.

      Проект React с полным списком данных для животных

      Вы можете создать аналогичный список с объектом additional, но вместо этого добавьте функцию для оповещения пользователя с данными. Это даст вам возможность передавать функции в виде свойств, а затем использовать данные внутри компонента при вызове функции.

      Откройте App.js:

      • nano src/components/App/App.js

      Создайте функцию showAdditionalData, которая будет конвертировать объект в строку и отображать ее в качестве оповещения.

      prop-tutorial/src/components/App/App.js

      import React from 'react';
      ...
      
      function showAdditional(additional) {
        const alertInformation = Object.entries(additional)
          .map(information => `${information[0]}: ${information[1]}`)
          .join('n');
        alert(alertInformation)
      };
      
      function App() {
        return (
          <div className="wrapper">
            <h1>Animals</h1>
            {data.map(animal => (
              <AnimalCard
                additional={animal.additional}
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                scientificName={animal.scientificName}
                showAdditional={showAdditional}
                size={animal.size}
              />
            ))}
          </div>
        )
      }
      
      export default App;
      

      Функция showAdditional конвертирует объект в массив пар, где первый элемент — это ключ, а второй — значение. Затем она преобразовывает данные, конвертируя пару ключей в строку. После этого функция добавляет разделитель строки n, прежде чем передавать полную строку в сигнальную функцию.

      Поскольку JavaScript может принимать функции в качестве аргументов, React также может принимать функции в качестве свойств. Поэтому вы можете передать showAdditional в AnimalCard в качестве свойства с именем showAdditional.

      Сохраните и закройте файл. Откройте AnimalCard:

      • nano src/components/AnimalCard/AnimalCard.js

      Извлеките функцию showAdditional из объекта свойства, затем создайте <button> с событием onClick, которое вызывает функцию с объектом additional:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
        additional,
        diet,
        name,
        scientificName,
        showAdditional,
        size
      }) {
        return (
          <div>
            <h2>{name}</h2>
            <h3>{scientificName}</h3>
            <h4>{size}kg</h4>
            <div>{diet.join(', ')}.</div>
            <button onClick={() => showAdditional(additional)}>More Info</button>
          </div>
        );
      }
      

      Сохраните файл. Сделав это и обновив браузер, вы увидите кнопку после каждой карточки. При нажатии на кнопку, вы получите оповещение с дополнительными данными.

      Оповещение с информацией

      Если вы попробуете нажать More Info для карточки Lion, то получите ошибку. Это связано с тем, что для льва дополнительные данные отсутствуют. Вы увидите, как исправить это, в шаге 3.

      В заключение давайте добавим немного оформления в наш проект. Добавьте className для animal-wrapper в div в AnimalCard:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
        return (
          <div className="animal-wrapper">
      ...
          </div>
        )
      }
      

      Сохраните и закройте файл. Откройте AnimalCard.css:

      • nano src/components/AnimalCard/AnimalCard.css

      Добавьте CSS для добавления тонкой границы и отступа для карточек и кнопки:

      prop-tutorial/src/components/AnimalCard/AnimalCard.css

      .animal-wrapper {
          border: solid black 1px;
          margin: 10px;
          padding: 10px;
          width: 200px;
      }
      
      .animal-wrapper button {
          font-size: 1em;
          border: solid black 1px;
          padding: 10;
          background: none;
          cursor: pointer;
          margin: 10px 0;
      }
      

      Это код CSS добавит небольшую границу для карточки и заменит стиль кнопки, используемый по умолчанию, на границу и отступ. cursor: pointer​​​ будет менять курсор при наведении на кнопку.

      Сохраните и закройте файл. После выполнения этих действий и обновления браузера вы увидите данные в отдельных карточках.

      Проект React с добавленными стилями для карточек животных

      На данный момент вы создали два пользовательских компонента. Вы передали данные второму компоненту из первого компонента, используя свойства. Свойства включают разные данные, такие как строки, целые числа, массивы, объекты и функции. В вашем втором компоненте вы использовали свойства для создания динамического компонента с помощью JSX.

      В следующем шаге вы будете использовать типизированную систему prop-types для указания структуры, которую ваш компонент ожидает увидеть, что будет обеспечивать предсказуемость в приложении и предотвращать ошибки.

      Шаг 3 — Создание предсказуемых свойств с помощью PropTypes и defaultProps

      На этом шаге вы добавите простую систему типизации для ваших компонентов с помощью PropTypes. PropTypes действуют как прочие системы типизации, прямо определяя тип данных, который вы ожидаете получить от определенного свойства. Они также дают вам возможность определять данные по умолчанию в случаях, когда свойство не всегда требуется. В отличие от большинства систем типизации, PropTypes выполняет проверку при исполнении, так что если свойства не соответствуют типу, код скомпилируется, но в консоли будет отображена ошибка.

      К концу этого шага вы обеспечите предсказуемость вашего пользовательского компонента, определив тип для каждого свойства. Это позволит гарантировать, что другой человек, который будет работать с компонентом, будет иметь четкое представление о структуре данных, которая требуется компоненту.

      Пакет prop-types устанавливается вместе с Create React App, поэтому для его использования необходимо только импортировать его в ваш компонент.

      Откройте AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Затем импортируйте PropTypes из prop-types:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      

      Добавьте PropTypes прямо в функцию компонента. В JavaScript функции являются объектами, что означает, что вы можете добавить свойства, используя точечный синтаксис. Добавьте следующие PropTypes в AnimalCard.js:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      
      AnimalCard.propTypes = {
        additional: PropTypes.shape({
          link: PropTypes.string,
          notes: PropTypes.string
        }),
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
        name: PropTypes.string.isRequired,
        scientificName: PropTypes.string.isRequired,
        showAdditional: PropTypes.func.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Сохраните и закройте файл.

      Как видите, существует множество разных PropTypes. Это только небольшой пример; изучите официальную документацию React, чтобы узнать об остальных типах, которые вы можете использовать.

      Давайте начнем со свойства name. Здесь вы указываете, что в name должна находиться строка. Свойство scientificName аналогично предыдущему примеру. sizeчисло, которое может включать как числа с плавающей точкой, например, 1.5, так и целые числа, например 6. showAdditional — это функция (func).

      diet же имеет определенные отличия. В данном случае вы указываете, что diet представляет собой массив, но вам также необходимо указать, что будет содержать этот массив. В нашем случае массив будет содержать только строки. Если вы хотите смешивать типы, то можете использовать другое свойство oneOfType, которое принимает массив валидных значений PropTypes. Вы можете использовать oneOfType где угодно, так что если вы хотите, чтобы size принимал числа или строки, внесите следующие изменения:

      size: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
      

      Свойство additional также немного более сложное. В этом случае вы указываете объект, но, чтобы внести большую ясность, вы указываете, что должен содержать объект. Для этого вы можете использовать PropTypes.shape, принимающий объект с дополнительными полями, которым требуются собственные значения PropTypes. В нашем случае link и notes имеют значение PropTypes.string.

      В настоящее время все данные имеют правильную форму и отвечают свойствам. Чтобы узнать, что произойдет, если значение PropTypes не будет совпадать, откройте ваши данные:

      • nano src/components/App/data.js

      Измените для size значение на строку в первом элементе:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: '140',
          diet: ['meat'],
        },
      ...
      ]
      

      Сохраните файл. После выполнения этих действий и обновления браузера вы увидите ошибку в консоли.

      Error

      index.js:1 Warning: Failed prop type: Invalid prop `size` of type `string` supplied to `AnimalCard`, expected `number`. in AnimalCard (at App.js:18) in App (at src/index.js:9) in StrictMode (at src/index.js:8)

      Браузер с ошибкой типизации

      В отличие от других систем типизации, таких как TypeScript, PropTypes не будет генерировать предупреждение на этапе сборки, поэтому если ошибки кода отсутствуют, то код все равно скомпилируется. Это означает, что вы можете случайно опубликовать код с ошибками свойств.

      Измените данные обратно на правильный тип:

      prop-tutorial/src/components/App/data.js

      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: 140,
          diet: ['meat'],
        },
      ...
      ]
      

      Сохраните и закройте файл.

      Откройте AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Каждое свойство, за исключением additional, имеет параметр isRequired. Это означает, что они должны быть обязательно указаны. Если вы не укажете обязательное свойство, код все равно скомпилируется, но вы получите ошибку исполнения в консоли.

      Если свойство не обязательное, вы можете добавить значение по умолчанию. Рекомендуется всегда добавлять значение по умолчанию для предотвращения ошибок при исполнении, если свойство не обязательное. Например, в компоненте AnimalCard вы вызываете функцию с данными additional. Если их там нет, функция попытается получить их и изменить несуществующий объект, в результате чего приложение упадет.

      Чтобы предотвратить эту проблему, добавьте значение defaultProp для additional:

      prop-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalCard.css'
      
      export default function AnimalCard({
      ...
      }
      
      AnimalCard.propTypes = {
        additional: PropTypes.shape({
          link: PropTypes.string,
          notes: PropTypes.string
        }),
      ...
      }
      
      AnimalCard.defaultProps = {
        additional: {
          notes: 'No Additional Information'
        }
      }
      

      Вы добавляете значение defaultProps в функцию, используя точечный синтаксис, как вы это делали для propTypes, затем вы добавляете значение по умолчанию, которое компонент должен использовать, если свойство не определено. В нашем случае вы подставляете форму additional, включая сообщение, которое не содержит дополнительной информации.

      Сохраните и закройте файл. После этого обновите браузер. После обновления страницы нажмите кнопку More Info​​​ карточки Lion. У нее нет поля additional в данных, поэтому свойство не определено. Но AnimalCard будет заменять свойство по умолчанию.

      Браузер с сообщением по умолчанию в оповещении

      Теперь ваши свойства хорошо задокументированы и являются либо обязательными, либо имеют значение по умолчанию для обеспечения предсказуемого кода. Это позволит будущим разработчикам (в том числе вам) понимать, какие свойства требуются компоненту. Это облегчит повторное использование ваших компонентов, предоставляя вам полную информацию о том, как компонент будет использовать данные, которые он получает.

      Заключение

      В этом руководстве вы создали несколько компонентов, которые используют свойства для отображения информации из родительского элемента. Свойства дают вам гибкость, необходимую для разбивки крупных компонентов на более мелкие и понятные части. Теперь, когда ваши данные больше не имеют тесной привязки к отображаемой информации, вы можете самостоятельно делать выбор в отношении сегментации вашего приложения.

      Свойства — это важнейший инструмент для создания сложных приложений, дающий возможность создания компонентов, которые могут адаптироваться к получаемым данным. С помощью PropTypes вы создаете предсказуемые и понятные компоненты, которые дадут команде возможность повторно использовать работу друг друга для создания гибкой и стабильной базы кода. Если вас интересуют другие обучающие модули по React, ознакомьтесь с нашей страницей тем по React или вернитесь на страницу серии Программирование на React.js.



      Source link

      How To Create Wrapper Components in React with Props


      The author selected Creative Commons to receive a donation as part of the Write for DOnations program.

      Introduction

      In this tutorial, you’ll create wrapper components with props using the React JavaScript library. Wrapper components are components that surround unknown components and provide a default structure to display the child components. This pattern is useful for creating user interface (UI) elements that are used repeatedly throughout a design, like modals, template pages, and information tiles.

      To create wrapper components, you’ll first learn to use the rest and spread operators to collect unused props to pass down to nested components. Then you’ll create a component that uses the built-in children component to wrap nested components in JSX as if they were HTML elements. Finally, you’ll pass components as props to create flexible wrappers that can embed custom JSX in multiple locations in a component.

      During the tutorial, you’ll build components to display a list of animal data in the form of cards. You’ll learn to split data and refactor components as you create flexible wrapping components. By the end of this tutorial, you’ll have a working application that will use advanced prop techniques to create reusable components that will scale and adapt as you application grows and changes.

      Note: The first step sets up a blank project on which you will build the tutorial exercise. If you already have a working project and want to go directly to working with props, start with Step 2.

      Prerequisites

      Step 1 — Creating an Empty Project

      In this step, you’ll create a new project using Create React App. Then you will delete the sample project and related files that are installed when you bootstrap the project. Finally, you will create a simple file structure to organize your components. This will give you a solid basis on which to build this tutorial’s wrapper application in the next step.

      To start, make a new project. In your command line, run the following script to install a fresh project using create-react-app:

      • npx create-react-app wrapper-tutorial

      After the project is finished, change into the directory:

      In a new terminal tab or window, start the project using the Create React App start script. The browser will auto-refresh on changes, so leave this script running while you work:

      You will get a running local server. If the project did not open in a browser window, you can open it with http://localhost:3000/. If you are running this from a remote server, the address will be http://your_domain:3000.

      Your browser will load with a simple React application included as part of Create React App:

      React template project

      You will be building a completely new set of custom components, so you’ll need to start by clearing out some boilerplate code so that you can have an empty project.

      To start, open src/App.js in a text editor. This is the root component that is injected into the page. All components will start from here. You can find more information about App.js at How To Set Up a React Project with Create React App.

      Open src/App.js with the following command:

      You will see a file like this:

      wrapper-tutorial/src/App.js

      import React from 'react';
      import logo from './logo.svg';
      import './App.css';
      
      function App() {
        return (
          <div className="App">
            <header className="App-header">
              <img src={logo} className="App-logo" alt="logo" />
              <p>
                Edit <code>src/App.js</code> and save to reload.
              </p>
              <a
                className="App-link"
                href="https://reactjs.org"
                target="_blank"
                rel="noopener noreferrer"
              >
                Learn React
              </a>
            </header>
          </div>
        );
      }
      
      export default App;
      

      Delete the line import logo from './logo.svg';. Then replace everything in the return statement to return a set of empty tags: <></>. This will give you a valid page that returns nothing. The final code will look like this:

      wrapper-tutorial/src/App.js

      
      import React from 'react';
      import './App.css';
      
      function App() {
        return <></>;
      }
      
      export default App;
      

      Save and exit the text editor.

      Finally, delete the logo. You won’t be using it in your application and you should remove unused files as you work. It will save you from confusion in the long run.

      In the terminal window type the following command:

      If you look at your browser, you will see a blank screen.

      blank screen in chrome

      Now that you have cleared out the sample Create React App project, create a simple file structure. This will help you keep your components isolated and independent.

      Create a directory called components in the src directory. This will hold all of you custom components.

      Each component will have its own directory to store the component file along with the styles, images if there are any, and tests.

      Create a directory for App:

      Move all of the App files into that directory. Use the wildcard, *, to select any files that start with App. regardless of file extension. Then use the mv command to put them into the new directory:

      • mv src/App.* src/components/App

      Next, update the relative import path in index.js, which is the root component that bootstraps the whole process:

      The import statement needs to point to the App.js file in the App directory, so make the following highlighted change:

      wrapper-tutorial/src/index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import './index.css';
      import App from './components/App/App';
      import * as serviceWorker from './serviceWorker';
      
      ReactDOM.render(
        <React.StrictMode>
          <App />
        </React.StrictMode>,
        document.getElementById('root')
      );
      
      // If you want your app to work offline and load faster, you can change
      // unregister() to register() below. Note this comes with some pitfalls.
      // Learn more about service workers: https://bit.ly/CRA-PWA
      serviceWorker.unregister();
      

      Save and exit the file.

      Now that the project is set up, you can create your first component.

      Step 2 — Collecting Unused Props with ...props

      In this step, you’ll create a component to display a set of data about a group of animals. Your component will contain a second nested component to display some information visually. To connect the parent and nested component, you’ll use the rest and spread operators to pass unused props from the parent to the child without the parent needing to be aware of the names or types of the props.

      By the end of this step, you’ll have a parent component that can provide props to nested components without having to know what the props are. This will keep the parent component flexible, allowing you to update the child component without having to change the parent.

      Creating an AnimalCard Component

      To start, create a set of data for your animals. First, open a file containing the data set in the components/App directory:

      • nano src/components/App/data.js

      Add the following data:

      src/components/App/data.js

      
      export default [
        {
          name: 'Lion',
          scientificName: 'Panthero leo',
          size: 140,
          diet: ['meat']
        },
        {
          name: 'Gorilla',
          scientificName: 'Gorilla beringei',
          size: 205,
          diet: ['plants', 'insects']
        },
        {
          name: 'Zebra',
          scientificName: 'Equus quagga',
          size: 322,
          diet: ['plants'],
        }
      ]
      

      This list of animals is an array of objects that includes the animal’s name, scientific name, weight, and diet.

      Save and close the file.

      Next, create a directory for the AnimalCard component:

      • mkdir src/components/AnimalCard

      Open a new file in the directo:

      • nano src/components/AnimalCard/AnimalCard.js

      Now add a component that will take the name, diet, and size as a prop and display it:

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      
      export default function AnimalCard({ diet, name, size }) {
        return(
          <div>
            <h3>{name}</h3>
            <div>{size}kg</div>
            <div>{diet.join(', ')}.</div>
          </div>
        )
      }
      
      AnimalCard.propTypes = {
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
        name: PropTypes.string.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Here you are destructuring the props in the parameter list for the AnimalCard function, then displaying the data in a div. The diet data is listed as a single string using the join() method. Each piece of data includes a corresponding PropType to make sure the data type is correct.

      Save and close the file.

      Now that you have your component and your data, you need to combine them together. To do that, import the component and the data into the root component of your project: App.js.

      First, open the component:

      • nano src/components/App/App.js

      From there, you can loop over the data and return a new AnimalCard with the relevant props. Add the highlighted lines to App.js:

      wrapper-tutorial/src/components/App/App.js

      import React from 'react';
      import './App.css';
      
      import animals from './data';
      import AnimalCard from '../AnimalCard/AnimalCard';
      
      function App() {
        return (
          <div className="wrapper">
            {animals.map(animal =>
              <AnimalCard
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                size={animal.size}
              />
            )}
          </div>
        );
      }
      
      export default App;
      

      Save and close the file.

      As you work on more complex projects, your data will come from more varied places, such as APIs, localStorage, or static files. But the process for using each of these will be similar: assign the data to a variable and loop over the data. In this case, the data is from a static file, so you are importing directly to a variable.

      In this code, you use the .map() method to iterate over animals and display the props. Notice that you do not have to use every piece of data. You are not explicitly passing the scientificName property, for example. You are also adding a separate key prop that React will use to keep track of the mapped data. Finally, you are wrapping the code with a div with a className of wrapper that you’ll use to add some styling.

      To add this styling, open App.css:

      • nano src/components/App/App.css

      Remove the boilerplate styling and add flex properties to a class called wrapper:

      prop-tutorial/src/components/App/App.js

      .wrapper {
          display: flex;
          flex-wrap: wrap;
          justify-content: space-between;
          padding: 20px;
      }
      

      This will use flexbox layout to organize the data so it will line up. padding gives some space in the browser window, and justify-content spreads out the extra space between elements.

      Save and exit the file. When you do, the browser will refresh and you’ll see some data spaced out.

      Browser with data spaced out

      Creating a Details Component

      You now have a simple component that displays the data. But let’s say you wanted to give the diet data a little flair by converting the text to an emoji. You can do this by converting the data in your component.

      React is designed to be flexible, so when you are thinking about how to convert data, you have a few different options:

      • You can create a function inside the component that converts the text to an emoji.
      • You can create a function and store it in a file outside the component so that you can reuse the logic across different components.
      • You can create a separate component that converts the text to an emoji.

      Each approach is fine when applied to the right use case, and you’ll find yourself switching between them as you build an application. To avoid premature abstraction and complexity, you should use the first option to start. If you find yourself wanting to reuse logic, you can pull the function out separately from the component. The third option is best if you want to have a reusable piece that includes the logic and the markup, or that you want to isolate to use across the application.

      In this case, we’ll make a new component, since we will want to add more data later and we are combining markup with conversion logic.

      The new component will be called AnimalDetails. To make it, create a new directory:

      • mkdir src/components/AnimalDetails

      Next, open AnimalDetails.js in your text editor:

      • nano src/components/AnimalDetails/AnimalDetails.js

      Inside the file, make a small component that displays the diet as an emoji:

      wrapper-tutorial/src/components/AnimalDetails/AnimalDetails.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './AnimalDetails.css';
      
      function convertFood(food) {
        switch(food) {
          case 'insects':
            return '🐜';
          case 'meat':
            return '🍖';
          case 'plants':
          default:
            return '🌱';
        }
      }
      
      export default function AnimalDetails({ diet }) {
        return(
          <div className="details">
            <h4>Details:</h4>
            <div>
              Diet: {diet.map(food => convertFood(food)).join(' ')}
            </div>
          </div>
        )
      }
      
      AnimalDetails.propTypes = {
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
      }
      

      The AnimalDetails.propTypes object sets up the function to take a prop of diet that is an array of strings. Then inside the component, the code loops over the diet and converts the string to an emoji using the switch statement.

      Save and close the file.

      You are also importing some CSS, so let’s add that now.

      Open AnimalDetails.css:

      • nano src/components/AnimalDetails/AnimalDetails.css

      Add some CSS to give the element a border and margin to separate the details from the rest of the component:

      wrapper-tutorial/src/components/AnimalDetails/AnimalDetails.css

      .details {
          border-top: gray solid 1px;
          margin: 20px 0;
      }
      

      We use .details to match the rule to elements with a className of details.

      Save and close the file.

      Now that you have a new custom component, you can add it to your AnimalCard component. Open AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Replace the diet.join statement with the new AnimalDetails component and pass diet as a prop by adding the highlighted lines:

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import AnimalDetails from '../AnimalDetails/AnimalDetails';
      
      export default function AnimalCard({ diet, name, size }) {
        return(
          <div>
            <h3>{name}</h3>
            <div>{size}kg</div>
            <AnimalDetails
              diet={diet}
            />
          </div>
        )
      }
      
      AnimalCard.propTypes = {
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
        name: PropTypes.string.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Save the file and you’ll see the new details in the browser.

      Browser with details

      Passing Details Through a Component with ...props

      The components are working well together, but there’s a slight inefficiency in AnimalCard. You are explicitly pulling diet out from the props argument, but you aren’t using the data. Instead, you are passing it through to the component. There’s nothing inherently wrong about this—in fact, it’s often better to err on the side of too much communication. But in doing this, you make your code more difficult to maintain. Whenever you want to pass new data to AnimalDetails, you need to update three places: App, where you pass the props, AnimalDetails, which consumes the prop, and AnimalCard, which is the go-between.

      A better way is to gather any unused props inside AnimalCard and then pass those directly to AnimalDetails. This gives you the chance to make changes to AnimalDetails without changing AnimalCard. In effect, AnimalCard doesn’t need to know anything about the props or the PropTypes that are going into AnimalDetails.

      To do that, you’ll use the object rest operator. This operator collects any items that are not pulled out during destructuring and saves them into a new object.

      Here’s a simple example:

      const dog = {
          name: 'dog',
          diet: ['meat']
      }
      
      const { name, ...props  } = dog;
      

      In this case, the variable name will be 'dog' and the variable props will be { diet: ['meat']}.

      Up till now, you’ve passed all props as if they were HTML attributes, but you can also use objects to send props. To use an object as a prop, you need to use the spread operator—...props—surrounded with curly braces. This will change each key-value pair into a prop.

      Open AnimalCard.js:

      • nano src/components/AnimalCard/AnimalCard.js

      Inside, remove diet from the destructured object and instead collect the rest of the props into a variable called props. Then pass those props directly to AnimalDetails:

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import AnimalDetails from '../AnimalDetails/AnimalDetails';
      
      export default function AnimalCard({ name, size, ...props }) {
        return(
          <div>
            <h3>{name}</h3>
            <div>{size}kg</div>
            <AnimalDetails
              {...props}
            />
          </div>
        )
      }
      
      AnimalCard.propTypes = {
        name: PropTypes.string.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Notice that you can remove the diet PropType since you are not using the prop in this component.

      In this case, you are only passing one prop to AnimalDetails. In cases where you have multiple props, the order will matter. A later prop will overwrite earlier props, so if you have a prop you want to take priority, make sure it is last. This can cause some confusion if your props object has a property that is also a named value.

      Save and close the file. The browser will refresh and everything will look the same:

      Browser with details

      To see how the ...props object adds flexibility, let’s pass the scientificName to AnimalDetails via the AnimalCard component.

      First, open App.js:

      • nano src/components/App/App.js

      Then pass the scientificName as a prop:

      wrapper-tutorial/src/components/App/App.js

      import React from 'react';
      import './App.css';
      
      import animals from './data';
      import AnimalCard from '../AnimalCard/AnimalCard';
      
      function App() {
        return (
          <div className="wrapper">
            {animals.map(animal =>
              <AnimalCard
                diet={animal.diet}
                key={animal.name}
                name={animal.name}
                size={animal.size}
                scientificName={animal.scientificName}
              />
            )}
          </div>
        );
      }
      
      export default App;
      

      Save and close the file.

      Skip over AnimalCard; you won’t need to make any changes there. Then open AnimalDetails so you can consume the new prop:

      • nano src/components/AnimalDetails/AnimalDetails.js

      The new prop will be a string, which you’ll add to the details list along with a line declaring the PropType:

      wrapper-tutorial/src/components/AnimalDetails/AnimalDetails.js

      import React from 'react';
      ...
      export default function AnimalDetails({ diet, scientificName }) {
        return(
          <div className="details">
            <h4>Details:</h4>
            <div>
              Scientific Name: {scientificName}.
            </div>
            <div>
              Diet: {diet.map(food => convertFood(food)).join(' ')}
            </div>
          </div>
        )
      }
      
      AnimalDetails.propTypes = {
        diet: PropTypes.arrayOf(PropTypes.string).isRequired,
        scientificName: PropTypes.string.isRequired,
      }
      

      Save and close the file. When you do, the browser will refresh and you’ll see the new details without any changes to the AnimalCard component:

      Browser with scientific name

      In this step, you learned how to create flexible parent props that can take unknown props and pass them into nested components with the spread operator. This is a common pattern that will give you the flexibility you need to create components with focused responsibilities. In the next step, you’ll create components that can take unknown components as a prop using the built in children prop.

      Step 3 — Creating Wrapper Components with children

      In this step, you’ll create a wrapper component that can take an unknown group of components as a prop. This will give you the ability to nest components like standard HTML, and it will give you a pattern for creating reusable wrappers that will let you make a variety of components that need a common design but a flexible interior.

      React gives you a built-in prop called children that collects any children components. Using this makes creating wrapper components intuitivie and readable.

      To start, make a new component called Card. This will be a wrapper component to create a standard style for any new card components.

      Create a new directory:

      • mkdir src/components/Card

      Then open the Card component in your text editor:

      • nano src/components/Card/Card.js

      Create a component that takes children and title as props and wraps them in a div by adding the following code:

      wrapper-tutorial/src/components/Card/Card.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './Card.css';
      
      export default function Card({ children, title }) {
        return(
          <div className="card">
            <div className="card-details">
              <h2>{title}</h2>
            </div>
            {children}
          </div>
        )
      }
      
      Card.propTypes = {
        children: PropTypes.oneOfType([
          PropTypes.arrayOf(PropTypes.element), 
          PropTypes.element.isRequired
        ]),
        title: PropTypes.string.isRequired,
      }
      

      The PropTypes for the children are new. The children prop can either be a JSX element or an array of JSX elements. The title is a string.

      Save and close the file.

      Next, add some styling. Open Card.css:

      • nano src/components/Card/Card.css

      Your card will have a border and a line under the details.

      wrapper-tutorial/src/components/Card/Card.css

      .card {
          border: black solid 1px;
          margin: 10px;
          padding: 10px;
          width: 200px;
      }
      
      .card-details {
          border-bottom: gray solid 1px;
          margin-bottom: 20px;
      }
      

      Save and close the file. Now that you have your component you need to use it. You could wrap each AnimalCard with the Card component in App.js, but since the name AnimalCard implies it is already a Card, it would be better to use the Card component inside of AnimalCard.

      Open up AnimalCard:

      • nano src/components/AnimalCard/AnimalCard.js

      Unlike other props, you don’t pass children explicitly. Instead, you include the JSX as if they were HTML child elements. In other words, you just nest them inside of the element, like the following:

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import Card from '../Card/Card';
      import AnimalDetails from '../AnimalDetails/AnimalDetails';
      
      export default function AnimalCard({ name, size, ...props }) {
        return(
          <Card title="Animal">
            <h3>{name}</h3>
            <div>{size}kg</div>
            <AnimalDetails
              {...props}
            />
          </Card>
        )
      }
      
      AnimalCard.propTypes = {
        name: PropTypes.string.isRequired,
        size: PropTypes.number.isRequired,
      }
      

      Unlike a React component, you do not need to have a single root element as a child. That’s why the PropType for Card specified it could be an array of elements or a single element. In addition to passing the children as nested components, you are giving the card a title of Animal.

      Save and close the file. When you do, the browser will refresh and you’ll see the updated card component.

      Browser with cards

      Now you have a reusable Card component that can take any number of nested children. The primary advantage of this is that you can reuse the Card with any arbitrary component. If you wanted to make a Plant card, you could do that by wrapping the plant information with the Card component. It doesn’t even need to relate at all: If you wanted to reuse the Card component in a completely different applications that lists things like music or account data, you could do that, too. The Card component doesn’t care what the children are; you are just reusing the wrapper element, which in this case is the styled border and title.

      The downside to using children is that you can only have one instance of the child prop. Occasionally, you’ll want a component to have custom JSX in multiple places. Fortunately, you can do that by passing JSX and React components as props, which we will cover in the next step.

      Step 4 — Passing Components as Props

      In this step, you’ll modify your Card component to take other components as props. This will give your component maximum flexibility to display unknown components or JSX in multiple locations throughout the page. Unlike children, which you can only use once, you can have as many components as props, giving your wrapper component the ability to adapt to a variety of needs while maintaining a standard look and structure.

      By the end of this step, you’ll have a component that can wrap children components and also display other components in the card. This pattern will give you flexibility when you need to create components that need information that is more complex than simple strings and integers.

      Let’s modify the Card component to take an arbitrary React element called details.

      First, open the Card component:

      • nano src/components/Card/Card.js

      Next, add a new prop called details and place it below the <h2> element:

      wrapper-tutorial/src/components/Card/Card.js

      import React from 'react';
      import PropTypes from 'prop-types';
      import './Card.css';
      
      export default function Card({ children, details, title }) {
        return(
          <div className="card">
            <div className="card-details">
              <h2>{title}</h2>
              {details}
            </div>
            {children}
          </div>
        )
      }
      
      Card.propTypes = {
        children: PropTypes.oneOfType([
          PropTypes.arrayOf(PropTypes.element), 
          PropTypes.element.isRequired
        ]),
        details: PropTypes.element,
        title: PropTypes.string.isRequired,
      }
      
      Card.defaultProps = {
        details: null,
      }
      

      This prop will have the same type as children, but it should be optional. To make it optional, you add a default value of null. In this case, if a user passes no details, the component will still be valid and will not display anything extra.

      Save and close the file. The page will refresh and you’ll see the same image as before:

      Browser with cards

      Now add some details to the AnimalCard. First, open AnimalCard.

      • nano src/components/AnimalCard/AnimalCard.js

      Since the Card component is already using children, you’ll need to pass the new JSX component as a prop. Since these are all mammals, add that to the card, but wrap it in <em> tags to make it italic.

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      ...
      
      export default function AnimalCard({ name, size, ...props }) {
        return(
          <Card title="Animal" details={<em>Mammal</em>}>
            <h3>{name}</h3>
            <div>{size}kg</div>
            <AnimalDetails
              {...props}
            />
          </Card>
        )
      }
      ...
      

      Save the file. When you do, the browser will refresh and you’ll see the update, including the phrase Mammal.

      Browser with card and details

      This prop is already powerful because it can take JSX of any size. In this example, you added only a single element, but you could pass as much JSX as you wanted. It also doesn’t have to be JSX. If you have a complicated markup for example, you wouldn’t want to pass it directly in the prop; this would be difficult to read. Instead, you could create a separate component and then pass the component as a prop.

      To see this at work, pass AnimalDetails to the details prop:

      wrapper-tutorial/src/components/AnimalCard/AnimalCard.js

      import React from 'react';
      ...
      
      export default function AnimalCard({ name, size, ...props }) {
        return(
          <Card
            title="Animal"
            details={
              <AnimalDetails
                {...props}
              />
            }
          >
            <h3>{name}</h3>
            <div>{size}kg</div>
          </Card>
        )
      }
      ...
      

      AnimalDetails is more complicated and has a number of lines of markup. If you were to add it directly to details, it would increase the prop substantially and make it difficult to read.

      Save and close the file. When you do, the browser will refresh and the details will appear at the top of the card.

      Card with details at the top

      Now you have a Card component that can take custom JSX and place it in multiple spots. You are not restricted to a single prop; you can pass elements to as many props as you want. This gives you the ability to create flexible wrapping components that can give other developers the opportunity to customize a component while retaining its overall style and functionality.

      Passing a component as a prop isn’t perfect. It’s a little more difficult to read and isn’t as clear as passing children, but they are just as flexible and you can use as many of them as you want in a component. You should use children first, but don’t hesitate to fall back to props if that is not enough.

      In this step, you learned how to pass JSX and React components as props to another component. This will give your component the flexibility to handle many situations where a wrapper component may need multiple props to handle JSX or components.

      Conclusion

      You have created a variety of wrapping components that can display data flexibly while keeping a predictable look and structure. You created components that can collect and pass unknown props to nested components. You also used the built-in children prop to create wrapper components that can handle an arbitrary number of nested elements. Finally, you created a component that can take JSX or React components as a prop so that your wrapper component can handle multiple instances of different customizations.

      Wrapper components give you the ability to adapt to unknown circumstances while also maximizing code reuse and consistency. This pattern is useful for creating basic UI elements that you will reuse throughout an application including: buttons, alerts, modals, slide shows, and more. You’ll find yourself returning to it many times.

      If you would like to look at more React tutorials, check out our React Topic page, or return to the How To Code in React.js series page.



      Source link