O que são React Components & Props

Componentes são como funções que retornam elementos HTML.

Os componentes são partes independentes e reutilizáveis de código. Eles possuem o mesmo propósito que as funções JavaScript, mas trabalham de forma isolada e retornam elementos HTML por uma função render.

Eles possuem dois tipos, chamados Componentes de Classes e Componentes de Funções.

Function Components

Um Function Component nada mais é do que uma função JavaScript que retorna um elemento JSX (leia este artigo se você não conhece JSX).

Por exemplo:

import React from 'react';

function ThisComponent(){
    const component = 'Olá Mundo! Eu sou um Componente!';
    return <h1>{component}</h1>;
}

export default ThisComponent;

Se você quer renderizar um React Component dentro de uma Function Component, você pode definir outro componente e renderizá-lo com HTML utilizando JSX:

import React from 'react';

function App(){
    return <ThisComponent />;
}

function ThisComponent(){
    const component = 'Olá Mundo! Eu sou um Componente!';
    return <h1>{component}</h1>;
}

export default App;

Deste modo, você tem um Componente Filho. Você consegue decidir como e onde renderizar um componente.

Class Component

Quando criamos um componente React, o nome do componente deve iniciar com uma letra maiúscula. Ao criar um Class Component, precisamos incluir o extends React.Component, pois este componente cria uma herança para o React.Component, criando um acesso às funções do React Component.

Criando um Class Component, precisamos do método render() para retornar HTML. Por exemplo:

class Pessoa extends React.Component {
    render(){
        return <h1>Olá, eu sou uma Pessoa!</h1>;
    }
}

Agora você tem um componente chamado Pessoa que retorna um elemento H1. Para usar este componente na aplicação, é só utilizar a sintaxe:

ReactDOM.render(<Pessoa />, document.getElementById('root'));

E esse componente será renderizado na sua página, no elemento root!

Component Constructor:

Se existe uma função construtora (constructor()) no seu componente, a função será chamada quando o componente for iniciado. O construtor será onde você irá iniciar as propriedades dos seus componentes.

No React, utilizamos um objeto chamado state para criar nossas propriedades de componentes. Utilize também o super() para utilizar os métodos herdados pela função construtora pai e também para obter acesso à todas as funções do método React.Component. Por exemplo, criaremos um componente Pessoa, com um estado de humor:

class Pessoa extends React.Component {
    constructor(){
        super();
        this.state = {humor: 'Bem humorada!'};
    }
    render(){
        return <h1>Olá, eu sou uma Pessoa {this.state.humor}</h1>;
    }
}

ReactDOM.render(<Pessoa />, document.getElementById('root'));

E temos a saída:

Olá, eu sou uma Pessoa Bem humorada!

Props:

Podemos também utilizar props para adicionar propriedades de componentes.

As props são como argumentos de funções, e você pode enviá-las para os componentes como atributos:

class Pessoa extends React.Component {
    render(){
        return <h1>Olá, eu sou uma Pessoa {this.props.humor}</h1>;
    }
}

ReactDOM.render(<Pessoa humor="Bem humorada!"/>, document.getElementById('root'));

E com isso, obtemos o nosso resultado:

Olá, eu sou uma Pessoa Bem humorada!

Gostou deste artigo? Comente abaixo!

Referências:

O que é JSX?

Olá pessoal, neste artigo, aprenderemos o que é o JSX e quais são as suas aplicações. O JSX significa JavaScript XML e nos permite escrever HTML no React, tornando fácil a sua adição. Com o JSX, podemos escrever os elementos HTML dentro do JavaScript e adicioná-los ao DOM sem utilizar métodos como createElement() ou appendChild(). o JSX é uma alternativa para escrevermos nosso código que mescla a estrutura do DOM com a lógica da aplicação.

São necessários transpiladores (pré-processadores) como o Babel. Basicamente, com o JSX você escreve estruturas HTML/XML do mesmo modo que escreve o código JavaScript, então, o transpilador transformará essas expressões em código JavaScript. Ou seja, ao invés de colocar o JavaScript no HTML, colocamos o HTML no JavaScript.

O JSX fornece uma sintaxe concisa e familiar para definir uma estrutura de árvore com atributos que não requerem o aprendizado de uma linguagem de templates ou abandonar o JavaScript e o JSX é fácil de ler e escrever. Vejamos um exemplo:

const element = <h1>Olá Mundo!</h1>

ReactDOM.render{
    element, 
    document.getElementById('root')
};

Neste exemplo, declaramos a variável element e a usamos dentro do JSX, renderizando-a com ReactDOM.render().

Se fosse escrever o mesmo exemplo anterior sem o JSX, seria algo como:

const element = React.createElement('h1, {}, 'Olá Mundo!');
ReactDOM.render(element, document.getElementById('root'));

Veja, se não utilizamos JSX, precisamos do método createElement para criarmos o nosso elemento <h1> utiliando o React. Com o JSX, eliminamos a necessidade de utilizar este método, simplificando a sintaxe do nosso código.

O JSX também é uma expressão!

Podemos utilizar expressões em JSX, transformando-se em chamadas normais de funções que retornam objetos JavaScript. Por exemplo:

function formatName(user) {
    return user.firstName + ' ' + user.lastName;
}

const user = {
    firstName: 'Nome',
    lastName: 'Sobrenome'
};

function greeting(user){
    if (user) {
        return <h1>Olá, {formatName(user)}!</h1>;
    }
    return <h1>Olá, anônimo!</h1>;
}

Ou seja, você pode utilizar o JSX dentro de estruturas condicionais e laços de repetição, atribuí-los a variáveis, aceitá-los como argumentos e retorná-los de funções!

Gostou deste artigo? Comente abaixo!

Referências:

 

Versão React v17.0: Atualização sem novos recursos

Depois do silêncio, o React anunciou o primeiro candidato a lançamento do React v17. O que chama a atenção neste lançamento é a parte considerada como central de qualquer lançamento relacionado ao desenvolvimento: Os novos recursos! Na versão 17, não há novos recursos, mas sim uma ideia de facilitar o processo de migração de uma versão anterior para uma nova. Os desenvolvedores poderão atualizar os seus aplicativos gradualmente ou de uma vez, pois as novas alterações introduzidas nos mecanismos de delegação de eventos permitem a coexistência de diferentes versões de React na mesma aplicação. Ou seja, o foco principal é a atualização do próprio React!

Updates graduais:

Algumas mudanças de API, como descontinuar uma API legado, são impossíveis de fazer de forma automatizada. Mesmo sendo pouco utilizadas, ainda há suporte para elas no React. O React 17 vem com a permissão de atualizações graduais, embora seja possível usar duas versões do React, isso causava problemas com eventos. Mas no React 17 em diantes, você terá mais opções, como atualizar todo o aplicativo de uma vez, mas também tendo a opção de atualizar seu aplicativo por partes.

Isso não quer dizer que será necessário fazer atualizações graduais do sistema. Para a maioria, atualizar tudo de uma só vez é a melhor ideia. Carregar duas versões do React não e a melhor solução. Para que possam ocorrer essas atualizações graduais, terá mudanças no sistema de eventos do React,

Mudanças de Eventos:

Nos componentes React, você geralmente escrevia os manipuladores de eventos embutidos:

<button onClick={eventoClick}>

E o seu equivalente no JavaScript seria:

meuBotao.addEventListener("click", eventoClick);

Para a maioria dos eventos, o React não anexa aos Nodes do DOM em que você declara. Em vez disso, anexa um manipulador de evento direto no nó document. Isso é chamado de delegação de evento.

Quando um evento DOM é disparado no documento, o React descobre qual componente deve ser chamado e “borbulha” para cima através de seus componentes.

Se você tiver várias versões do React na página, elas registram manipuladores de eventos na parte superior. Isso gera uma quebra e.stopPropagation(). Mesmo sendo interrompida a propagação de evento, a árvore externa ainda o receberia. É por isso que será alterada no React 17: Não haverá anexo de manipuladores de eventos no nível document. Então, ele os anexará ao contêiner DOM no qual o React é renderizado:

const noRoot = document.getElementById('root');
ReactDOM.render(<App />, noRoot);

Você pode conferir mais detalhes da atualização diretamente no site do React.

Gostou desta notícia? Comente abaixo!

Referências:

Angular vs ReactJS: Qual o Framework Front-End mais requisitado de 2020

Olá pessoal, o primeiro semestre de 2020 foi uma época cheia de mudanças. Ainda assim, permanece a eterna batalha entre Angular e React. Antes de iniciar a comparação, esclareceremos alguns pontos sobre ambas as tecnologias:

Angular:

Desenvolvido pelo Google e lançado pela primeira vez em 2010, é um framework de desenvolvimento front-end com uma boa estrutura, um ecossistema próprio, regras rígidas e um estilo de código declarativo. Possui uma profunda curva de aprendizado, bastante difícil, mas depois de possuir todas as possibilidades do Angular, ele auxiliará a criação do seu projeto.

Baseado na arquitetura MVC (Model-View-Controller), fornece aos desenvolvedores as peças fundamentais que são necessárias para projetar aplicativos móveis e da web.

React

React foi criado em 2011 e foi criado pelo Facebook. É uma biblioteca front-end que oferece uma oportunidade de construir uma excelente UI. Fácil de ler, escrever e integrar com outras estruturas JavaScript. Com React, você não utiliza somente a lógica do desenvolvedor, mas também a imaginação. Possuindo um ambiente de desenvolvimento flexível, amplia os horizontes de pensamento do desenvolvedor.

Oportunidades

Angular:

Desenvolvido para facilitar a criação de aplicativos nativos e híbridos ricos em recursos, como um SPA ou MPA.

React:

Tem por objetivo expandir as interfaces de usuário complexas, principalmente em apps web e móveis para Android e iOS.

Template Language

Angular:

Utilizando TypeScript, é adequado para desenvolvimento de apps complicados e você não queira perder seu tempo detectando bugs, pois o TypeScript ajuda a detectá-los mais cedo.

React:

Escrito em JavaScript, pode ser utilizado com diversos tipos de aplicações devido ao suporte e integração em outras linguagens.

Performance

Angular:

Funcionando de maneira mais devagar que o React, mas ainda com velocidade satisfatória, o Angular inclui todas as etapas, desde a criação de um projeto até a otimização de código.

React:

Rápido devido à forma como foi concebido, adiciona eficiência e simplicidade ao desenvolvimento de apps.

E qual escolher para ser um desenvolvedor sob demanda?

Escolha o Angular quando precisar:

  • Desenvolver aplicativos ricos em recursos;
  • Estrutura confiável e estável;
  • Desenvolver um app em tempo real, com base em bate-papo ou mensagens;
  • Aplicativos nativos, híbridos ou web que deveriam ser projetos de investimento substanciais;
  • Código em TypeScript;
  • Programação orientada a objetos.

Escolha o Angular quando precisar:

  • Desenvolver app’s modernos e leves a nível empresarial em um curto espaço de tempo;
  • Estrutura flexível, fornecendo soluções seguras de desenvolvimento de sites;
  • Aplicativos de plataforma cruzada ou SPA;
  • Expander a funcionalidade do aplicativo existente;
  • Forte apoio da comunidade.

Tendências:

De acordo com o NPM Trends, o React é mais popular em 2020:

Tendências NPM

O StackOverflow Trends oferece uma visão diferente da situação. De 2014 a 2019, o React e Angular tiveram quase a mesma popularidade, mas o React se tornou um líder nesta corrida:

Tendências de estouro de pilha

Conclusão:

Levando em consideração as estatísticas, o React é a estrutura mais demandada em 2020. Mesmo assim, escolha o seu framework ou biblioteca de acordo com sua necessidade de trabalho e experiência.

Gostou deste artigo? Comente abaixo!

Referências: https://techstory.in/angular-vs-reactjs/

MERN stack, o que é?

Você já ouviu falar no termo MERN stack?

Por definição, MERN significa:

  • (M) MongoDB;
  • (E) ExpressJs;
  • (R) React;
  • (N) Node.js;

Ou seja, é chamado de MERN stack o profissional que domina todas essas quatro tecnologias. É uma stack que permite a criação de sites/sistemas completos (back-end e front-end) utilizando JavaScript no lado do Cliente e lado do Servidor. Com isso, o desenvolvedor fica apto a criar sites/sistemas completos, sem precisar conhecer outra tecnologia ou utilizar outra habilidade. O MERN stack representa uma aliança das tecnologias mais poderosas do mercado, pois oferece a possibilidade de dominar a parte de algoritmos e lógica utilizada no back-end, juntamente com os componentes de design, UX e animações que o front-end é responsável. Isso traz uma competência para apenas um desenvolvedor, onde, normalmente, seriam exigidos dois.

Atualmente, com a alta utilização do JavaScript, o MERN stack é um dos profissionais mais requisitados no mercado.

E quais são as tecnologias utilizadas?

  • MongoDB: É um banco de dados não-relacional. É utilizado na MERN stack pois os dados são manipulados no formato JSON.
  • Node.js: O Node.js trabalha com JavaScript, ou seja, um desenvolvedor que conheça bem a linguagem JavaScript não terá dificuldades em aprender Node.js.
  • Express.js: Um middleware dedicado ao gerenciamento de apps web complexos, é usado para criação de API REST. A API REST corresponde a um site que recuperará dados por meio de solicitações HTTP.
  • React.js: Responsável pelo front-end, é uma biblioteca JavaScript desenvolvida e utilizada pelo Facebook. Responsável por fazer, de maneira extremamente rápida, animações, uploads e transições.

Assim como a MERN stack, também temos a MEAN stack onde o React não é utilizado, mas sim o Angular, alterando somente a biblioteca/framework utilizado no Front-end. Utilizando o Vue.js, teremos o MEVN stack, ou seja, são muitas as opções para quem quer dominar Front e Back-end utilizando JavaScript!.

Dominando essas tecnologias, você é um desenvolvedor MERN/MEAN/MEVN stack!

Gostou deste artigo? Comente abaixo!

Referências:

 

Criando Pokedéx com React – Final

Olá pessoal! Chegamos a última parte do nosso tutorial Pokedex com React! Nesta última parte, gerenciaremos o estado e buscaremos dados da poke api. Por fim, usaremos os dados do Pokemón para preenchimento do nosso DetailView. Para dar sequência, você precisará dos artigos anteriores:

Passing Events:

Precisamos criar um evento de clique para cada um dos nossos PokeCells, afim de buscar os dados Pokemón da Poke API. Para fazer isso, criaremos a função como parte da classe APP e depois transmitiremos como props para cada um de nossos PokeCells.

Abra o arquivo App.js e cria uma função chamada handleOnClick, com o parâmetro id. No corpo da função, inclua um console.log do argumento id.

import React, { Component } from 'react';
import PokeList from './PokeList';
import DetailView from './DetailView';
import './styles/App.css';
class App extends Component {
  constructor() {
    super();
    this.state = {};
  }

  handleOnClick(id){
    console.log(id);
  }

  render() {
    return (
      <div className = "App">
        <PokeList />
        <DetailView />
      </div>
    );
  }
}

Precisamos passar esta função através do componente PokeList. Adicione a função handleOnClick para o PokeList:

render() {
    return (
      <div className = "App">
        <PokeList handleOnClick = {this.handleOnClick} />
        <DetailView />
      </div>
    );
  }

Usamos a palavra-chave this, porque handleOnClick é um método da classe App. No entanto, se não utilizarmos o bind, perderemos o contexto disso quando usarmos essa função no componente PokeList. Então, vamos vincular handleOnClick à classe atual:

class App extends Component {
  constructor() {
    super();
    this.state = {};

    this.handleOnClick = this.handleOnClick.bind(this);
  }

Agora, abra o seu arquivo PokeList.js e siga esta etapa:

  1. Desconstrua o handleOnCLick a partir dos argumentos PokeList;
  2. Adicione o método handleOnClick como um prop de PokeCells:
const PokeList = ({handleOnClick}) => {
    const cells = pokeClasses.map(pokeClass => {
        return (
            <PokeCell 
                key = {pokeClass.id}
                pokeClass = {pokeClass}
                handleOnClick = {handleOnClick}
            />
        );
    });

    return (
        <section className="poke-list">
            {cells}
        </section>
    )
}

Abra seu arquivo PokeCell e siga os seguintes passos:

  1. Desconstrua o handleOnClick a partir dos argumentos PokeCell;
  2. Adicione um evento onClick dentro da guia do botão e atribua a ele uma função anônima que chama handleOnClick com a variável id como parâmetro;

Agora, sempre que clicarmos no botão PokeCell, o ID do Pokémon clicado será registrado no console:

import React from 'react';
import sprites from '../assets/sprites.png';
import './styles/PokeCell.css';

const PokeCell = ({ pokeClass, handleOnClick }) => {
  const { id, backgroundPosition } = pokeClass;
  const style = { backgroundImage: `url(${sprites})`, backgroundPosition};

  return <button onClick={() => handleOnClick(id)} style={style} className="poke-cell"></button>
};

export default PokeCell;

Pokemon Helper:

Vamos criar uma classe Pokemon para limpar os dados da API que vamos buscar. Dessa forma, podemos gerenciar os dados de Pokemon mais facilmente. Dentro do diretório src, crie um arquivo Pokemon.js. Dentro deste arquivo Pokemon.js, adicione o código:

class Pokemon {
    constructor(data) {
        this.id = data.id;
        this.name = data.name;
        this.sprite = data.sprites.front_default;
        this.type = data.types[0].type.name;
    }
}

export default Pokemon;

Agora, quando buscarmos os dados, instanciaremos um novo objeto Pokemon e passa-lo aos dados buscados.

Buscando os dados:

Abra o arquivo App.js e siga estas etapas:

  1. Importe a classe Pokemon na parte superior do arquivo;
  2. No método handleOnClick, faça um fetch para a API. Adicione uma rota de URL dinâmico com o argumento id;
  3. Resolve a promise e crie uma nova instância de Pokecom com os dados buscados;
  4. Adicione um console.log do objeto Pokemon para ver os dados do Pokemon quando um PokeCell é clicado.
handleOnClick(id){
  fetch(`http://pokeapi.co/api/v2/pokemon/${id}/`)
  .then(res=> res.json())
  .then(data => {
    const pokemon = new Pokemon(data);

    console.log(pokemon);
  })
  .catch (err => console.log(err));
}

State:

Agora que nós já realizamos o fetch dos dados dos Pokemon, precisamos passar esses dados para o DetailView para mostrá-los.

Para fazer isso, precisamos tirar o objeto Pokemon da promise resolvida e armazená-lo no estado de nosso aplicativo. Na função construtora do componente App, adicione uma nova chave ao objeto de estado com o valor de um objeto vazio.

constructor() {
    super();
    this.state = {
      pokemon: {}
    };

    this.handleOnClick = this.handleOnClick.bind(this);
  }

Para atualizar o estado do pokemon, o React nos fornece uma função chamada setState. Essa função usa um objeto como argumento, onde precisamos especificar a chave que queremos atualizar e atribuir um novo valor a ele. Toda vez que essa função é chamada, o React renderiza novamente todos os componentes filhos.

handleOnClick(id){
    fetch(`http://pokeapi.co/api/v2/pokemon/${id}/`)
    .then(res=> res.json())
    .then(data => {
      const pokemon = new Pokemon(data);

      this.setState({pokemon});
    })
    .catch (err => console.log(err));
  }

Agora que armazenamos nossos dados de Pokemon no estado do aplicativo, podemos acessá-los na função de renderização. Passe o estado pokemon para o componente DetailView como um suporte. Como a propriedade state faz parte da classe App, precisamos incluir a palavra-chave this para acessá-la:

render() {
    return (
      <div className = "App">
        <PokeList handleOnClick = {this.handleOnClick} />
        <DetailView pokemon = {this.state.pokemon} />
      </div>
    );
  }

Exibindo os dados:

Abra o arquivo DetailView.js e siga estas etapas:

  1. Desconstrua o pokemon a partir dos argumentos DetailView;
  2. Desconstrua o ID, nome, Sprite e tipo da variável pokemon;
  3. Na tag da imagem, adiciona um atributo src e atribua a variável Sprite envolvida em chaves;
  4. Entre as tags h1, adicione as variáveis id e name envoltas em chaves;
  5. Na tag p, adicione a variável type envolvida em chaves.
import React from 'react';
import './styles/DetailView.css';

const DetailView = ({pokemon}) => {
    const { id, name, sprite, type } = pokemon;

    return (
        <section className="detail-view">
            <img src={sprite} className='sprite-image' alt='sprite' />
            <div className='data-wrapper'>
                <h1 className='data-name'>ID: {name}</h1>
                <p className="data-char">Type: {type}</p>
            </div>
        </section>
    )
}

export default DetailView;

E com isso, terminamos a nossa PokeDex! Gostou desta sequência de artigos? Comente abaixo!

Referências: https://blog.cloudboost.io/lets-build-a-pokedex-with-react-part-5-b61d730de5fc

JavaScript lidera ranking de linguagens

2020 chegou e com ele, muitas mudanças no mundo da tecnologia. Se você está curioso para saber qual pode ser o futuro do mundo da programação, veio conferir no lugar certo.

Seguindo as tendências de 2019, o ecossistema do JavaScript se manteve muito utilizado e otimizado. A cada dia que passa, mais pessoas utilizam esta poderosa linguagem com seus frameworks e bibliotecas.

Por muitos anos seguidos, o JavaScript vem sendo a linguagem de programação com maior crescimento e procura. Ela é amplamente utilizada no desenvolvimento de interfaces interativas para a Web, pois é suportada por todos os navegadores modernos. Segundo a pesquisa anual realizada pela Stack Overflow, cerca de 70% dos 72.525 desenvolvedores profissionais que participaram da pesquisa, afirmaram que utilizam JavaScript. Além disso, é um dos idiomas mais procurados, pois os entrevistados que ainda não usaram, afirmaram que querem aprendê-lo.

Pelo sétimo ano consecutivo, o JavaScript é a linguagem de programação mais utilizada, com Python seguindo de categoria.

Empresas de todo o mundo utilizam JavaScript em seus stacks de linguagens. O JavaScript é o coração de qualquer grande empresa de tecnologia, como o PayPal, que foi um dos primeiros a adotar o NodeJS, Netflix, Groupon, Walmart e LinkedIn. 16 de 25 empresas Unicórnio dos EUA mencionam o JavaScript em suas tecnologias, portanto, é improvável que o JavaScript saia do grid em um futuro próximo.

Em relação aos frameworks web, vemos que os frameworks JavaScript continuam em pleno funcionamento, com o jQuery tomando o primeiro lugar, seguido do Angular/Angular.js, React.js,

ASP.NET entre outros. Ainda vemos o Vue.js em ascensão na lista de frameworks web mais utilizados

.

Entre outros frameworks, bibliotecas e ferramentas, vemos a ascensão do Node.js, que se tornou o mais utilizado, com 50.4%, seguido de .NET e .NET Core. React Native também possui uma grande quantia de usos, com 10.8% dos entrevistados afirmando utilizá-lo

.

Referências:

Gostou desta notícia? Comente abaixo!

Criando Pokedéx com React – Parte 4

Na parte 4 do nosso tutorial, vamos fazer o componente DetailView. Você poderá conferir a parte 3 no link: https://www.mundojs.com.br/2020/04/03/criando-pokedex-com-react-parte-3/

DetailView:

Vá para a sua pasta componentes e crie um arquivo chamado DetailView.js. Também vá para a pasta styles e crie o arquivo DetailView.css.

Abra o DetailView.js e siga esses passos:

  1. Importe o React;
  2. Importe o DetailView css;
  3. Cria uma nova função chamada DetailView;
  4. Retorne uma section vazia com className=”detail-view”;
  5. Adicione elementos para mostrar os dados e a imagem;
  6. Exporte a nova função criada.
import React from 'react';
import './styles/DetailView.css';

const DetailView = () => {
    return (
        <section className="detail-view">
            <img className='sprite-image' />
            <div className='data-wrapper'>
                <h1 className='data-name'></h1>
                <p className="data-char"></p>
            </div>
        </section>
    )
}

export default DetailView;

No seu arquivo DetailView.css, adicione o seguinte código:

.detail-view {
    width: 50%;
    height: 100%;
    padding: 10px;
    background-color: #df095e;
    border-top-right-radius: 10px;
    border-bottom-right-radius: 10px;
    display: flex;
    flex-direction: column;
    justify-content: center;
}

.sprite-image {
    width: 80%;
    height: 150px;
    margin: 10px auto;
    background-color: #585858;
    border: 15px solid #DEDEDE;
    color: #585858;
}

.data-wrapper {
    width: 80%;
    height: 110px;
    padding: 10px;
    margin: 0 auto;
    background-color: #585858;
    border-radius: 5px;
    box-shadow: inset 0 0 20px rgba(0, 0, 0, 0.22);
    color: #FFF;
}

.data-name {
    margin: 0 0 5px;
}

.data-char {
    font-size: 10px;
}
  1. O sprite-image conterá o Sprite Pokemón;
  2. A classe data-chat refere-se às características do Pokemón (id, nome, tipo).

No App.js, importe o componente DetailView. Renderize-o colocando o componente DetailView como uma tag html dentro do elemento pai.

import React, { Component } from 'react';
import PokeList from './PokeList';
import DetailView from './DetailView';
import './styles/App.css';
class App extends Component {
  constructor() {
    super();
    this.state = {};
  }

  render() {
    return (
      <div className = "App">
        <PokeList />
        <DetailView />
      </div>
    );
  }
}

export default App;

E este será o resultado:

Está gostando desta sequência de artigos? Comente abaixo!

Referências: https://blog.cloudboost.io/lets-build-a-pokedex-with-react-part-4-72afd23905a6

Criando Pokedéx com React – Parte 2

Na parte 2 do nosso projeto, construiremos o layout básico do nosso projeto. Você precisará da Parte 1 para dar sequência neste artigo.

Wireframe:

O React tem a ver com construção de componentes. Então, a melhor maneira de fazer isso é criar wireframes para mapeamento dos componentes a serem construídos. O nosso aplicativo principal terá dois componentes: a visualização do Pokemón e a visualização dos detalhes.

O Pokemon view conterá um componente chamado PokeList que envolverá 151 PokeCélulas (da primeira geração de Pokemón). Ao clicar em uma PokeCélula, a visualização dos detalhes mostrará as informações e a sprite do Pokemón selecionado.

Tipos de componentes:

O React possui 2 tipos básicos de componentes: stateful (com estado) e stateless (sem estado). Os componentes Stateful têm seu próprio estado. No nosso aplicativo, o componente APP será Stateful, pois manterá o estado dos dados do Pokemón.

Vamos construir!

Abra o App.js e exclua todo o conteúdo interno. A primeira etapa é importar o pacote React e desconstruir a classe Component.

import React, { Component } from 'react';

Agora, precisamos criar um novo aplicativo que estenda o Componente. Todos os componentes Stateful requerem dois métodos principais:

  1. Construtor: onde inicializamos o nosso estado;
  2. Render: onde escrevemos nosso jsx.

No construtor, precisamos chamar a função super(), pois estamos estendendo da classe componente. Além disso, precisamos declarar nosso estado inicial. Por enquanto, será um objeto vazio.

import React, { Component } from 'react';
class App extends Component {
  constructor() {
    super();
    this.state = {};
  }
}

Adicionaremos o método render. Ele retorna a sintaxe jsx, que é uma mistura de JavaScript e HTML. O método render só pode retornar um elemento, portanto, criaremos um elemento pai e aninharemos filhos dentro dele. Se estamos retornando um elemento aninhado, envolveremos ele entre parênteses.

import React, { Component } from 'react';
class App extends Component {
  constructor() {
    super();
    this.state = {};
  }

  render() {
    return (
      <div className = "App">

      </div>
    );
  }
}

Feito isso, importaremos nossa folha de estilo na parte superior para adicionar o CSS do nosso componente e exportar toda a classe para que possamos usá-la em outros arquivos.

import React, { Component } from 'react';
import './styles/App.css'
class App extends Component {
  constructor() {
    super();
    this.state = {};
  }

  render() {
    return (
      <div className = "App">

      </div>
    );
  }
}

export default App;

Abra o seu arquivo App.css e adicione o seguinte css:

.App {
    display: flex;
    align-items: center;
    justify-content: center;
    width: 650px;
    height: 400px;
    padding-left: 10px;
    margin: 50px auto;
    background-color: #FE0065;
    border-radius: 10px;
    box-shadow: 0 14px 45px rgba(0, 0, 0, 0.22), 0 18px 45px rgba(0, 0, 0, 0.22);
}

 

  1. Usamos o display: flex para separar as duas visualizações que construiremos;
  2. Fixamos a largura e altura para a tela do desktop;
  3. Aplicamos margem superior e inferior para separar a vista dos cantos e esquerda e direita automaticamente para coloca-los no meio;
  4. Aplicamos cor ao fundo.

Com isso, concluímos a Parte 2! Até a próxima!

Referências: https://blog.cloudboost.io/lets-build-a-pokedex-with-react-part-2-3d119b07f9e0

Criando Pokedéx com React – Parte 1

Olá pessoal, hoje criaremos uma pokedex usando React e utilizando o PokeAPI para obter os dados dos pokémon. Para isso, precisamos entender sobre o fetch. Caso você não conheça o assunto, sugiro a leitura deste artigo. Mãos à obra.

Instalando React App

No seu prompt de comando (CMD), coloque o seguinte comando:

npm install –g create-react-app

Isso instalará o react-app globalmente. Agora, precisamos criar a pasta do projeto. Utilize o comando:

create-react-app pokedex

E, criada a pasta do projeto, entraremos nela:

cd pokedex

Você encontrará uma pasta chamada src dentro do seu arquivo pokedex. Exclua o arquivo logo.svg, ele não será utilizado.

Dentro da pasta src, criaremos uma pasta chamada test e outra pasta chamada components. Dentro da pasta components, crie uma pasta chamada styles.

Mova o arquivo App.js para a pasta components, o arquivo App.css para a pasta style. Mova o arquivo App.test.js para a pasta test.

Vamos aos códigos:

Abrindo o arquivo App.js e reescreva o conteúdo com o código a seguir:

import React, { Component } from 'react';
import './styles/App.css';
class App extends Component {
  render() {
    return (
      <div className="App">
        Ola Mundo
      </div>
    );
  }
}

export default App;

Agora, abra o seu arquivo App.css e delete o seu conteúdo. Ele será reescrito posteriormente.

No arquivo index.css, reescreva o conteúdo com o código a seguir:

* {
  box-sizing: border-box;
}

body {
  margin: 0;
  padding: 0;
  font-family: 'Avenir Next', sans-serif;
}

h1,
h2,
h3,
h4,
p {
  margin: 0;
}

Este arquivo contém todos os nossos estilos top-level. Removemos todas as margens das tags h1, h2, h3, h4 e p e também, queremos que os elementos tenham o tamanho do border-box.

No arquivo index.js, precisamos importar os componentes do React, ReactDOM e os componentes do nosso App.

import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './components/App';
import * as serviceWorker from './serviceWorker';

ReactDOM.render(<App />, document.getElementById('root'));
serviceWorker.unregister();

Esse arquivo diz para o DOM renderizar o componente App no elemento com o ID “root”. O nosso componente APP conterá todos os componentes, que serão construídos. Para iniciar a aplicação, inicie com o comando:

npm start

E isso iniciará a nossa aplicação no navegador, então, toda vez que criarmos alterações no projeto. Se acontecer algum erro, o navegador exibirá informações sobre o erro.

Gostou? Fique atento aos próximos artigos!

Referências: https://blog.cloudboost.io/lets-build-a-pokedex-with-react-part-1-e1ba0b9387a7