<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Ricardo Pedroni on Medium]]></title>
        <description><![CDATA[Stories by Ricardo Pedroni on Medium]]></description>
        <link>https://medium.com/@rpedroni?source=rss-8d09c1d9ddc2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*VNyAVV4g8_AD0QbTi9r4Qw.jpeg</url>
            <title>Stories by Ricardo Pedroni on Medium</title>
            <link>https://medium.com/@rpedroni?source=rss-8d09c1d9ddc2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:34:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rpedroni/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Tudo sobre Testes - Testes Unitários vs. Testes de Integração vs. Testes E2E]]></title>
            <link>https://medium.com/rpedroni/tudo-sobre-testes-testes-unit%C3%A1rios-vs-testes-de-integra%C3%A7%C3%A3o-vs-testes-e2e-6a7cc955779?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a7cc955779</guid>
            <category><![CDATA[react-testing-library]]></category>
            <category><![CDATA[teste]]></category>
            <category><![CDATA[cypress]]></category>
            <category><![CDATA[e2e-testing]]></category>
            <category><![CDATA[unit-testing]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Fri, 18 Jun 2021 13:22:24 GMT</pubDate>
            <atom:updated>2021-06-18T13:22:24.756Z</atom:updated>
            <content:encoded><![CDATA[<p>Pelo jeito esse post é sobre testes.</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Não esqueça de ver essa aula e muitas outras no nosso Canal do YouTube!</a></p><p>Já que você está aqui, vamos ter uma conversa sincera?</p><p>Eu quero que você seja sincero comigo e diga a verdade. Não adianta mentir porque sendo professor, eu <strong><em>sempre </em></strong>sei a verdade. Sempre.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vU_e7d1N0MwCjhq5" /><figcaption>“Se aplicarmos essa equação podemos naturalmente concluir que o Carlos colou na prova.”</figcaption></figure><p>Responde aí: aposto que você sabe que fazer testes e testar bem seu projeto é importantíssimo.. mas você odeia fazer isso, né? Eu aposto que você odeia mesmo, seu monstro – mas agradeço sua sinceridade.</p><p>Sempre me questionei por que desenvolvedores não gostam de testes e a resposta é simples. O que nos motiva a virar engenheiros, programadores, arquitetos e desenvolvedores é nosso poder adquirido de <strong>criar e construir </strong>– a emoção de desenvolver está em ver coisas novas, concretizar aquilo que antes não existia.</p><p>Testes não fazem isso. Tipicamente testes são ensinados como “mera consequência”, algo que você faz porque você tem vergonha de não fazer, o setor de QA pediu ou.. você só não faz mesmo porque FODASSE TUDO #YOLO</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1RZZ2LrjWa_UFgS7" /><figcaption>vida loka rende foto boa pro insta</figcaption></figure><p>Seja lá o motivo, tendemos a não gostar de testes porque não aprendemos a fazê-los da forma correta – mas vamos corrigir isso hoje. Esse post servirá para dar um panorama geral de que tipos de testes existem, para que servem e como e onde devem ser usados ~ bora lá ✨</p><h3>Tipos de Testes</h3><p>Uma analogia que gosto bastante para os tipos de testes é uma que vi num <a href="https://kentcdodds.com/blog/static-vs-unit-vs-integration-vs-e2e-tests">post do Kent Dodds</a>. Basicamente testes e os tipos de testes são comparados com tinta e os pinceis usados para pintar uma parede. Imagine que você quer pintar a parede do seu quarto na cor da estação (Pantone me falou que é o “amarelo vibrante”). Para pintar toda a parede você pode usar um rolo grande, um pincel pequeno ou usar um jato de tinta. Usar apenas um provavelmente vai gerar um resultado ruim, ineficiente ou ambos. Se usar só o rolo grande, vai ter dificuldade de pintar os cantos e onde precisa de mais detalhes enquanto só usar o pincel fino demora demais, enquanto usar o jato de tinta.. bem, nunca pintei usando jato de tinta, mas certeza que ia fazer merda. Enfim, para dar cobertura de tinta adequada a sua parede, é necessário que use as ferramentas adequadas.</p><p>No mundo dos testes, temos os pinceis para cada nível de cobertura que queremos dar. Começando do mais fino ao mais grosso 😏:</p><ul><li><strong>Testes Unitários: </strong>são testes que vão cobrir uma <em>unidade</em> de funcionamento da sua aplicação. O conceito de unidade é abstrato mas tipicamente vai ser um módulo com um propósito próprio, como um uma função ou um componente Button em React. Nos testes unitários, normalmente tudo que podemos remover de conexões com o “mundo externo”, vamos remover, e colocar valores de teste (<em>mocks</em>) no lugar;</li><li><strong>Testes de Integração: </strong>quando for necessário testar múltiplas <em>unidades</em> juntas para ver se integradas umas às outras funcionam corretamente podemos escrever testes de integração. Aqui já tentamos usar menos mocks (i.e. deixamos as conexões mais “reais” entre si) para assimilar-se a um uso mais real. Um exemplo de teste de integração é ver se um formulário de login funciona (e.g. se o componente Button junto com Input e Form vão chamar sua callback se os valores de entrada são válidos);</li><li><strong>Testes Funcionais ou End-to-End (E2E): </strong>os rolos grandões, conhecido como “End-to-End” porque testam de ponta a ponta (no pt-BR formal, “de cabo a rabo”). Esses testes vão testar se uma funcionalidade completa da sua aplicação está de acordo, idealmente sem nenhum mock utilizado. A ideia é replicar ao máximo a experiência do seu usuário, como se fosse um robô no lugar dele fazendo as mesmas tarefas e vendo se é possível ou não completar de forma correta. Um exemplo pode ser verificar se um usuário consegue entrar na página do perfil dele, detectar se aparece o formulário de login, entrar com os dados dele, fazer o login e ver se ele é roteado para a página privada /my-profile após isso tudo caso os dados estiverem corretos, ou se voltamos para /login caso contrário.</li></ul><p>Repare que existe bastante mistura do que é um teste ou outro. É normal que se escreva um teste de integração que faz um pouco o papel de um teste unitário ou um teste E2E que fará uma pequena parte como um teste de integração, e não tem problema. Uma recomendação que daria é evitar que testes menores (i.e. unitário) façam o papel de testes maiores, justamente para manterem o escopo definido e para que mantenham seu <strong><em>custo</em></strong> baixo. Sim, é isso mesmo, cada teste tem custo.</p><p>Custo? CUSTO? Já odeio fazer e ainda preciso pagar pra ter?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*piUSbnnUjMavOEDj" /><figcaption>Com esse dinheiro, dá para comprar exatamente 23 testes.</figcaption></figure><p>Calma calma, Pedrinho, antes de ir vender seus BTCs para poder testar sua aplicação, vamos discutir o que é o conceito de custo no mundo de testes.</p><h3>O Custo de Testes</h3><p>Cada teste possui um custo próprio. O custo de um teste não é monetário (essa afirmação é parcialmente verdade, mais sobre isso depois) mas sim no tempo necessário para elaborar, escrever e manter o teste e o custo do <em>tempo de execução</em> desse teste. O custo do tempo de criação e manutenção do teste é evidente — quanto mais testes forem criados, mais tempo irá investir neles. Já sobre o custo do tempo de execução de um teste, lanço para você uma pergunta:</p><blockquote>Que tipo de teste tem maior custo: um teste unitário, um teste de integração ou teste E2E?</blockquote><p>Se você respondeu teste unitário, parabéns! Você errou! ✨</p><p>Os testes mais custosos de tempo de execução são os testes <strong>E2E</strong>. A razão por trás disso é simples: como um teste E2E vai testar um pedaço grande da aplicação, é necessário que a aplicação esteja em execução, significando que uma instância dela deverá “estar rodando”, possivelmente um backend/API vai precisar ser iniciado também para ter as conexões funcionais, e se esse teste for ser executado numa pipeline de CI/CD, haverá a necessidade de instalar todas as dependências do seu projeto e provavelmente fazer um build da versão final para poder executá-lo naquele ambiente. Por isso que além do custo de tempo mencionei a possibilidade de custo monetário, uma vez que executar um teste em CI requer algum tipo de computação adicional, incluindo algum sistema de integração continua — e isso vai te custar (tempo e alguns centavos de dólar aqui e ali).</p><h3>Cobertura de Testes</h3><p>Ouve-se muito o termo <strong>cobertura</strong> quando estamos falando de testes. Mas o que exatamente queremos dizer com isso?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*hnwGWjsVbKlxLX6i" /><figcaption>Sorvete com uma colher de sopa de testes unitários.</figcaption></figure><p><strong>Cobertura</strong> é uma métrica usada para saber quantos porcento (%) do nosso código está sendo testado. Normalmente usamos os testes unitários como base para esse cálculos. De forma genérica, a cobertura é a porcentagem do número de linhas que são testadas dividido pelo número total de linhas que existem no seu projeto, que resulta em um número. Esse cálculo pode ser menos ou mais preciso se a ferramenta de cobertura analisar individualmente as funções e ramificações do seu código e pode variar um tanto dependendo do método que escolher.</p><p>Dito tudo isso e sendo cobertura um número que identifica quanto do seu código está testado, desafio você à próxima polêmica pergunta:</p><blockquote>Numa escala de 0 a 100%, quantos porcento do seu código deve estar coberto por testes?</blockquote><p>Pensa nessa um pouco antes de responder…</p><p>…</p><p>Talvez como as bem intencionadas almas que vieram antes de você, você respondeu <strong>100%</strong>. Primeiramente, quero te parabenizar pela boa intenção — querer ter um código completamente testado é fantástico e mostra o seu compromisso com qualidade e profissionalismo.</p><blockquote>“MAS QUE CARALHA, PROFESSOR. A IDEIA NÃO É TESTAR PRA GARANTIR COISA BOA?”</blockquote><blockquote>- Albert Einstein, 1927</blockquote><p>Ótimo pergunta mas a resposta é mais complicada que isso. Veja bem, lembra que nós conversamos sobre o <strong>custo</strong> de testes agora pouco e concordamos que um teste tem um custo de criação, manutenção e execução. As leis da economia ditam que se algo possui um custo é natural que se tenha uma quantidade limitada desse item. Inclusive, para testes, existe um declínio do retorno de valor de adicionar testes após um dado ponto.</p><p>A cobertura de testes necessária e o ponto de declínio de retorno depende da especificação do projeto. Projetos críticos (hospitalares, aeroespaciais, etc.) normalmente terão coberturas maiores justamente para garantir que todos os “pedaços” estejam devidamente testados, inclusive com possíveis redundâncias e testes de casos extremamente improváveis mas que seriam fatais caso acontecessem.</p><p>No entanto, a maioria dos projetos não cai dentro dessas categorias e portanto o custo de testar excessivamente tem valor. Afinal, de quantas formas diferentes podemos testar um componente Button no seu projeto React para garantir que ele funciona corretamente? Precisamos fazer um teste para garantir que ele continua funcionando num browser IE6 rodando num Windows 98 sem javascript numa madrugada de maio?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*a9vi97eeBgUSGpIi.jpg" /><figcaption>&lt;Button color=”red”&gt;Launch Nuke&lt;/Button&gt; com poucos testes</figcaption></figure><p>Sei lá, o projeto e o tempo são seus. Mas lembre que quanto mais teste seu projeto tiver, em geral mais <em>qualidade </em>terá, ao custo de maior tempo de criação e execução.</p><blockquote>Mas, professor, eu quero o número mágico! Por isso que paguei por esse curso!</blockquote><p>Ok, vou te falar, mas só porque você pagou por esse curso.</p><p>Ao longo dos anos, pela minha experiência e troca de experiência com outros profissionais, um número genérico que tento seguir quando não temos uma especificação melhor é <strong>70%</strong>. O raciocínio por trás disso é que 70% cobre a maioria do projeto, especialmente as partes mais críticas e importantes, sem excessivamente demandar que todo e qualquer pedaço do projeto possua cobertura.</p><p>É importante destacar que isso não significa que tem várias partes do seu projeto sem nenhum teste — isso significa que pode ter casos de uso dele sem teste. Por exemplo, se uma dada função se comporta de algumas maneiras mas pode gerar um valor diferente em alguns casos bem específicos e esses casos não são muito importantes ou são difíceis de testar mas são meio evidentes que vão funcionar, talvez o investimento em testar essa parte não vale o tempo. Mas, novamente, tenha bastante zelo em analisar cada caso.</p><p>Outra recomendação <em>genérica</em> é limitar a quantidade de testes E2E que for fazer. Como comentei antes, é possível que um teste E2E seja praticamente um teste unitário, dada suas capacidades. Mas lembre também que testes E2E são os mais custosos para executar uma vez que o ambiente de execução inteiro estará de pé para isso. Consequentemente procure tentar cobrir as “rotas” ou casos de uso mais essenciais ou importantes da sua aplicação e vá adicionando esses testes gradativamente em outras partes, caso sentir que elas estejam pouco protegidas de erros ou mesmo para garantir que um bug que apareceu esteja consertado e não venha a ter regressão.</p><p>Fato curioso: num projeto recente meu, nossos testes E2E rodando no CI demoravam em média 45 minutos para executarem. Isso significa que para que seu código seja aceito para ser <em>mergeado</em> ao master, você precisaria esperar quase 1 hora e ainda, caso houvesse algum erro, você precisaria consertar esse erro e começar tudo de volta 🎉 Alegria pura — inclusive nesse projeto tomamos a (controversa) decisão de remover alguns testes E2E que cobriam áreas bastante não-importantes para diminuir um pouco esse tempo. Caiu para ~30min (velocidade da luz praticamente).</p><h3>Distribuição de Testes</h3><p>Já que estamos falando de cobertura e tipos de testes, uma pergunta que se pode fazer é em quais testes devemos dar mais importância.</p><p>Unitários porque validam as partes menores? Integração porque garantem bom comportamento entre as partes? Ou E2E que garantem que sua aplicação funcione da forma que você espera que seus usuários a usem?</p><p>Igual a quando falamos sobre cobertura, responder isso aqui de uma forma exata é difícil. Mas já que estamos apelando para genéricos, eu diria que uma distribuição saudável seria:</p><ul><li><strong>Testes Unitários: </strong>garanta que as unidades principais funcionem corretamente, teste todas as outras unidades com testes básicos, pode pular testes difíceis de realizar nas não-essenciais → <strong>~30% dos esforços</strong></li><li><strong>Testes de Integração: → </strong>garanta que as combinações críticas estejam conversando adequadamente (i.e. sem elas, o usuário não conseguiria usar nada), evite <em>mockear</em> o que puder → <strong>~50% dos esforços</strong></li><li><strong>Testes E2E: </strong>garanta que os casos de uso principais estejam cobertos, adicione testes de funcionamento necessário (“smoke tests”) <strong>→ ~20% dos esforços</strong></li></ul><p>Novamente, analise isso para seu projeto específico.</p><p>Tenho até medo de colocar números assim porque existem 3 tipos de desenvolvedores:</p><ol><li><strong>Os racionais</strong>: vão entender que isso tudo que foi falado são diretrizes e recomendações de boas práticas, e vão usar de forma racional nos seus projetos, mas sempre lembrando que cada caso é um caso;</li><li><strong>Os fanáticos: </strong>“TEM QUE SER 20% DE E2E PORQUE O CARA LÁ DO POST FALOU QUE TEM QUE SER 20%. COMO ASSIM TÁ ERRADO? O CARA É PROFESSOR PORRA! 20% OU VOU EMBORA”. Aí passa uma semana criando uma calculadora para garantir que passou 20% do tempo em testes E2E (e 80% criando a calculadora);</li><li><strong>Os chatopaporra: </strong>“Veja bem, eu trabalhei na Amagoogleappleflix e lá nós usamos 50% de testes unitários com 2 revisões manuais feito por um time de QA dedicado. 50% é a resposta correta”.</li></ol><p>Eu já trabalhei em projetos que ~90% dos testes eram unitários e o resto E2E, sem nenhum tipo de teste de integração e tudo deu certo. Eu já trabalhei em projeto que não tinha NADA de testes e deu tudo certo… huehue mentira projeto sem teste sempre dá merda uma hora — adicionamos um monte de teste unitário depois e… ajudou (saudades da época de estagiário ❤).</p><p>Pare, pense e veja o que é melhor para o seu caso em particular :)</p><p>Espero que esse post tenha te ajudado e que possamos ter um mundo com mais testes, mais qualidade e mais pessoas dormindo tranquilamente sabendo que seu botão vermelho de bomba nuclear está devidamente coberto.</p><p>Abraço e até a próxima aula!</p><p>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://bit.ly/3q0TIAU">Ah, e me acompanhe também lá no YouTube</a>✌!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a7cc955779" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rpedroni/tudo-sobre-testes-testes-unit%C3%A1rios-vs-testes-de-integra%C3%A7%C3%A3o-vs-testes-e2e-6a7cc955779">Tudo sobre Testes - Testes Unitários vs. Testes de Integração vs. Testes E2E</a> was originally published in <a href="https://medium.com/rpedroni">RPEDRONI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…]]></title>
            <link>https://medium.com/reactbrasil/server-side-rendering-single-page-application-static-site-generation-incremental-static-1de36475d0c8?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/1de36475d0c8</guid>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[ssg]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[isr]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Tue, 11 May 2021 18:07:58 GMT</pubDate>
            <atom:updated>2021-05-11T23:53:03.674Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 3)</h3><p>Continuando nossa viagem no mundo da renderização.</p><p>Essa aula faz parte de uma série então veja a <a href="https://medium.com/reactbrasil/server-side-rendering-vs-static-site-generation-vs-single-page-application-vs-incremental-static-e91804ef9401">Parte #1</a> e <a href="https://medium.com/reactbrasil/server-side-rendering-vs-static-site-generation-vs-single-page-application-vs-incremental-static-e91804ef9401">Parte #2</a> para perder nenhum detalhe 👌</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://youtu.be/-8af2gClT-M">Não esqueça de ver essa aula e muitas outras no nosso Canal do YouTube!</a></p><p>Na aula passada, ao longo de nossa linda viagem ao longo da história da internet, falamos sobre as técnicas que possibilitam criamos aplicações do lado do cliente, alavancando tecnologias como o AJAX (Asynchronous JavaScript and XML) para habilitar o uso de SPA (Single Page Applications), como visto em aplicações React, Angular e Vue.</p><p>Ao passo que essas tecnologias nos permitem criar aplicações complexas com tamanhos iniciais de página mínimos e respostas rápidas de navegação entre páginas, existem algumas limitações também. No final da aula, levantamos alguns pontos que podem ser problemáticos às suas necessidades, como o impacto em SEO e as páginas iniciais em branco, já que o JS vai popular a página só depois de carregar tudo do servidor.</p><p>Ou seja, com cada ferramenta que temos, existem pontos fortes e fracos a serem considerados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MW7IGIueJa0oFJ0G" /><figcaption>Quer dizer que existe uma ferramenta melhor que uma chave inglesa para martelar pregos?!</figcaption></figure><p>Nesse momento na história da web, as soluções de renderização caem basicamente em duas categorias:</p><ul><li>O servidor fornece um documento pronto, usando especialmente SSR onde um documento vai ser devolvido, sendo renderizado pelo servidor a cada requisição;</li><li>O servidor devolve um documento mínimo, apenas com HTML básico e as “conexões” dos scripts JS necessários para depois construir a página e hidratar a aplicação com a funcionalidade necessária.</li></ul><p>É importante destacar que existe uma desvantagem ambas essas tecnologias vigentes comparadas com como a Web 1.0 e os documentos estáticos funcionavam — para qualquer requisição, é necessário que o servidor ou o cliente façam algum tipo e processamento adicional para que o documento ou página chegue num estado final.</p><p>Com isso em mente, a pergunta que muitos se fizeram foi: “Será que é possível ter as vantagens de performance de documentos estáticos e prontos com a possibilidade de customizar o que vai ser entregue ao cliente?”</p><p>E eis que o conceito de Geração Estática apareceu.</p><h4>Static Site Generation (SSG)</h4><p>Geração Estática (mais conhecida pelo seu nome bonito em inglês, Static Site Generation) é um conceito relativamente simples:</p><blockquote>Se o conteúdo que irá aparecer na sua página/site/documento muda relativamente pouco, gere esse documento uma única vez invés de renderizá-lo para toda requisição</blockquote><p>Ou seja, invés de cada cliente pedir o documento e o servidor precisar puxar as informações todas as vezes (e.g. ler um banco de dados, abrir um arquivo), faça essa operação de leitura uma única vez e construa o documento com essa informação já embutida nele. Pode-se fazer uma analogia com “compilar” seu documento já que a ferramenta que vai fazer isso precisa analisar o que está sendo pedido e gerar um resultado, que é o documento estático.</p><p>O momento que essa “compilação” vai acontecer depende da ferramenta mas tipicamente isso vai ser o momento de build do projeto — normalmente antes de fazer o upload dos arquivos para algum servidor, por exemplo.</p><p>Todo esse processo pode ser feito manualmente ou podemos construir algo que faria isso mas existem excelentes ferramentas que já possuem essa capacidade, como o <a href="https://www.gatsbyjs.com/">Gastby</a> e o <a href="https://nextjs.org/">Next.js</a>. Tipicamente essas ferramentas, além de serem capazes de analisar seus documentos e gerar estaticamente o que for possível, também tem suporte para a criação de projetos mistos, onde alguns documentos são estáticos e outros são dinâmicos, podendo inclusive usar o React para montar suas páginas.</p><p>Um bom exemplo de uma aplicação que funciona bem com o uso do SSG é um blog. Por mais prolífero que possa ser como autor, normalmente haverão dias entre um post e outro (a menos que seja blog tipo BuzzFeed que solta post a cada 15 minutos tipo “10 Coisas Que Seu Signo Diz Sobre Sua Vida Sexual). Nesse caso, se um usuário acessar seu blog agora e outro daqui 10 horas, o conteúdo devolvido será exatamente o mesmo. Para evitar que o servidor precise ler de um CMS ou banco de dados para montar o documento, faz sentido gerar uma versão estática do blog e devolver o mesmo documento para ambos os leitores.</p><p>Já se sua aplicação trabalhar com dados em tempo real ou tem informações que atualizam constantemente, o SGG certamente não será uma solução prática uma vez que é necessário “compilar” seu projeto toda vez que desejar gerar um documento novo aos seus usuários.</p><p>Mas… e se invés de gerar um documento estático manualmente, fosse possível que o servidor regenerasse esse documento de tempos em tempos, gerando um documento atualizado cada vez? Excelente pergunta, jovem 👌 Eis que apresento a Regeneração Estática Incremental.</p><p><strong>Incremental Static Regeneration (ISR)</strong></p><p>A Regeneração Estática Incremental (credo como esses nomes ficam mais feio em pt-BR) ou ISR é virtualmente a mesma coisa que o SSG com uma pequena diferença — o ISR gera os documentos estáticos toda vez que um gatilho é acionado. Esse gatilho pode ser um determinado de tempo, uma url específica visitada ou uma flag setada em algum lugar. Não importa muito qual é a fonte do gatilho mas, sim, que uma vez acionado, um novo documento estático será gerado, possuindo as informações atualizadas nele.</p><p>Voltando ao exemplo do blog (agora modelo BuzzFeed e seu conteúdo de qualidade) e supondo que um novo post é criado a cada 1 hora, usando um gatilho de tempo de 1 hora, o ISR vai gerar um novo documento estático com os posts mais atualizados a cada 1 hora mas qualquer visita dentro desse intervalo vai ser respondida com o documento estático previamente gerado.</p><p>Olhando dessa forma, é natural achar que o ISR é <em>sempre melhor</em> que o SSG. Só lhe digo uma coisa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*BXd7F-Nge-Az4KE6.jpg" /><figcaption>Achou errado,</figcaption></figure><p>Repare que o ISR necessita de um servidor “inteligente” (Node, PHP, etc.) que possa ler as informações de alguma fonte (e.g banco de dados, CMS) e que então pode criar um novo documento estático com essas informações estáticas. Já no caso do SSG, um servidor que simplesmente devolve documentos para uma dada url resolve (como um CDN). Então leve isso em consideração na hora de escolher sua solução.</p><h4>Para Onde Agora?</h4><p>Com todas essas técnicas e ferramentas em mãos, a lista de perguntas que se pode fazer para determinar o que é melhor para sua aplicação começa a ficar bem grande. Meu conteúdo muda bastante ou pouco? Preciso personalizar o que é devolvido ou não? Minha aplicação é toda privada ou tem partes públicas? SEO importa ou não? Métricas como <em>First Meaningful Paint</em> são essenciais para meu projeto? Existe vida após a morte? Quais são as 10 coisas que meu signo afetam na minha vida sexual?</p><p>Perguntas importantes.</p><p>Mas bacana também que existem ferramentas que resolvem boa parte desses problemas, como o Next.js — que por <em>coincidência</em> será o tópico na próxima aula. Abraço e até lá!</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube</a> ✌</p><h3>TLDR;</h3><ul><li>Documentos estáticos possuem a vantagem de “estarem prontos” — quando são requisitados, o servidor simplesmente devolve o próprio documento;</li><li>A Web 1.0 já oferecia documentos estáticos mas sem nenhuma configuração ou personalização;</li><li>A Web 2.0 passou a um modelo dinâmico, onde o servidor tipicamente renderiza o conteúdo a ser mostrado a cada requisição;</li><li>Uma potencial evolução para isso é gerar documentos estáticos mas puxando informação de fontes dinâmicas (e.g. bancos de dado, CMS);</li><li><strong>SSG (Static Site Generation)</strong> é uma técnica que faz justamente isso — no momento de compilação ou construção da sua aplicação, o conteúdo é lido e as partes estáticas são geradas;</li><li><strong>ISR (Incremental Static Regeneration)</strong> funciona de forma similar, porém gerando o documento estático a cada período determinado.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1de36475d0c8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/reactbrasil/server-side-rendering-single-page-application-static-site-generation-incremental-static-1de36475d0c8">Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…</a> was originally published in <a href="https://medium.com/reactbrasil">React Brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…]]></title>
            <link>https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-465ab6ac9306?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/465ab6ac9306</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[ssg]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[isr]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Tue, 11 May 2021 18:06:26 GMT</pubDate>
            <atom:updated>2021-05-11T23:53:34.510Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 3)</h3><p>Continuando nossa viagem no mundo da renderização.</p><p>Essa aula faz parte de uma série então veja a <a href="https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-f183fda64101">Parte #1</a> e <a href="https://rpedroni.medium.com/server-side-rendering-single-page-application-static-site-generation-incremental-static-615e697d9b31">Parte #2</a> para perder nenhum detalhe 👌</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://youtu.be/-8af2gClT-M">Não esqueça de ver essa aula e muitas outras no nosso Canal do YouTube!</a></p><p>Na aula passada, ao longo de nossa linda viagem ao longo da história da internet, falamos sobre as técnicas que possibilitam criamos aplicações do lado do cliente, alavancando tecnologias como o AJAX (Asynchronous JavaScript and XML) para habilitar o uso de SPA (Single Page Applications), como visto em aplicações React, Angular e Vue.</p><p>Ao passo que essas tecnologias nos permitem criar aplicações complexas com tamanhos iniciais de página mínimos e respostas rápidas de navegação entre páginas, existem algumas limitações também. No final da aula, levantamos alguns pontos que podem ser problemáticos às suas necessidades, como o impacto em SEO e as páginas iniciais em branco, já que o JS vai popular a página só depois de carregar tudo do servidor.</p><p>Ou seja, com cada ferramenta que temos, existem pontos fortes e fracos a serem considerados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MW7IGIueJa0oFJ0G" /><figcaption>Quer dizer que existe uma ferramenta melhor que uma chave inglesa para martelar pregos?!</figcaption></figure><p>Nesse momento na história da web, as soluções de renderização caem basicamente em duas categorias:</p><ul><li>O servidor fornece um documento pronto, usando especialmente SSR onde um documento vai ser devolvido, sendo renderizado pelo servidor a cada requisição;</li><li>O servidor devolve um documento mínimo, apenas com HTML básico e as “conexões” dos scripts JS necessários para depois construir a página e hidratar a aplicação com a funcionalidade necessária.</li></ul><p>É importante destacar que existe uma desvantagem ambas essas tecnologias vigentes comparadas com como a Web 1.0 e os documentos estáticos funcionavam — para qualquer requisição, é necessário que o servidor ou o cliente façam algum tipo e processamento adicional para que o documento ou página chegue num estado final.</p><p>Com isso em mente, a pergunta que muitos se fizeram foi: “Será que é possível ter as vantagens de performance de documentos estáticos e prontos com a possibilidade de customizar o que vai ser entregue ao cliente?”</p><p>E eis que o conceito de Geração Estática apareceu.</p><h4>Static Site Generation (SSG)</h4><p>Geração Estática (mais conhecida pelo seu nome bonito em inglês, Static Site Generation) é um conceito relativamente simples:</p><blockquote>Se o conteúdo que irá aparecer na sua página/site/documento muda relativamente pouco, gere esse documento uma única vez invés de renderizá-lo para toda requisição</blockquote><p>Ou seja, invés de cada cliente pedir o documento e o servidor precisar puxar as informações todas as vezes (e.g. ler um banco de dados, abrir um arquivo), faça essa operação de leitura uma única vez e construa o documento com essa informação já embutida nele. Pode-se fazer uma analogia com “compilar” seu documento já que a ferramenta que vai fazer isso precisa analisar o que está sendo pedido e gerar um resultado, que é o documento estático.</p><p>O momento que essa “compilação” vai acontecer depende da ferramenta mas tipicamente isso vai ser o momento de build do projeto — normalmente antes de fazer o upload dos arquivos para algum servidor, por exemplo.</p><p>Todo esse processo pode ser feito manualmente ou podemos construir algo que faria isso mas existem excelentes ferramentas que já possuem essa capacidade, como o <a href="https://www.gatsbyjs.com/">Gastby</a> e o <a href="https://nextjs.org/">Next.js</a>. Tipicamente essas ferramentas, além de serem capazes de analisar seus documentos e gerar estaticamente o que for possível, também tem suporte para a criação de projetos mistos, onde alguns documentos são estáticos e outros são dinâmicos, podendo inclusive usar o React para montar suas páginas.</p><p>Um bom exemplo de uma aplicação que funciona bem com o uso do SSG é um blog. Por mais prolífero que possa ser como autor, normalmente haverão dias entre um post e outro (a menos que seja blog tipo BuzzFeed que solta post a cada 15 minutos tipo “10 Coisas Que Seu Signo Diz Sobre Sua Vida Sexual). Nesse caso, se um usuário acessar seu blog agora e outro daqui 10 horas, o conteúdo devolvido será exatamente o mesmo. Para evitar que o servidor precise ler de um CMS ou banco de dados para montar o documento, faz sentido gerar uma versão estática do blog e devolver o mesmo documento para ambos os leitores.</p><p>Já se sua aplicação trabalhar com dados em tempo real ou tem informações que atualizam constantemente, o SGG certamente não será uma solução prática uma vez que é necessário “compilar” seu projeto toda vez que desejar gerar um documento novo aos seus usuários.</p><p>Mas… e se invés de gerar um documento estático manualmente, fosse possível que o servidor regenerasse esse documento de tempos em tempos, gerando um documento atualizado cada vez? Excelente pergunta, jovem 👌 Eis que apresento a Regeneração Estática Incremental.</p><p><strong>Incremental Static Regeneration (ISR)</strong></p><p>A Regeneração Estática Incremental (credo como esses nomes ficam mais feio em pt-BR) ou ISR é virtualmente a mesma coisa que o SSG com uma pequena diferença — o ISR gera os documentos estáticos toda vez que um gatilho é acionado. Esse gatilho pode ser um determinado de tempo, uma url específica visitada ou uma flag setada em algum lugar. Não importa muito qual é a fonte do gatilho mas, sim, que uma vez acionado, um novo documento estático será gerado, possuindo as informações atualizadas nele.</p><p>Voltando ao exemplo do blog (agora modelo BuzzFeed e seu conteúdo de qualidade) e supondo que um novo post é criado a cada 1 hora, usando um gatilho de tempo de 1 hora, o ISR vai gerar um novo documento estático com os posts mais atualizados a cada 1 hora mas qualquer visita dentro desse intervalo vai ser respondida com o documento estático previamente gerado.</p><p>Olhando dessa forma, é natural achar que o ISR é <em>sempre melhor</em> que o SSG. Só lhe digo uma coisa:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/0*BXd7F-Nge-Az4KE6.jpg" /><figcaption>Achou errado,</figcaption></figure><p>Repare que o ISR necessita de um servidor “inteligente” (Node, PHP, etc.) que possa ler as informações de alguma fonte (e.g banco de dados, CMS) e que então pode criar um novo documento estático com essas informações estáticas. Já no caso do SSG, um servidor que simplesmente devolve documentos para uma dada url resolve (como um CDN). Então leve isso em consideração na hora de escolher sua solução.</p><h4>Para Onde Agora?</h4><p>Com todas essas técnicas e ferramentas em mãos, a lista de perguntas que se pode fazer para determinar o que é melhor para sua aplicação começa a ficar bem grande. Meu conteúdo muda bastante ou pouco? Preciso personalizar o que é devolvido ou não? Minha aplicação é toda privada ou tem partes públicas? SEO importa ou não? Métricas como <em>First Meaningful Paint</em> são essenciais para meu projeto? Existe vida após a morte? Quais são as 10 coisas que meu signo afetam na minha vida sexual?</p><p>Perguntas importantes.</p><p>Mas bacana também que existem ferramentas que resolvem boa parte desses problemas, como o Next.js — que por <em>coincidência</em> será o tópico na próxima aula. Abraço e até lá!</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube</a> ✌</p><h3>TLDR;</h3><ul><li>Documentos estáticos possuem a vantagem de “estarem prontos” — quando são requisitados, o servidor simplesmente devolve o próprio documento;</li><li>A Web 1.0 já oferecia documentos estáticos mas sem nenhuma configuração ou personalização;</li><li>A Web 2.0 passou a um modelo dinâmico, onde o servidor tipicamente renderiza o conteúdo a ser mostrado a cada requisição;</li><li>Uma potencial evolução para isso é gerar documentos estáticos mas puxando informação de fontes dinâmicas (e.g. bancos de dado, CMS);</li><li><strong>SSG (Static Site Generation)</strong> é uma técnica que faz justamente isso — no momento de compilação ou construção da sua aplicação, o conteúdo é lido e as partes estáticas são geradas;</li><li><strong>ISR (Incremental Static Regeneration)</strong> funciona de forma similar, porém gerando o documento estático a cada período determinado.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=465ab6ac9306" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-465ab6ac9306">Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…</a> was originally published in <a href="https://medium.com/rpedroni">RPEDRONI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…]]></title>
            <link>https://medium.com/reactbrasil/server-side-rendering-single-page-application-static-site-generation-incremental-static-f9b5d9b0bf8d?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/f9b5d9b0bf8d</guid>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[ssg]]></category>
            <category><![CDATA[rendering]]></category>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Mon, 26 Apr 2021 20:26:13 GMT</pubDate>
            <atom:updated>2021-04-26T20:26:13.456Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 2)</h3><p>Renderizando como se não houvesse amanhã.</p><p>Essa aula faz parte de uma série então veja a <a href="https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-f183fda64101">Parte #1</a> se quiser começar do começo.</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://youtu.be/x2a8IuIqgrs">Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">muitas outras no nosso Canal do YouTube!</a></p><p>Terminamos a aula passada discutindo sobre o <strong>Server Side Rendering (SSR)</strong> e como essa técnica nos habilitou a termos uma internet mais dinâmica e personalizada, uma vez que páginas poderiam ser geradas a medida que fossem requisitadas. Com isso em mente, vamos nos ambientar melhor em como o modelo cliente-servidor funcionava na época.</p><p>Independentemente se estamos falando de SSR ou páginas estáticas, tipicamente a interação entre um cliente e um servidor seguia o modelo:</p><ol><li>Cliente: me dê o documento localizado em <em>site.com/meu-perfil</em></li><li>Servidor: deixa eu ver eu tenho esse documento… tenho sim, toma aqui.</li><li>Cliente: obrigado, servidor. (opcional, apenas browsers educados)</li></ol><p>Além dessa sequência <em>altamente técnica</em> de troca de mensagens, repare que até agora, sempre falamos na troca ou requisição de <strong>páginas e documentos</strong>. Isso foi intencional porque nessa época, o conceito de troca de informação ainda era à base de troca de documentos inteiros e isso não é a toa — todo o início da internet foi fundamentado nessa troca de documentos.</p><p>Mas é importante destacar que esse modelo de documentos inteiros fazia muito sentido quando a internet era uma ferramenta de pouca criação e muita leitura. Como falamos na aula passada, a partir do momento que “evoluímos” para a Web 2.0 e toda a dinâmica e velocidade que ela trouxe e precisava, esse modelo começou a apresentar alguns problemas.</p><p>Veja bem — agora <em>não somos mais meros leitores e espectadores</em> dos documentos alheios, agora somos criadores e geramos posts envolventes e tweets sobre quantas fatias de presunto colocamos no sanduíche que acabamos de comer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*worr81Up-50ksYh-" /><figcaption>Como montar um sanduíche foda desses e NÃO compartilhar com meus 73 seguidores?</figcaption></figure><p>Nessa era de geração de conteúdo, uma interação entre cliente e servidor para criar um conta de usuário numa plataforma poderia ser assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ereEBb4k_g-ERUEXKx8Arw.png" /></figure><p>Num modelo predominantemente baseado na troca de documentos, qualquer interação entre um cliente e um servidor precisa receber e enviar documentos inteiros para que essa troca possa ocorrer. Apesar de funcionar, isso torna a experiência de usuário (famosa ú·xis) precária, uma vez que seu usuário pode ficar segundos esperando com uma tela vazia enquanto o servidor carrega ou processa alguma informação.</p><p>…e por muitos anos, fazer o quê, era o jeito de se <em>fazer a internet </em>🤷‍♀️</p><p>Mas no começo dos anos 2000, com o crescimento i̶n̶c̶e̶s̶s̶a̶n̶t̶e̶ contínuo de plataformas sociais, outros meios de criação de conteúdo e a necessidade de nos aproximarmos mais de experiências rápidas e em tempo real, desenvolvedores se viram com a necessidade de sanar esse problema de troca de documentos inteiros… e eis que uma <em>tecnologia</em> nasceu.</p><p>Apelidado de <strong>AJAX </strong>(<strong>Asynchronous JavaScript and XML), </strong>essa tecnologia permitia que clientes e servidores pudessem conversar de forma <em>assíncrona</em> (i.e. sem precisar sincronamente trocar um documento/carregar uma página inteira) usando <strong>JavaScript</strong> para fazer essas chamadas e o servidor respondendo com <strong>dados</strong> <strong>invés de documentos</strong>, tipicamente usando o formato <strong>XML.</strong></p><blockquote>Vou fazer uma pausa aqui para explicar uma coisa — se você não estava trabalhando ou envolvido na área web nessa época, você provavelmente nunca ouviu esse termo e talvez nem sabia que um dia a web não trabalhava com chamadas assíncronas — mas deixa eu te explicar uma coisa: para qualquer um envolvido na comunidade na época, <strong><em>AJAX foi revolucionário</em>.</strong></blockquote><p>AJAX talvez seja uma das siglas mais fadadas a parecer velha logo de cara porque XML era uma linguagem de markup bastante utilizadas na época mas que perdeu espaço rapidamente para JSON como um formato de troca de dados.</p><blockquote>Pausa #2: Você já se perguntou alguma vez porque que no DevTools do browser existe o filtro “XHR” na aba de Network? Ou por que que o JavaScript tem um método chamado de XML Http Request (eis o XHR)? A resposta é porque tudo isso começou com o singelo uso do XML e o nome acabou ficando.</blockquote><p>Com essa tecnologia <em>revolucionária</em>, agora era possível um cliente e servidor se comunicarem sem ter que trocar um documento completou ou carregar uma página nova. No exemplo da criação de conta, basta agora o cliente mandar as informações do formulário e o servidor pode responder com os dados, se deu certo ou não, etc., e o browser pode agir de acordo — inclusive, isso abriu a porta para páginas “em tempo real”, como cotações de valores, resultados e números que mudam constantemente (inclusive servindo como base para anos depois o aparecimento dos <em>websockets </em>e seu modelo <em>push</em>).</p><p>Como agora o cliente poderia executar mais coisas do lado dele (e as máquinas dos clientes estavam ficando mais poderosas), as responsabilidades e funcionalidades <strong>client-side</strong> começaram a aumentar. Foi nessa época que o conceito de “Servidores APIs” começou a se fortalecer, com servidores que já não devolviam mais páginas ou documentos mas apenas informação, com um esquema de URLs estruturada seguindo alguma lógica (eis nosso amigo REST ganhando força), devolvendo essa informação tipicamente usando XML ou JSON.</p><p>Devido ao fato do cliente agora ter tantas possibilidades, cada vez mais criamos aplicações complexas do lado dele, indo ao ponto de criarmos aplicações inteiras que vivem <strong>apenas</strong> <strong>do lado do cliente</strong>, com o servidor servindo <strong>apenas para devolver o documento original e responder com dados,</strong> quando o cliente pedir esses dados dele.</p><p>Nesse esforço de termos clientes robustos, nasce o que hoje chamamos de <strong>Single Page Application</strong> <strong>(SPA)</strong>. Mais uma vez, o nome é bastante pertinente. SPAs são documentos mínimos (i.e. tem a menor quantidade de informação possível de início) e que podem então ser puxados rapidamente do servidor. Uma vez no cliente, é papel do JavaScript montar toda a estrutura e conectar dados com interface, criando efetivamente o que você vê e com o que você interage.</p><p>Quando criamos um app usando o <a href="https://create-react-app.dev/">Create React App</a><em>, </em>o que é criado é um SPA, e o único documento que existe é o index.html e sua “aplicação inteira” se resume a:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/73c136b33e2e9fc47d418cca3dfec66c/href">https://medium.com/media/73c136b33e2e9fc47d418cca3dfec66c/href</a></iframe><p>O segredo em SPAs é que vai existir uma forma do JavaScript interagir com o documento e, a partir dele, criar toda a estrutura do app (no caso do React, normalmente é o &lt;div id=&quot;root&quot;&gt; )</p><p>SPAs são leves, rápidos de baixar e tipicamente fornecem uma boa experiência de usuário se programados corretamente. Mas como toda coisa boa, tem coisa <em>não tão boa</em> <em>assim</em> também.</p><p>Se sua aplicação se importa com SEO (lembrando que nem todo app vai se importar com isso, como painéis admin ou qualquer parte da sua aplicação atrás de um login), SPAs podem ser detrimentais, uma vez que os <em>crawlers</em> de SEO vão enxergar uma página praticamente vazia e sem conteúdo (vide nosso código acima ali). Outro potencial problema é que se criado de forma ingênua, um SPA pode forçar o cliente a baixar a aplicação inteira, mesmo partes dela que ele nunca vai usar ou acessar, visto que não existem URLs ou documentos explícitos. Ambos esses problemas podem ser resolvidos mas nem sempre é trivial trazer essas otimizações dependendo como sua aplicação foi programada. Então antes de sair fazendo um SPA em React ou Angular (ou JS puro se você for insano), dê uma pensada nessas consequências.</p><p>E eis que na nossa caminha pela história da web, temos ferramentas agora para gerar aplicações mais dinâmicas, com o uso ainda de documentos inteiros ou apenas partes deles, usando AJAX e, caso queiramos fazer uma aplicação inteira client-side, SPA.</p><p>Mas nessa busca constante de melhorarmos a experiência dos usuários e dos desenvolvedores, começou-se a sentir falta de uma forma de gerar páginas e documentos completos e prontos. E começou-se a hipotetizar: “Imagina que legal se tivéssemos uma forma de ter os documentos já prontos no lado do servidor e que, bastasse o cliente pedir por eles, eles receberiam esse documento pronto imediatamente, sem quer o servidor precisasse gerar eles? Imagina se pudéssemos trabalhar com documentos… estáticos”</p><p>E como a moda se repete, também se repete a tecnologia — falaremos sobre documentos e geração estática na aula que vem ~ aquele abraço e até lá! ✌️</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube! </a>✌</p><h3>TLDR;</h3><ul><li>O funcionamento original do modelo cliente-servidor era à base de troca de documentos e páginas completas;</li><li>Esse funcionamento trazia uma experiência mediocre, uma vez que qualquer interação, por menor que fosse, requeria que o servidor enviasse um documento completo novo;</li><li><strong>AJAX </strong>apareceu como uma solução para pedidos assíncrono de informação;</li><li>Baseado nesses pedidos assíncronos, aplicações inteiras foram criadas do lado do cliente (client-side), chamadas de <strong>Single Page Applications (SPA)</strong>, devido ao fato de tipicamente serem uma única página/documento;</li><li>SPA são tipicamente leves e rápidos mas podem ser uma solução medíocre se sua aplicação necessita de alguns fatores, como SEO.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f9b5d9b0bf8d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/reactbrasil/server-side-rendering-single-page-application-static-site-generation-incremental-static-f9b5d9b0bf8d">Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…</a> was originally published in <a href="https://medium.com/reactbrasil">React Brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…]]></title>
            <link>https://rpedroni.medium.com/server-side-rendering-single-page-application-static-site-generation-incremental-static-615e697d9b31?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/615e697d9b31</guid>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[isr]]></category>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[ssg]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Thu, 08 Apr 2021 16:14:05 GMT</pubDate>
            <atom:updated>2021-04-26T20:19:36.146Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 2)</h3><p>Renderizando como se não houvesse amanhã.</p><p>Essa aula faz parte de uma série então veja a <a href="https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-f183fda64101">Parte #1</a> se quiser começar do começo.</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://youtu.be/x2a8IuIqgrs">Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">muitas outras no nosso Canal do YouTube!</a></p><p>Terminamos a aula passada discutindo sobre o <strong>Server Side Rendering (SSR)</strong> e como essa técnica nos habilitou a termos uma internet mais dinâmica e personalizada, uma vez que páginas poderiam ser geradas a medida que fossem requisitadas. Com isso em mente, vamos nos ambientar melhor em como o modelo cliente-servidor funcionava na época.</p><p>Independentemente se estamos falando de SSR ou páginas estáticas, tipicamente a interação entre um cliente e um servidor seguia o modelo:</p><ol><li>Cliente: me dê o documento localizado em <em>site.com/meu-perfil</em></li><li>Servidor: deixa eu ver eu tenho esse documento… tenho sim, toma aqui.</li><li>Cliente: obrigado, servidor. (opcional, apenas browsers educados)</li></ol><p>Além dessa sequência <em>altamente técnica</em> de troca de mensagens, repare que até agora, sempre falamos na troca ou requisição de <strong>páginas e documentos</strong>. Isso foi intencional porque nessa época, o conceito de troca de informação ainda era à base de troca de documentos inteiros e isso não é a toa — todo o início da internet foi fundamentado nessa troca de documentos.</p><p>Mas é importante destacar que esse modelo de documentos inteiros fazia muito sentido quando a internet era uma ferramenta de pouca criação e muita leitura. Como falamos na aula passada, a partir do momento que “evoluímos” para a Web 2.0 e toda a dinâmica e velocidade que ela trouxe e precisava, esse modelo começou a apresentar alguns problemas.</p><p>Veja bem — agora <em>não somos mais meros leitores e espectadores</em> dos documentos alheios, agora somos criadores e geramos posts envolventes e tweets sobre quantas fatias de presunto colocamos no sanduíche que acabamos de comer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*worr81Up-50ksYh-" /><figcaption>Como montar um sanduíche foda desses e NÃO compartilhar com meus 73 seguidores?</figcaption></figure><p>Nessa era de geração de conteúdo, uma interação entre cliente e servidor para criar um conta de usuário numa plataforma poderia ser assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ereEBb4k_g-ERUEXKx8Arw.png" /></figure><p>Num modelo predominantemente baseado na troca de documentos, qualquer interação entre um cliente e um servidor precisa receber e enviar documentos inteiros para que essa troca possa ocorrer. Apesar de funcionar, isso torna a experiência de usuário (famosa ú·xis) precária, uma vez que seu usuário pode ficar segundos esperando com uma tela vazia enquanto o servidor carrega ou processa alguma informação.</p><p>…e por muitos anos, fazer o quê, era o jeito de se <em>fazer a internet </em>🤷‍♀️</p><p>Mas no começo dos anos 2000, com o crescimento i̶n̶c̶e̶s̶s̶a̶n̶t̶e̶ contínuo de plataformas sociais, outros meios de criação de conteúdo e a necessidade de nos aproximarmos mais de experiências rápidas e em tempo real, desenvolvedores se viram com a necessidade de sanar esse problema de troca de documentos inteiros… e eis que uma <em>tecnologia</em> nasceu.</p><p>Apelidado de <strong>AJAX </strong>(<strong>Asynchronous JavaScript and XML), </strong>essa tecnologia permitia que clientes e servidores pudessem conversar de forma <em>assíncrona</em> (i.e. sem precisar sincronamente trocar um documento/carregar uma página inteira) usando <strong>JavaScript</strong> para fazer essas chamadas e o servidor respondendo com <strong>dados</strong> <strong>invés de documentos</strong>, tipicamente usando o formato <strong>XML.</strong></p><blockquote>Vou fazer uma pausa aqui para explicar uma coisa — se você não estava trabalhando ou envolvido na área web nessa época, você provavelmente nunca ouviu esse termo e talvez nem sabia que um dia a web não trabalhava com chamadas assíncronas — mas deixa eu te explicar uma coisa: para qualquer um envolvido na comunidade na época, <strong><em>AJAX foi revolucionário</em>.</strong></blockquote><p>AJAX talvez seja uma das siglas mais fadadas a parecer velha logo de cara porque XML era uma linguagem de markup bastante utilizadas na época mas que perdeu espaço rapidamente para JSON como um formato de troca de dados.</p><blockquote>Pausa #2: Você já se perguntou alguma vez porque que no DevTools do browser existe o filtro “XHR” na aba de Network? Ou por que que o JavaScript tem um método chamado de XML Http Request (eis o XHR)? A resposta é porque tudo isso começou com o singelo uso do XML e o nome acabou ficando.</blockquote><p>Com essa tecnologia <em>revolucionária</em>, agora era possível um cliente e servidor se comunicarem sem ter que trocar um documento completou ou carregar uma página nova. No exemplo da criação de conta, basta agora o cliente mandar as informações do formulário e o servidor pode responder com os dados, se deu certo ou não, etc., e o browser pode agir de acordo — inclusive, isso abriu a porta para páginas “em tempo real”, como cotações de valores, resultados e números que mudam constantemente (inclusive servindo como base para anos depois o aparecimento dos <em>websockets </em>e seu modelo <em>push</em>).</p><p>Como agora o cliente poderia executar mais coisas do lado dele (e as máquinas dos clientes estavam ficando mais poderosas), as responsabilidades e funcionalidades <strong>client-side</strong> começaram a aumentar. Foi nessa época que o conceito de “Servidores APIs” começou a se fortalecer, com servidores que já não devolviam mais páginas ou documentos mas apenas informação, com um esquema de URLs estruturada seguindo alguma lógica (eis nosso amigo REST ganhando força), devolvendo essa informação tipicamente usando XML ou JSON.</p><p>Devido ao fato do cliente agora ter tantas possibilidades, cada vez mais criamos aplicações complexas do lado dele, indo ao ponto de criarmos aplicações inteiras que vivem <strong>apenas</strong> <strong>do lado do cliente</strong>, com o servidor servindo <strong>apenas para devolver o documento original e responder com dados,</strong> quando o cliente pedir esses dados dele.</p><p>Nesse esforço de termos clientes robustos, nasce o que hoje chamamos de <strong>Single Page Application</strong> <strong>(SPA)</strong>. Mais uma vez, o nome é bastante pertinente. SPAs são documentos mínimos (i.e. tem a menor quantidade de informação possível de início) e que podem então ser puxados rapidamente do servidor. Uma vez no cliente, é papel do JavaScript montar toda a estrutura e conectar dados com interface, criando efetivamente o que você vê e com o que você interage.</p><p>Quando criamos um app usando o <a href="https://create-react-app.dev/">Create React App</a><em>, </em>o que é criado é um SPA, e o único documento que existe é o index.html e sua “aplicação inteira” se resume a:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/73c136b33e2e9fc47d418cca3dfec66c/href">https://medium.com/media/73c136b33e2e9fc47d418cca3dfec66c/href</a></iframe><p>O segredo em SPAs é que vai existir uma forma do JavaScript interagir com o documento e, a partir dele, criar toda a estrutura do app (no caso do React, normalmente é o &lt;div id=&quot;root&quot;&gt; )</p><p>SPAs são leves, rápidos de baixar e tipicamente fornecem uma boa experiência de usuário se programados corretamente. Mas como toda coisa boa, tem coisa <em>não tão boa</em> <em>assim</em> também.</p><p>Se sua aplicação se importa com SEO (lembrando que nem todo app vai se importar com isso, como painéis admin ou qualquer parte da sua aplicação atrás de um login), SPAs podem ser detrimentais, uma vez que os <em>crawlers</em> de SEO vão enxergar uma página praticamente vazia e sem conteúdo (vide nosso código acima ali). Outro potencial problema é que se criado de forma ingênua, um SPA pode forçar o cliente a baixar a aplicação inteira, mesmo partes dela que ele nunca vai usar ou acessar, visto que não existem URLs ou documentos explícitos. Ambos esses problemas podem ser resolvidos mas nem sempre é trivial trazer essas otimizações dependendo como sua aplicação foi programada. Então antes de sair fazendo um SPA em React ou Angular (ou JS puro se você for insano), dê uma pensada nessas consequências.</p><p>E eis que na nossa caminha pela história da web, temos ferramentas agora para gerar aplicações mais dinâmicas, com o uso ainda de documentos inteiros ou apenas partes deles, usando AJAX e, caso queiramos fazer uma aplicação inteira client-side, SPA.</p><p>Mas nessa busca constante de melhorarmos a experiência dos usuários e dos desenvolvedores, começou-se a sentir falta de uma forma de gerar páginas e documentos completos e prontos. E começou-se a hipotetizar: “Imagina que legal se tivéssemos uma forma de ter os documentos já prontos no lado do servidor e que, bastasse o cliente pedir por eles, eles receberiam esse documento pronto imediatamente, sem quer o servidor precisasse gerar eles? Imagina se pudéssemos trabalhar com documentos… estáticos”</p><p>E como a moda se repete, também se repete a tecnologia — falaremos sobre documentos e geração estática na aula que vem ~ aquele abraço e até lá! ✌️</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube! </a>✌</p><h3>TLDR;</h3><ul><li>O funcionamento original do modelo cliente-servidor era à base de troca de documentos e páginas completas;</li><li>Esse funcionamento trazia uma experiência mediocre, uma vez que qualquer interação, por menor que fosse, requeria que o servidor enviasse um documento completo novo;</li><li><strong>AJAX </strong>apareceu como uma solução para pedidos assíncrono de informação;</li><li>Baseado nesses pedidos assíncronos, aplicações inteiras foram criadas do lado do cliente (client-side), chamadas de <strong>Single Page Applications (SPA)</strong>, devido ao fato de tipicamente serem uma única página/documento;</li><li>SPA são tipicamente leves e rápidos mas podem ser uma solução medíocre se sua aplicação necessita de alguns fatores, como SEO.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=615e697d9b31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…]]></title>
            <link>https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-f183fda64101?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/f183fda64101</guid>
            <category><![CDATA[isr]]></category>
            <category><![CDATA[ssg]]></category>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[sap]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Mon, 05 Apr 2021 12:13:43 GMT</pubDate>
            <atom:updated>2021-04-05T12:13:43.369Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 1)</h3><p>Em cada canto do ringue, uma técnica de renderização de peso (e algumas menos pesadas).</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://www.youtube.com/watch?v=DiC2puit44Q">Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">muitas outras no nosso Canal do YouTube!</a></p><p>Nos primórdios da internet, quando os homens da caverna usavam pedras e palha para começar fogos, páginas com apenas HTML e CSS eram comuns e PHP era considerado uma tecnologia válida de ser usada por pessoas sãs, a rede era composta basicamente pelo modelo <em>cliente-servidor.</em></p><p>Nessa época, um site era constituído basicamente de informações estáticas e designs nada-estáticos (Deus abençoe a alma de quem deixou o <a href="https://www.spacejam.com/1996/">site original do Space Jam vivo até hoje</a>), onde uma página era basicamente um arquivo HTML com uma pitada (pesada) de CSS cabuloso para decorar os botões que giram e os fundos que piscam. Mesmo com todo esse movimento e a possibilidade de iniciar uma crise de convulsão, o importante é que essas páginas <strong>não precisavam puxar informações de fontes externas</strong> e <strong>atualizar seus dados frequentemente.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CN2Us9WdYl395r5F" /><figcaption>“Sim, Rodrigo, é fundamental que o fundo pisque e TOQUE MÚSICA QUANDO O USUÁRIO ENTRAR E QUE ELE NÃO TENHA OPÇÃO DE DESLIGAR ELA PÔRRA”</figcaption></figure><p>Dessa maneira, uma vez que você escrevesse o HTML do seu site, bem.. ele estava pronto. Para toda a eternidade (vide o site do Space Jam — Deus realmente abençoe essa pessoa que deixou esse site no ar).</p><p>Então era natural que o modelo predominante de serviço web na época fosse o tradicional <em>cliente-servidor</em>, onde um cliente (e.g. um browser) pede um recurso (e.g. uma página localizada num endereço específico) e o servidor, aprovando esse pedido, devolve esse recurso. E quando esse recurso é algo completamente estático como eram os sites na época, o que o servidor devolvia era <strong>exatamente </strong>o recurso pedido — i.e. a página do site em questão (inclusive, veja no site do Space Jam que a maioria das páginas termina com .html, significando que o que você recebeu é realmente o próprio arquivo HTML).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O0G4Ao22Ud8IoHjgeJ_j-g.png" /><figcaption>Usando a linguagem de conversa altamente técnica e formal entre cliente e servidor.</figcaption></figure><p>Um arquivo estático pode ser visto abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dabf4c515dd2efb8324af689c463a3d8/href">https://medium.com/media/dabf4c515dd2efb8324af689c463a3d8/href</a></iframe><p>Repare que num arquivo estático, <strong>todas as informações necessárias</strong> já estão presentes no próprio documento, significando que o mesmo está pronto para ser enviado a qualquer cliente que pedir.</p><p>E por muitos anos, tudo estava bem no mundo da internet, onde os documentos e a troca de informação reinavam…</p><h3>Web 2.0 (ou “Como a humanidade se perdeu”)</h3><p>O modelo de entregar um documento “pronto” para os clientes fez sentido por muito tempo mas com o passar dos anos, a internet começou a virar algo muito mais dinâmico, responsivo e voltado aos usuários e às pessoas (e os gatos) invés de documentos e mera troca de informação.</p><p>Com sites como Tumblr, Blogger, Twitter e qualquer startup cujo nome foi gerado colocando um “r” e comendo umas vogais pode te dizer, o foco dessa nova web é personalização e criação, onde cada usuário de um site ou uma “rede” gera conteúdo e as <strong>informações mudam rapidamente</strong>.</p><p>Um leitor mais sagaz pode ter reparado que, por mais que documentos estáticos fornecem repostas rápidas (“tá tudo pronto de antemão”), um arquivo estático carece de <strong>personalização. </strong>Enquanto teoricamente possível, se minha rede social tem 100 mil usuários, não é muito eficiente gerar uma página de perfil estática para cada um deles, além do que que geralmente numa rede dessas, as informações estão mudando o tempo todo (pense na página principal do Facebook e como ela era dinâmica quando você acessou ela pela última vez 4 anos atrás).</p><p>Com essa nova web, não era mais possível ter todas as informações prontas de antemão. Por mais que ainda era responsabilidade dos servidores devolverem os documentos aos clientes, invés de devolver um arquivo pronto estático, os documentos começaram a ser <strong>renderizados do lado do servidor</strong>. Na prática, isso significa apenas que o documento devolvido em partes era estático mas continha alguma informação que o servidor colocou ali, justamente na hora que foi feito o pedido por aquele documento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KX00xoa304ryT-ZvTnBpSw.png" /><figcaption>Em apenas 7 dias?!</figcaption></figure><p>Um exemplo de um documento que pode ser gerado pelo servidor tá aí:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bc01845b553e2c85b9796d317016cf1/href">https://medium.com/media/5bc01845b553e2c85b9796d317016cf1/href</a></iframe><p>Nessa época, apareceram ou subiram em popularidade as linguagens de script, como PHP e Ruby (e alguns anos depois, o Node), que serviam como <em>linguagens de backend</em>, capazes de rodarem em servidores, podendo conectar com banco de dados, fazer chamadas à API externas e renderizar páginas com essas informações, devolvendo ao cliente um documento que fosse personalizado para ele.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5453f1ab62018939039a8df9511a9298/href">https://medium.com/media/5453f1ab62018939039a8df9511a9298/href</a></iframe><p>Repare que o que o cliente recebe é um documento “pronto”, igual ao estático, mas dessa vez com informações customizadas a ele. Essa mágica toda acontece porque o servidor recebe o pedido do cliente, analisa o que ele precisa/quem ele é, e devolve o documento com informações que o próprio servidor puxou de algum lugar (e.g. um banco de dados). A técnica onde o documento é renderizado do “lado do servidor” se chama <strong>Server Side Rendering (SSR).</strong></p><p>Essa mágica toda, porém, vem com um custo — o servidor demora mais tempo agora para devolver a página, já que precisa buscar as informações para ser montada (e caso o servidor não for configurado de forma muito eficiente, o servidor vai pegar essas informações <strong>em todas as chamadas</strong>, mesmo se essa informação adicional não mudar).</p><p>Um detalhe interessante sobre como o SSR e como era implementado antigamente é que é muito utilizado para gerar documentos completos, como uma página HTML inteira, que é devolvida completa ao cliente. Isso pode ser útil mas significa que qualquer interação entre o cliente e o servidor requer <strong>o pedido de uma página completa</strong>, mesmo que boa parte da página atual não mudou.</p><p>SSR foi e continua sendo uma técnica de renderização muito utilizada, especialmente para páginas que precisam de customização e que tenham informações constantemente mudando. No entanto, a internet e a forma que a usamos continuou a evoluir, e renderizar e interagir com o servidor dessa forma, fazendo pedidos de páginas inteiras, também se mostrou limitada em alguns casos. Se apenas houvesse uma forma mais dinâmica, modular e <em>assíncrona</em> de interagir com servidores…</p><p>Mas falaremos sobre isso na Parte 2 🔥 Aquele abraço e até lá!</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube</a>! ✌</p><h3>TLDR;</h3><ul><li>A internet começou com o model tradicional de cliente-servidor, onde um servidor devolvia um recurso (e.g. página) estático ao cliente;</li><li>Com o avanço da internet, as páginas deixaram de ser estáticas, sendo geradas à base que fossem requisitadas, renderizadas pelo servidor, entregues prontas ao cliente, técnica conhecida como <strong>Server Side Rendering (SSR)</strong>;</li><li>A possibilidade de customizar a resposta e renderizar do lado do servidor vem com o custo da resposta demorar um pouco mais, já que é necessário realizar “ações” adicionais (e.g. ler um banco de dados) para preencher a página;</li><li>SSR antigamente envolvia fazer um pedido toda vez que o cliente fosse interagir com o servidor, requerendo <strong>carregar uma página completa</strong> <strong>toda vez</strong>. Talvez exista uma forma melhor de fazer isso…</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f183fda64101" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rpedroni/server-side-rendering-single-page-application-static-site-generation-incremental-static-f183fda64101">Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static…</a> was originally published in <a href="https://medium.com/rpedroni">RPEDRONI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Server Side Rendering vs Static Site Generation vs  Single Page Application vs Incremental Static…]]></title>
            <link>https://medium.com/reactbrasil/server-side-rendering-vs-static-site-generation-vs-single-page-application-vs-incremental-static-e91804ef9401?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/e91804ef9401</guid>
            <category><![CDATA[ssrs]]></category>
            <category><![CDATA[ssg]]></category>
            <category><![CDATA[isr]]></category>
            <category><![CDATA[ajax]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Wed, 31 Mar 2021 00:35:44 GMT</pubDate>
            <atom:updated>2021-04-05T12:07:27.492Z</atom:updated>
            <content:encoded><![CDATA[<h3>Server Side Rendering, Single Page Application, Static Site Generation, Incremental Static Regeneration e Next.js (pt. 1)</h3><p>Em cada canto do ringue, uma técnica de renderização de peso (e algumas menos pesadas).</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br>🎥 <a href="https://www.youtube.com/watch?v=DiC2puit44Q">Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">muitas outras no nosso Canal do YouTube!</a></p><p>Nos primórdios da internet, quando os homens da caverna usavam pedras e palha para começar fogos, páginas com apenas HTML e CSS eram comuns e PHP era considerado uma tecnologia válida de ser usada por pessoas sãs, a rede era composta basicamente pelo modelo <em>cliente-servidor.</em></p><p>Nessa época, um site era constituído basicamente de informações estáticas e designs nada-estáticos (Deus abençoe a alma de quem deixou o <a href="https://www.spacejam.com/1996/">site original do Space Jam vivo até hoje</a>), onde uma página era basicamente um arquivo HTML com uma pitada (pesada) de CSS cabuloso para decorar os botões que giram e os fundos que piscam. Mesmo com todo esse movimento e a possibilidade de iniciar uma crise de convulsão, o importante é que essas páginas <strong>não precisavam puxar informações de fontes externas</strong> e <strong>atualizar seus dados frequentemente.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*CN2Us9WdYl395r5F" /><figcaption>“Sim, Rodrigo, é fundamental que o fundo pisque e TOQUE MÚSICA QUANDO O USUÁRIO ENTRAR E QUE ELE NÃO TENHA OPÇÃO DE DESLIGAR ELA PÔRRA”</figcaption></figure><p>Dessa maneira, uma vez que você escrevesse o HTML do seu site, bem.. ele estava pronto. Para toda a eternidade (vide o site do Space Jam — Deus realmente abençoe essa pessoa que deixou esse site no ar).</p><p>Então era natural que o modelo predominante de serviço web na época fosse o tradicional <em>cliente-servidor</em>, onde um cliente (e.g. um browser) pede um recurso (e.g. uma página localizada num endereço específico) e o servidor, aprovando esse pedido, devolve esse recurso. E quando esse recurso é algo completamente estático como eram os sites na época, o que o servidor devolvia era <strong>exatamente </strong>o recurso pedido — i.e. a página do site em questão (inclusive, veja no site do Space Jam que a maioria das páginas termina com .html, significando que o que você recebeu é realmente o próprio arquivo HTML).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O0G4Ao22Ud8IoHjgeJ_j-g.png" /><figcaption>Usando a linguagem de conversa altamente técnica e formal entre cliente e servidor.</figcaption></figure><p>Um arquivo estático pode ser visto abaixo</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dabf4c515dd2efb8324af689c463a3d8/href">https://medium.com/media/dabf4c515dd2efb8324af689c463a3d8/href</a></iframe><p>Repare que num arquivo estático, <strong>todas as informações necessárias</strong> já estão presentes no próprio documento, significando que o mesmo está pronto para ser enviado a qualquer cliente que pedir.</p><p>E por muitos anos, tudo estava bem no mundo da internet, onde os documentos e a troca de informação reinavam…</p><h3>Web 2.0 (ou “Como a humanidade se perdeu”)</h3><p>O modelo de entregar um documento “pronto” para os clientes fez sentido por muito tempo mas com o passar dos anos, a internet começou a virar algo muito mais dinâmico, responsivo e voltado aos usuários e às pessoas (e os gatos) invés de documentos e mera troca de informação.</p><p>Com sites como Tumblr, Blogger, Twitter e qualquer startup cujo nome foi gerado colocando um “r” e comendo umas vogais pode te dizer, o foco dessa nova web é personalização e criação, onde cada usuário de um site ou uma “rede” gera conteúdo e as <strong>informações mudam rapidamente</strong>.</p><p>Um leitor mais sagaz pode ter reparado que, por mais que documentos estáticos fornecem repostas rápidas (“tá tudo pronto de antemão”), um arquivo estático carece de <strong>personalização. </strong>Enquanto teoricamente possível, se minha rede social tem 100 mil usuários, não é muito eficiente gerar uma página de perfil estática para cada um deles, além do que que geralmente numa rede dessas, as informações estão mudando o tempo todo (pense na página principal do Facebook e como ela era dinâmica quando você acessou ela pela última vez 4 anos atrás).</p><p>Com essa nova web, não era mais possível ter todas as informações prontas de antemão. Por mais que ainda era responsabilidade dos servidores devolverem os documentos aos clientes, invés de devolver um arquivo pronto estático, os documentos começaram a ser <strong>renderizados do lado do servidor</strong>. Na prática, isso significa apenas que o documento devolvido em partes era estático mas continha alguma informação que o servidor colocou ali, justamente na hora que foi feito o pedido por aquele documento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KX00xoa304ryT-ZvTnBpSw.png" /><figcaption>Em apenas 7 dias?!</figcaption></figure><p>Um exemplo de um documento que pode ser gerado pelo servidor tá aí:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bc01845b553e2c85b9796d317016cf1/href">https://medium.com/media/5bc01845b553e2c85b9796d317016cf1/href</a></iframe><p>Nessa época, apareceram ou subiram em popularidade as linguagens de script, como PHP e Ruby (e alguns anos depois, o Node), que serviam como <em>linguagens de backend</em>, capazes de rodarem em servidores, podendo conectar com banco de dados, fazer chamadas à API externas e renderizar páginas com essas informações, devolvendo ao cliente um documento que fosse personalizado para ele.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5453f1ab62018939039a8df9511a9298/href">https://medium.com/media/5453f1ab62018939039a8df9511a9298/href</a></iframe><p>Repare que o que o cliente recebe é um documento “pronto”, igual ao estático, mas dessa vez com informações customizadas a ele. Essa mágica toda acontece porque o servidor recebe o pedido do cliente, analisa o que ele precisa/quem ele é, e devolve o documento com informações que o próprio servidor puxou de algum lugar (e.g. um banco de dados). A técnica onde o documento é renderizado do “lado do servidor” se chama <strong>Server Side Rendering (SSR).</strong></p><p>Essa mágica toda, porém, vem com um custo — o servidor demora mais tempo agora para devolver a página, já que precisa buscar as informações para ser montada (e caso o servidor não for configurado de forma muito eficiente, o servidor vai pegar essas informações <strong>em todas as chamadas</strong>, mesmo se essa informação adicional não mudar).</p><p>Um detalhe interessante sobre como o SSR e como era implementado antigamente é que é muito utilizado para gerar documentos completos, como uma página HTML inteira, que é devolvida completa ao cliente. Isso pode ser útil mas significa que qualquer interação entre o cliente e o servidor requer <strong>o pedido de uma página completa</strong>, mesmo que boa parte da página atual não mudou.</p><p>SSR foi e continua sendo uma técnica de renderização muito utilizada, especialmente para páginas que precisam de customização e que tenham informações constantemente mudando. No entanto, a internet e a forma que a usamos continuou a evoluir, e renderizar e interagir com o servidor dessa forma, fazendo pedidos de páginas inteiras, também se mostrou limitada em alguns casos. Se apenas houvesse uma forma mais dinâmica, modular e <em>assíncrona</em> de interagir com servidores…</p><p>Mas falaremos sobre isso na Parte 2 🔥 Aquele abraço e até lá!</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br><a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">Ah, e me acompanhe também no YouTube</a>! ✌</p><h3>TLDR;</h3><ul><li>A internet começou com o model tradicional de cliente-servidor, onde um servidor devolvia um recurso (e.g. página) estático ao cliente;</li><li>Com o avanço da internet, as páginas deixaram de ser estáticas, sendo geradas à base que fossem requisitadas, renderizadas pelo servidor, entregues prontas ao cliente, técnica conhecida como <strong>Server Side Rendering (SSR)</strong>;</li><li>A possibilidade de customizar a resposta e renderizar do lado do servidor vem com o custo da resposta demorar um pouco mais, já que é necessário realizar “ações” adicionais (e.g. ler um banco de dados) para preencher a página;</li><li>SSR antigamente envolvia fazer um pedido toda vez que o cliente fosse interagir com o servidor, requerendo <strong>carregar uma página completa</strong> <strong>toda vez</strong>. Talvez exista uma forma melhor de fazer isso…</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e91804ef9401" width="1" height="1" alt=""><hr><p><a href="https://medium.com/reactbrasil/server-side-rendering-vs-static-site-generation-vs-single-page-application-vs-incremental-static-e91804ef9401">Server Side Rendering vs Static Site Generation vs  Single Page Application vs Incremental Static…</a> was originally published in <a href="https://medium.com/reactbrasil">React Brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Seu Primeiro Componente usando TypeScript]]></title>
            <link>https://medium.com/rpedroni/seu-primeiro-componente-usando-typescript-82345cec3da0?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/82345cec3da0</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Mon, 01 Mar 2021 22:01:05 GMT</pubDate>
            <atom:updated>2021-03-08T16:29:43.486Z</atom:updated>
            <content:encoded><![CDATA[<p>Ganhe confiança no seu código e integridade de tipos — enquanto aumenta sua empregabilidade.</p><blockquote>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br><a href="https://www.youtube.com/watch?v=WSw2V1H2Ir0">🎥 Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ">muitas outras no nosso Canal do YouTube!</a></blockquote><p>Se tem um aspecto que considero “o próximo passo” para um desenvolvedor React tornar-se mais competente na sua arte de criar e desenhar interfaces modernas e robustas é saber usar <a href="https://www.typescriptlang.org/">TypeScript</a>.</p><p>“Mas professor, me falaram que preciso entender tudo sobre ordenação de árvores binárias, ponderadas usando listas quadruplamente encadeadas usando assembly rodando num PIC de 4bits para progredir minha carreira como desenvolvedor!”. E isso <em>é verdade</em>, num lindo mundo de entrevistas de quadro branco e nos sonhos dos puristas de ciências da computação 🦄</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*SlwehzE85PhSmEih" /><figcaption>Você tem 2 minutos para explicar o Jantar dos Filósofos. Se você passar no teste, segunda-feira começa a trabalhar, trocando cores de botões em CSS.</figcaption></figure><p>Se você tem contato com empresas que trabalham de verdade com React e fazem seus testes com problemas reais do mundo real, uma forma de mostrar sua competência e cuidado com sua arte é justamente você elevar a qualidade com qual você produz essa arte. E o <strong>TypeScript</strong> é uma excelente forma de fazer isso.</p><p>Nessa aula, não vou entrar em detalhes <em>muito</em> técnicos do que o TypeScript (<strong>TS</strong>) é capaz de fazer (e acreditem, é capaz de <a href="https://www.typescriptlang.org/docs/"><em>fazer muita coisa</em></a><em>) </em>mas vamos molhar nossos pés um pouco porque eu vejo que tem MUITO desenvolvedor com medo da ferramenta quando a verdade é que o TS só é tão intimidador quanto você quer que ele seja.</p><p>Parecido com outras bibliotecas de tipificação do JavaScript (como o <a href="https://flow.org/">flow</a>), a adaptação do TS pode ser gradual ou por inteiro — você decide. Então na aula de hoje vamos seguir por esse caminho gradual, onde vamos usar o TS para elevar a qualidade do nosso código, de uma forma simples, modular e por passos, justamente para entendermos algumas das capacidades maravilhosas que ele proporciona — e que você finalmente perca o medo dele, como você venceu o seu medo de palhaços aos 23 anos de idade.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-s2RfYWHAjViKbzA" /><figcaption>Oi, sou o Palhaço Bolhas! Sou seu amigo e vim comer sua alma.</figcaption></figure><h3>O que é TypeScript?</h3><p>Longe de termos uma aula sobre o que é em detalhes e quais são todos os poderes do TS, a resposta resumida é a seguinte: TypeScript é JavaScript tipificado. Isso é, TS é JS com a possibilidade de definir tipos, trazendo mais robustez e segurança ao seu código e, convenhamos, a coisa mais massa de TypeScript: auto-completar.</p><p>Como o o TS é um superconjunto do JS (i.e. todo e qualquer código JS é código TS válido), <strong>absolutamente tudo</strong> que você pode fazer em JS, pode fazer igual em TS. Por isso que usar TypeScript pode ser um <em>processo gradual, </em>indo componente por componente, arquivo por arquivo, sem a necessidade de transformar o projeto todo em uma só sentada.</p><h3>Criando seu Projeto TypeScript com o Create React App</h3><p>Nosso foco vai ser no uso do TS. Dito isso, não quero perder muito tempo com instalações complicadas e configurações avançadas (o TS suporta bastante configuração). Para termos um projeto React funcional com TS da maneira mais rápida, vamos alavancar nosso amigável <strong>Create React App (CRA), </strong>que já temo suporte (semi-)nativo ao TS. Para criar um novo projeto com TS, basta rodar:</p><pre>npx create-react-app my-ts-comp-project --template typescript<br># Ou com o yarn<br>yarn create react-app my-ts-comp-project --template typescript</pre><blockquote>O npx e o yarn create são ferramentas “one-off” de criação e configuração de projetos — i.e. é uma forma de usar um pacote npm sem ter que instalar ele localmente</blockquote><p>Uma vez rodado, teremos um projeto CRA normal mas com suporte a usar TS logo de cara. A primeira coisa que você vai reparar de diferente é que vão haver vários arquivos .ts e .tsx invés dos .js e .jsx que talvez esteja acostumado. Por mais que não seja obrigatório usar a extensão para denotar arquivos TS, é um costume para diferenciar de arquivos que sejam puramente escritos em JS.</p><p>Outra coisa que talvez note é um novo arquivo na raiz do projeto, o tal do .tsconfig. Basicamente esse arquivo define e configura como deseja que o TS funcione para esse projeto. Para projeto diferentes, é normal haver .tsconfigs diferentes, justamente denotando as diferenças e preferências do projeto e dos desenvolvedores nele trabalhando.</p><p>Para provar que o TypeScript interpreta JavaScript normalmente, troque a extensão do arquivo App.tsx para App.jsx (atualize também a inclusão desse arquivo no index.tsx para import App from &#39;./App.jsx para puxar o arquivo correto). Recarregue a página e ~boom~, nada mudou (não esqueça de mudar de .jsx de volta .tsx quando terminar).</p><p>Repare também por último que por mais que estamos num projeto TypeScript, os arquivos que o React gera são idênticos em conteúdo do que os de um projeto JS normal. O CRA não está usando TS para nada, e é nosso papel adicionar agora esses super poderes 🦸‍♀️</p><h3>React e o TypeScript</h3><p>TypeScript pode e é usado muito em qualquer ambiente JavaScript — React sendo um desses ambiente, é natural querer usar ele aqui também. Uma das principais maneiras de usar TS com o React é justamente na definição das APIs de componentes React — no caso de componentes, a “interface” que eles tem com o mundo é justamente o props , então nada melhor do que começar a adicionar TS aos nossos componentes do que aqui.</p><blockquote>▶️ Nosso objetivo nesse momento não é fazer o componente funcionar “de verdade” mas, sim, vermos como podemos usar o TS para elevar a qualidade dos nossos componentes.</blockquote><p>Vamos criar nosso componente, o NumberInput, para demonstrar o TS em ação. As funcionalidades que queremos do nosso componente de teste são:</p><ol><li>O componente é uma entrada (input) de números inteiros;</li><li>O componente tem dois parâmetros, min e max , que controlam os limites de valor de entrada. A entrada só pode estar na faixa [min , max];</li><li>O componente pode receber um valor inicial, e esse valor deve ser forçado a estar entre os valores de min e max;</li><li>O componente também aceita um placeholder, uma string opcional que serve de <em>placeholder </em>no input;</li><li>Ao ter um valor válido inserido, o componente deve sinalizar ao componente pai que o seu valor mudou, passando o valor atual válido ao mesmo.</li></ol><p>Nada muito complicado para começarmos. Então bora começar a ver nosso pequeno exemplo ganhando vida 🍀</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4f9e92e9886f596dfee5fafc96f85e06/href">https://medium.com/media/4f9e92e9886f596dfee5fafc96f85e06/href</a></iframe><p>Bem radical né? Pois bem, precisamos começar de algum lugar. Vamos então começar a preparar o componente justamente com os valores que ele pode receber do mundo externo, nosso amigo props .</p><h3>Props Tipados</h3><p>Para isso, vamos definir em TS quais são esses os nomes desses props, e os tipos a eles associados:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/20f82866a11501270717875baaa9a1f0/href">https://medium.com/media/20f82866a11501270717875baaa9a1f0/href</a></iframe><p>A palavra type significa “tipo” (pikachu_suprise_face.jpg), e está criando nesse exemplo um “tipo” para nós — o tipo NumberInputProps . O TS nos permite criar tipos indefinidamente complexos, com tipos extendendo e herdando de outros tipos, com a possibilidades de implementar interfaces e muitas outras coisas. Mas o curioso que no React, pelo menos quando o assunto é componentes, raramente precisamos de algo muito complexo, nos limitando a simplesmente definir os tipos dos parâmetros que esperamos do mundo externo. Só com isso, já vamos ver bastante mágica acontecer ✨</p><p>Adicione esse tipo para os props do seu componente:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/32bb893267df126a7564e67b1d44f685/href">https://medium.com/media/32bb893267df126a7564e67b1d44f685/href</a></iframe><p>E falando em mágica… sua aplicação talvez <em>magicamente</em> “crasheou”. Na verdade, o TS gerou um erro de compilação (<em>transpilação</em> na verdade, mas vamos ignorar isso por enquanto) e seu app deu erro. Mas antes que você fique puto que o TS está gerando um erro, saiba: ISSO É BOM!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*DEZyYD-NHfhJxvripJpYwQ.png" /><figcaption>Óia lá, tá faltando coisa.</figcaption></figure><p>Erro bom? Erro bom! O erro está acontecendo justamente porque você está usando o componente de forma errada. Afinal, você falou que os props do componente são min, max, initialValue e placeholder mas você não está fornecendo nenhum deles no momento. Então que ótimo que o TS está sendo seu amigo e te avisando isso logo de cara — o JS não teria essa capacidade. Para resolvermos isso, vamos adicionar valores de props no uso do nosso componente</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0290da5c693505db7318c6c3719bf077/href">https://medium.com/media/0290da5c693505db7318c6c3719bf077/href</a></iframe><p>Resolvido, né? Não, continuamos a fazer cagada um erro de programação. Lembra que quando definimos nossos props no componente, falamos que todos os valores eram do tipo number, significando que esperamos os três valores como número mas estamos invés passando strings. Ou seja, mais uma vez o TS nos salvando de erros simples mas que podem demorar muito para debugar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/665/1*jhT9mk5dKZgfOMXVvQEuDA.png" /></figure><p>Corrigindo, temos agora:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2bcc49e3e8e69f7e3e615142abc98d3d/href">https://medium.com/media/2bcc49e3e8e69f7e3e615142abc98d3d/href</a></iframe><p>E nosso app volta a funcionar 🎉</p><p>Uma coisa que você pode ter reparado é que na nossa especificação, nós falamos que o componente <em>pode</em> receber um valor inicial mas não que <em>necessariamente</em> vai receber um valor. No TS, podemos traduzir isso para um <strong>valor opcional</strong>, anotando o tipo desse campo como opcional, usando ? depois do nome da variável, tendo assim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/277/1*N878v2ShD9Nm15WMElEjCg.png" /></figure><p>Sendo assim, experimenta tirar o initialValue do &lt;NumberInput /&gt; e verá que o TS não vai reclamar mais. <em>Espertinho</em>. Inclusive, se agora dentro do nosso componente fizermos a soma de todos os props numéricos, teremos um problema:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/715/1*qY9_GUJuZMlAORTPQN3LMg.png" /></figure><p>Note que por mais que os três valores são números, o TS vai reclamar que somar o valor de initialValue ao min e max pode dar ruim, visto que agora o initialValue <em>pode</em> ser indefinido. Mesmo que você forneça um valor aos a todos os props, o erro do TS não vai sumir porque ele previne os erros em tempo de compilação e não depuração — a ideia é previnir erros e não descobrir eles apenas quando acontecerem. Caso quiser resolver isso, basta dar um valor default ao initialValue e o TS também será inteligente de saber que agora sempre haverá um valor válido:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/70f33dbd0b5e937c102a3ff95ee756ce/href">https://medium.com/media/70f33dbd0b5e937c102a3ff95ee756ce/href</a></iframe><p>Quanto à lista de props, está faltando um último prop, justamente para sinalizarmos ao componente pai que um valor válido foi inserido no input. De forma clássica, usaremos um <em>callback </em>para fazer essa sinalização:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e5029ed54531dec41f4098cba78662ee/href">https://medium.com/media/e5029ed54531dec41f4098cba78662ee/href</a></iframe><p>TS também é capaz de anotar os tipos em uma função, indicando quais são os parâmetros e qual o valor de retorno. Nesse caso, nossa callback passa um único número e retorna nada (eis o void ali). Vale comentar que os tipos que o TypeScript pode representar são muitos e suas complexidades variam desde valores primitivos (string, number, boolean, etc.) até objetos complexos, <em>unions</em>, <em>range </em>de valores e <a href="https://www.typescriptlang.org/docs/handbook/2/template-literal-types.html"><em>template literal types</em></a> . Como nosso objetivo hoje é fazer apenas uma introdução, vamos ao segundo local clássico onde TS pode nos ajudar e muito em React: estado.</p><h3>Estado Tipado</h3><p>props são apenas uma parte de um componente — muito componentes dependem de manter estado para poderem funcionar, e isso se aplica no nosso caso. A forma de adicionar TS para nos ajudar com <em>state</em> no React é usando-o nas chamadas ao useState</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/abcc01c054da93c550d5e5f67c892e3d/href">https://medium.com/media/abcc01c054da93c550d5e5f67c892e3d/href</a></iframe><p>Parte da mágica do TS é que ele consegue muitas vezes inferir tipos baseado apenas que usamos, como é o caso aqui. Deixa seu mouse em cima do value e veja o que o TS conseguiu descobrir sobre ele:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/383/1*wOHiE27EWGhA04tOqPkPvg.png" /></figure><p>No caso de useState o TS atribui o tipo da variável baseado no valor que é passado como valor inicial do estado, nesse caso puxando o tipo do initialValue, ou seja, number. Mas o que aconteceria se não houvesse um valor inicial ou esse valor inicial fosse indefinido? Bora lá ver:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/284/1*oiwRzJCEaH0Bn-5GRiFPVw.png" /></figure><p>Como você poderia imaginar, ele definiu o tipo de value como undefined, justamente porque o valor realmente é indefinido. Inclusive, se tentarmos usar o setValue em seguida no código, o TS reclamaria caso a função recebesse qualquer valor que não fosse undefined</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*BBFTd65y4u1xQcWuYQBgEA.png" /></figure><p>Se encontrar um caso assim e quiser sinalizar ao TS o tipo que deseja à sua variável de estado, muitas funções aceitam um <em>tipo genérico </em>que pode ser usado internamente para definir o tipo de outros valores, nesse caso no a variável de retorno da função. Veja só:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/353/1*GhHSTl2Qw1VdGoECn3VoKA.png" /></figure><p>Basicamente estamos falando ao TS o seguinte:</p><blockquote>“Saca só typescript, confia em mim , o tipo dessa variável É number e essa tal de função setValue vai receber um number como entrada quando eu usar ela, firmeza? abs irmão vlw falow me liga no zap.” <strong>Desenvolvedor, 2021</strong></blockquote><p>Inclusive, ao tentar usar o setValue com outro valor que não seja um número, ele vai te proteger mais uma vez:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*C1LZVHr_kMf_3gacZYrEPg.png" /></figure><p>Se você for atento, na verdade vai ver que o TS é <em>mais inteligente ainda</em> — por mais que falamos que o value e o setValue é e recebe um number, repare que o TS está falando que esse valor na verdade é number | undefined, significando que pode ser número mas também pode ser indefinido e ele está correto — quando inicializamos nossa variável, ela realmente é indefinida e nem prestamos muita atenção a isso — então alavanque esse poder todo a seu favor.</p><h3>Tipo Assim</h3><p>Por mais que isso foi uma introdução <em>ligeiraça</em> de TypeScript, espero que tenha te motivado a incluí-lo na sua próxima aventura programática ou o seu projeto JavaScript puro. Dá para começar a ver que as vantagens em termos de robustez, leitura de código, manutenibilidade e debug dos componentes e que sua adoção pode ser gradual e por partes. Então está esperando o que? Vá lá tipificar tudo isso aí 💪</p><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br>Ah, e me acompanhe também no YouTube: <a href="https://bit.ly/3q0TIAU">https://bit.ly/3q0TIAU</a> ✌!</p><h3>TLDR;</h3><ul><li>Empresas <em>sérias </em>estão cada vez buscando mais devs que entendam e usam TypeScript (TS) para trazer robustez e segurança aos seus apps;</li><li>TS é um superconjunto do JavaScript — tudo que vale em JS vai valer em TS;</li><li>O Create React App pode ser criado para ter um suporte nativo ao TS;</li><li>Uma das principais formas de usar TS com React é a definição dos props de um componente e a tipificação do estado desse componente;</li><li>TS te dá suporte a auto-complete, segurança de tipos e robustez de código;</li><li>Testes são mais fáceis de escrever por causa da garantia de tipos.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82345cec3da0" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rpedroni/seu-primeiro-componente-usando-typescript-82345cec3da0">Seu Primeiro Componente usando TypeScript</a> was originally published in <a href="https://medium.com/rpedroni">RPEDRONI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[useState — Diving Deep into React Hooks (2021)]]></title>
            <link>https://medium.com/rpedroni/usestate-diving-deep-into-react-hooks-2021-88ec31d69a5e?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/88ec31d69a5e</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[hooks]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[front-end-development]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Tue, 23 Feb 2021 12:27:07 GMT</pubDate>
            <atom:updated>2021-02-23T12:27:07.584Z</atom:updated>
            <content:encoded><![CDATA[<h3>useState — Diving Deep into React Hooks (2021)</h3><p>Welcome to our Deep Dive Series on React Hooks! In each lesson, we’ll look into each hook offered by React at the time of this writing (who knows what the future holds 🔮). We’ll go beyond their basic usage (but cover that too!) to understand why each one exists, what is the best scenario to use each and how we can squeeze every ounce of hook-goodness they can offer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*6ZA6BIDv0n0q5gYe" /><figcaption>Little known fact: Jack Sparrow is a proficient frontend developer, but still doesn’t use hooks.</figcaption></figure><p>In our first session, we’re going to take a look at the simplest but often most useful of all hooks, useState .</p><h3>The Way Things Were</h3><p>Before even talking about hooks, let’s take a look back at how React handled things before hooks existed. Formally speaking, let’s take a walk back to React pre version 16.8, where functional components were a bit rare and class components ruled the frontend jungle.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a931bf0c80323f5c25694248a5c0a65d/href">https://medium.com/media/a931bf0c80323f5c25694248a5c0a65d/href</a></iframe><p>This simple component illustrates how we worked with class components and, specifically, how we handled state back then. React components enforced state control using its infamous this.state and this.setState(), which, when used together, handled the reading and updating of state, respectively. Since components were classes and instances of classes, there wasn’t much debate as to how state was conserved — class instances inherently hold state in memory, that being one of the core principles of OOP and classes. As a developer, you could sleep assured that you understood how your component’s state was handled and where it was “saved”.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*m4aqF6wVjBEsXAHR" /><figcaption>Nothing like a good night of sleep knowing which RAM block my data lives in.</figcaption></figure><p>But once the React community started noticing some issues with class components (in special regards to reusability and maintenance), React decided to shift to and embrace functional components completely, meaning that components were not classes anymore, they were functions.</p><p>Let’s be very clear here: this was an excellent decision which I’ve never heard a single developer complain about (if you’re <em>that</em> developer, please comment). But with this change in scenery, what was once a trivial and intrinsic thing of saving and updating state in class instances, became a challenge. After all, how do you hold state in something inherently stateless like a function?</p><p>To that end, let’s exemplify a functional component holding (or attempting to hold) state, as before:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/550a968fe965c1bc79f79f8cb3478719/href">https://medium.com/media/550a968fe965c1bc79f79f8cb3478719/href</a></iframe><p>Functional components are much cleaner, showcase better what the components intend to do and render and are overall much easier to write and maintain — props to the development team for this shift in paradigm. All that being said, here we’re are trying to hold state by using a variable, declared in let count = 0; with an initial value. We also have an update function passed to onClick that increments count by 1 on every click. With all this done, let’s run this and see the magic happen!</p><p>…or not. If we run this, even if we click the button 50 times, nothing happens. No matter how many times clicked, the component still renders a flat 0 onscreen.</p><p>Wait, I know! The problem is obvious — since let count = 0; is inside the function component, so every time the component renders, since this is just a function, count will be set to 0 and that’s why we don’t see anything change. Let’s move our declaration outside of the component and that should fix things:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1e47d94b9608140db6c87e59e34bb3a2/href">https://medium.com/media/1e47d94b9608140db6c87e59e34bb3a2/href</a></iframe><p>And there you go! Just click that sweet button and see..</p><p>…nothing happen again. There something strange here, it’s not possible that count doesn’t update, is it? We put a console log in our updater to see at least what value count contains through the multiple clicks:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/126/1*FrOivom9NlXK_SQVBfqx7g.png" /></figure><p>So count‘s value is actually updating, but why isn’t React or our component picking this up?</p><p>One important thing we need to remember from “classic” React and class components is that state updates were never done directly to the values saved on state — that is, while we read state variables normally, using this.state.myValue, you should <strong>never</strong> update state by trying to change that variable directly (this.state.myValue = 10). If we wanted to update a state, we always used this.setState, passing whatever variables needed updating. And the reasoning for this is simple: though some value changed, React doesn’t “monitor” values directly, instead being <em>reactful </em>of changes it’s actually aware of.</p><p>React is great at controlling updates and render cycles but we need to signal React that we actually intend on updating something so it can pick up this “attempted” change (I put “attempted” in quotes since not every change necessarily implicates in a rerender — we’ll talk about this later on). That being said, when we talk about state management in React, we’re actually discussing two <strong>saving state AND signaling we want to do an update</strong>. Since React covers part of this, we need some tool that plugs in to React to do it all.</p><p>For functional components and the future of React, the way to do this using hooks — in our case, useState</p><p>Let’s see how this baby works:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bc6e27fb48ab9a52b07c675bc5cf145/href">https://medium.com/media/5bc6e27fb48ab9a52b07c675bc5cf145/href</a></iframe><p>useState returns an array, where position [0] is the actual value were maintaining in state and position [1] is the state update function, typically called setState (though it’s name is usually always the name of the variable preceded by set, such as setCount). Reinforcing, we should never update state by trying to alter the state value directly (i.e. count = 5) since we have an update function for this (and count is a const anyway).</p><p>Using the setXXX function returned (we’ll call this setState from now on, independent of what it’s actual name is) we’re able to update our state variable in a similar fashion we did with this.setState from class components. Let’s see useState in a (possibly) real component, demonstrating some of it’s abilities:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fe39a8b54f63ace2d4224f4da09f03a6/href">https://medium.com/media/fe39a8b54f63ace2d4224f4da09f03a6/href</a></iframe><p>First thing to notice is that useState accepts an argument. This argument, which can be an arbitrary value or a function (we’ll talk about this function in depth later on) is used to give the state variable its initial value. In our previous example, we’re actually using a value from a passed in prop. The same applies to setState function, which equally accepts an arbitrary value (string, objects, etc.) or a function. Passing it a function is useful when we want to update the state with a previous value of itself, such is the case with our prevCount =&gt; prevCount + 1 example. Here we don’t need to access the count value directly since this callback will receive the current (“previous value”) and it should return the intended new value.</p><p>If you came from good ol’<em> </em>React with class components, you’re probably used to updating state using this.setState and benefiting from React’s automatic state object merging. So in this example,</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/bd1163adb915f9c0046176fa569c052e/href">https://medium.com/media/bd1163adb915f9c0046176fa569c052e/href</a></iframe><p>even if I called this.setState only passing in a value for count, the component would what it currently has in memory with what was passed to the function, and would have count updated and x still with 10. This is not the case with useState, since any call to its returned setState will completely override whatever was saved there previously.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8692c6ea0255aced6b420c08c0c5b754/href">https://medium.com/media/8692c6ea0255aced6b420c08c0c5b754/href</a></iframe><p>Here, we’ll initially have an X: 10 displayed in our component but once the button is clicked, setState will overwrite the previous { count: 0, x: 10 } object with the new object passed to it, in this case simply { count: state.count + 1 } .</p><p>Due to this, useState is usually used for each data that needs to be in state, having multiple calls to it for each of these pieces.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e12e48ee9a68f69cb7057281c25ab61c/href">https://medium.com/media/e12e48ee9a68f69cb7057281c25ab61c/href</a></iframe><p>One logical conclusion you may have come to is that useState isn’t a very adequate solution for keeping complex and/or big data structures, like large objects or deeply nested structures (here’s a gold sticker for your observation ⭐️). That being said, React and its community have multiple options for doing specifically this, through other hooks (e.g. useReducer ) and libraries (you name it — redux, recoil, mobx, etc. etc. etc.). These solutions come with the benefit of better separation between UI and state management, but with the downside of making your code a bit harder to read and some necessary boilerplate to set it all up — but we’ll talk about this when the time comes ✨</p><h3>Render For Me…</h3><p>We’re mainly talking about state here but don’t be fooled — part of React’s large appeal to its users is its rendering capabilities, or better yet, its ability to <em>not render that much</em>. Remember that a big part of a FE developers responsibility is that whatever interface we’re building, it should be snappy, load fast and respond quickly to user interactions (the rule of thumb here is to maintain 60 frames per second). That being so, we should strive to keep this performance and React helps us quite a bit in this department.</p><blockquote>⚠️ Fair warning: We’re discussing optimization and performance and while having this in mind is always healthy, deeper and more time consuming optimization should never be your first task when developing an application.</blockquote><p>One thing to note is that React is pretty clever when it comes to <em>rerendering</em> components, since it knows to avoid rerenders when the updated state value is the same as its previous value. Contrary to what many believe, simply calling setState does not force a render if React notices a render isn’t needed.</p><p>For instance, if we look at our previous examples of using a count state variable and we make an update from value0 to 1, React will be aware of this change and rerender the component accordingly. Suppose now that we create a reset button, which sets the count value to 0 . If we press this button multiple times, will React rerender our component on every click? No, React knows that a render isn’t necessary since no value changed and updating the screen isn’t necessary. Pretty smart, right?</p><h3>…But Don’t Render That Much</h3><p>It really is pretty smart. But, well, it’s not thaaaaat smart. What React does, in a simplified manner, is to check if the new state value is equal to the current state value. The equality check React does is using the triple equal === (i.e. strict equality), checking if there is a change newValue === currentValue . If not, no rerender is needed, and that’s good 👍</p><p>But coming back to using useState to hold objects, we can encounter a nice ol’ source of problems when using it haphazardly.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/efaad6823ebacb0f4af4fc12709739cf/href">https://medium.com/media/efaad6823ebacb0f4af4fc12709739cf/href</a></iframe><p>In this case, we have a very simple component that hold a user instance and updates it when the Reset User button is clicked — while actually updating it to the same exact value every time. We put a console.log to help us see this during its life time. Let’s try this out by clicking the button a few times.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/1*WbiMjcHVmw7-U3Kx3wzlUw.png" /><figcaption>A few 35 times, just to make our point.</figcaption></figure><p>Heck, there goes our “React is smart” statement. So why the hell does our component rerender if it never changes in terms of value or visually? The answer is that React is <em>pretty</em> smart, but it requires your help too.</p><p>We previously mentioned that React triple equals === values to detect if a value is new or not, rerendering when it detects a change in this comparison. Well, that continues to be true, even if what we’re comparing is a string, a number or an object. In this case, it’s an object (remember that in JS land, anything that isn’t a primitive is an object) and object strict comparisons are shallow, in the sense that they don’t compare an object’s values but instead the reference to that object. So while we can have const a = {}; const b = {}; , the comparison a === b is false since these are variables referencing different objects.</p><p>In our example, while the values of the passed object were the same, on every update it is referencing a new, different object, so React just goes and rerenders the component anyway, oblivious to the fact — after all it’s your fault you’re using useState for objects 😜</p><p>Classic React had its shouldComponentUpdate() method to help in these cases but we are long gone from the class component world. Now, there are several ways to solve this, be it by breaking up the object by it’s fields (in our s̶t̶u̶p̶i̶d̶ simple example, we could’ve just had a username state variable directly) or using a more apt tool for this, such as useReducer that we mentioned before or doing some type of memoization — but we’ll also talk about these in the not-so-distant future.</p><h3>Wake Up, Lazy State</h3><p>There are cases where we want to initialize a component’s state with a given computation, such as the result an expensive function. We can see such a case down below:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/749684017d67a3bbeef0bd4a31fa8bb5/href">https://medium.com/media/749684017d67a3bbeef0bd4a31fa8bb5/href</a></iframe><p>Using your imagination (please do), imagine the getValue is a function that produces a (useful) value after doing some heavy computation. We need this heavily computed value to initialize our count variable with its first value — nothing to special here.</p><p>If you play around with this component, you’ll notice a couple of things (besides the stupidest way of obtaining the constant value 1000000000 ). First off, when the component loads, there is a significant delay to actually render the component (or if you’re on one of those fabled quantum computers, increase the number of 0 in the loop). One could imagine that this would make sense for the first render (aka the <em>mount</em>) of the component, since it has to do the heavy calculation to get the initial value. But what is quite strange is that, if we click the button to increment count , we notice this same delay every single time. This begs the question: why is our expensive calculation being done <em>every single render </em>if we only need it for the initial value?</p><p>The answer is pretty simple: React components are nothing but regular functions. If a function calls another function inside of it, and this call isn’t conditional (meaning it will be called on every function invocation —in our case, it has to be since React hooks are <strong>prohibited</strong> from being called conditionally), it will execute the whole body of that function, independently if we use that value for something useful or not. And here this is an obvious big no-no. So how can we solve this?</p><p>One way would be to put our calculation outside the component, simply getting the initial value once and passing it as a value later on. While that’s possible, this is typically impractical since if this function is always going to calculate the same value, why not just pre-calculate this value beforehand and pass it as a const to your state variable? And in most cases, we’ll probably need to wait on a prop value or some other dynamic value that is required, so that’s a no go.</p><p>To solve this, useState actually offers a <em>lazy initialization</em>, meaning that it is able of calling a function once when needed, and never calling this function again later on. The way to do this is by passing useState a function directly</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a0ba53c69c926ba8397e0d82e6874d73/href">https://medium.com/media/a0ba53c69c926ba8397e0d82e6874d73/href</a></iframe><p>Using useState like this, getValue will still make a choppy mount experience for this component but for further rerender, like when clicking the button, things will be smooth again since it knows to not call this function every again, in a very <em>lazy </em>fashion (the good type of lazy). And that’s that.</p><h3>Born Identity</h3><p>One last thing I want to talk about before the bell rings and letting you go off to recess — one <em>very important but often overlooked</em> characteristic about useState and setState specifically is that React guarantees that this function has a <em>stable identity</em>. That’s a fancy way of saying the React will <strong>always </strong>return the same function (that is, the same reference to the same function object) on every render, be it the first or the thousandth render. Check this out below:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c03bfa3af6a619fd2639a0bc616ede5/href">https://medium.com/media/7c03bfa3af6a619fd2639a0bc616ede5/href</a></iframe><p>Give the button a ride and click a few times and check your console. Trust me, <em>they are the same.</em></p><blockquote>⚠️ In case you see false in your console, it’s because I’ve been lying to you this whole time. Just kidding, try removing &lt;React.StrictMode&gt; in case you’re using it or leave a comment for me to explain this better :)</blockquote><p>And you might ask, “<em>Ricardo, why end your post talking about something so… unimportant?</em>”, to which I respond “<em>Gasp! Unimportant?</em>”, but I understand the concern, so I’ll give you part of the answer — when we get to our next hook, you’ll see that reference stability is very important. So stick around to learn more about hooks and in special, our next hook friend, useEffect .</p><p>Catch you guys on the flippity flip and until then ✌️</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88ec31d69a5e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/rpedroni/usestate-diving-deep-into-react-hooks-2021-88ec31d69a5e">useState — Diving Deep into React Hooks (2021)</a> was originally published in <a href="https://medium.com/rpedroni">RPEDRONI</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testes Eficientes Usando React Testing Library]]></title>
            <link>https://medium.com/reactbrasil/testes-eficientes-usando-react-testing-library-580abb64ef98?source=rss-8d09c1d9ddc2------2</link>
            <guid isPermaLink="false">https://medium.com/p/580abb64ef98</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[react-testing-library]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[jest]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Ricardo Pedroni]]></dc:creator>
            <pubDate>Wed, 17 Feb 2021 12:19:26 GMT</pubDate>
            <atom:updated>2021-03-08T16:31:26.142Z</atom:updated>
            <content:encoded><![CDATA[<p>Testando e tornando seus componentes React indestrutíveis, da forma certa.</p><p>Fala, galera! Aqui é o Professor Ricardo Pedroni e vamos juntos para mais uma aula fantástica 🎉<br><a href="https://youtu.be/UKCIfwI8DxA">🎥 Não esqueça de ver essa aula</a> e <a href="https://www.youtube.com/watch?v=UKCIfwI8DxA&amp;feature=youtu.be">muitas outras no nosso Canal do YouTube!</a></p><p>A partir do momento que o React ganhou popularidade, muitas pessoas já pensavam na melhor forma de poder testar componentes para garantir que os mesmos fizessem o que era esperado. A ideia é simples: fazer testes que garantem que aquele botão faça algo quando apertado, que o seu &lt;Dropdown /&gt; mostre uma lista de opções quando acionado, e assim vai.</p><p>O que não foi tão simples nessa história toda foi chegar num consenso de qual é a melhor forma de testar isso. Afinal, se tem uma coisa que engenheiros, cientistas da computação e profissionais em tecnologia em geral fazem bem, é saber se quebrar na porrada proverbial brigando por um ponto de vista.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*RdnXpcCvGNHfww_T" /><figcaption>Engenheiros definindo os novos features do JavaScript/ES 2021</figcaption></figure><p>A discussão era em torno exatamente <em>como </em>testar os componentes. Uma das bibliotecas a ganhar muita atenção logo no começo foi a <a href="https://enzymejs.github.io/enzyme">Enzyme</a>. Criada pelo Airbnb, a premissa do Enzyme é facilitar o acesso a valores de um componente renderizado, podendo verificar e testar esses valores para ver se batem com os valores esperados pelo desenvolvedor.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6855cbe0df4057d19e1c50318b68d495/href">https://medium.com/media/6855cbe0df4057d19e1c50318b68d495/href</a></iframe><p>No teste acima, usamos o shallow do Enzyme para renderizar (em memória) o componente e, usando um helper .state(), pegamos um valor de dentro do estado do componente e testamos se o valor equivale ao que esperamos, nesse caso, se é true</p><h3>Testes Testando Errado?</h3><p>O que acabamos de ver é um teste, não é? Formalmente, com certeza. Mas a discussão que gera certa controvérsia é que um teste desse tipo é um teste que testa o componente de <em>forma errada</em>. A razão disso é que veja bem o que está sendo testado — nesse caso, o state do componente (que é um valor interno e privado do componente) averiguando se o estado do componente <em>tem</em> um certo valor. O problema disso (e eu concordo plenamente) é que <em>testar valores </em>desse tipo testam muito mais <strong>detalhes de implementação </strong>do que o <strong>funcionamento correto </strong>do componente.</p><p>Se eu testo que um componente começa com um valor interno em true e que, ao ser clicado, passa esse valor para false, eu estou efetivamente estando o componente? Ou seja, estamos garantindo que o componente FAZ o que ele precisa fazer ou estamos testando se o desenvolvedor programou corretamente o componente? Nesse tipo de teste, acaba sendo o último — o teste passa a ser uma verificação de programação invés de testar o que efetivamente faz.</p><blockquote>Teste o que um componente faz e não como ele foi programado</blockquote><p>Com esse conceito em mente, o <strong>React Testing Library (RTL) </strong>foi criado. Inventado pelo nobre Kent Dodds, o RTL <em>força </em>(na amizade, de forma delicada) você a escrever testes que verificam o uso e a funcionalidade de um componente, imitando justamente como um <a href="https://testing-library.com/docs/guiding-principles">usuário interfacearia</a> com o mesmo. Dessa forma, o teste testa certo 👌</p><h3>Testes Testando Certo!</h3><p>Vamos criar nosso componente (imaginário) a ser testado, o &lt;Dropdown /&gt;, usando nossa lista de requisitos<em> </em>abaixo<em>:</em></p><ol><li>Começa fechado</li><li>Ao ser clicado enquanto fechado, abre e mostra a lista de opções que recebe como parâmetro</li><li>Quando uma opção é clicada, fecha a lista e indica a opção selecionada</li></ol><p>Mesmo não sendo muito complexo, ter uma lista formal em mente <em>do que você espera</em> de algum pedaço de software e sempre útil. Com isso em mãos, vamos começar a ver como podemos testar e garantir que nosso componente faz o que esperamos que ele faça, criando os testes baseados nessas funcionalidades que destacamos (⚠️ Não vou explicar como instalar o RTL nesse post porque depende muito do ambiente em que está trabalhando — assista o vídeo no meu <a href="https://www.youtube.com/watch?v=UKCIfwI8DxA&amp;feature=youtu.be">canal do YouTube</a> para ver um exemplo funcional)</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3bb500ed33945ab2bc722583e9e6875b/href">https://medium.com/media/3bb500ed33945ab2bc722583e9e6875b/href</a></iframe><p>Repare que estou incluindo uma série de bibliotecas nos imports. Dessa lista, destacamos:</p><ul><li>@testing-library/jest-dom: adiciona métodos de verificação ao Jest, úteis para testes de componentes, como o .toBeInTheDocument() e .toHaveValue();</li><li>@testing-library/dom: entre outras coisas, te fornece o screen, que é como um browser em memória, que mantém o componente renderizado e é de onde vamos puxar os componentes baseados nos queries do RTL;</li><li>@testing-library/react: adiciona a capacidade de renderizar componentes React no mundo do RTL;</li><li>@testing-library/user-event: fornece ações de usuário para interagir com os componentes renderizados.</li></ul><p>Com toda essa parafernália instalada e incluída, podemos começar a escrever nossos testes, focando em cada um dos testes por vez:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3f4faadae9cb810c0ecaaf92badb394f/href">https://medium.com/media/3f4faadae9cb810c0ecaaf92badb394f/href</a></iframe><p>Normalmente o primeiro passo do teste de componente é renderizar o componente para que RTL possa fazer um query em cima dele depois. Aqui estamos renderizando nosso Dropdown com algumas opções de escolha de Pokémon (Por que Pokémon? Poké não? 🥁), o título do dropdown quando ele estiver fechado e a função que vai ser chamada quando uma das opções é selecionada.</p><blockquote>Repare que passamos uma função vazia para <em>onSelect</em> e é normal ver valores “vazios” assim em testes. Isso é feito para explicitar que aquela prop não será testada e seu valor não importa para o respectivo teste</blockquote><p>O primeiro teste é para garantir que o Dropdown comece fechado, sem mostrar as suas opções. A primeira pergunta portanto a se fazer é a seguinte: como testamos que algo não é visível?</p><p>Uma das formas é verificar se um valor interno do Dropdown (e.g. um valor de estado isOpen) é false, garantindo que <em>booleanamente </em>temos o valor correto para essa variável. Mas isso implica no problema que levantamos antes: não teste implementação, <strong>teste funcionalidade</strong>. E a melhor forma de testar funcionalidade é imitar o que seu usuário vê e faz — e é justamente nesse ponto que o RTL brilha.</p><p>Imitar seu usuário nesse caso é verificar que algo não pode ser visto e o RTL (junto com o @testing-library/jest-dom ) fornece formas eficientes de testar isso:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62b4e87f615c1ce2a7bd3431c8cd2998/href">https://medium.com/media/62b4e87f615c1ce2a7bd3431c8cd2998/href</a></iframe><p>Depois de renderizar o componente, usamos o screen , um utilitário que simula como se fosse a tela de um usuário, que fornece vários métodos para podermos buscar “coisas” dentro do que foi renderizado. Essas coisas podem ser inputs, labels, botões, checkboxes e qualquer outro tipo de elemento que o componente pode gerar. As opções para buscar esses elementos também são diversas e o RTL incentiva que a busca deve ser feita da forma mais “usuário” possível, ou seja, que se busque como um usuário buscaria aquele elemento.</p><p>No nosso exemplo, usamos o texto da lista de opções do Dropdown mesmo, que seria algo bem visual que nosso usuário viria. Isso também poderia ser por role (algo como screen.getByRole(&#39;button&#39;)) dependendo do nosso componente (a sequência de prioridade de busca pode ser vista <a href="https://testing-library.com/docs/queries/about">aqui</a>, junto com uma explicação). No nosso teste, foi verificado que nenhum elemento com o nome dos Pokémão que passamos estava presente no documento e que, se estivesse, falharia nosso teste. As opções de asserção são muitas, e uma lista gigante pode ser encontrada <a href="https://github.com/testing-library/jest-dom#custom-matchers">aqui</a>.</p><p>Agora que você entendeu a lógica do que deve ser feito para fazer um teste da forma correta, pause esse post (tira o dedo desse scroll!) e elabore mentalmente como os próximos dois testes devem ser feitos. O que falta testar então é:</p><ol><li>Ao ser clicado enquanto fechado, abre e mostra a lista de opções que recebe como parâmetro</li><li>Quando uma opção é clicada, fecha a lista e indica a opção selecionada</li></ol><p>Pensa bem — não vai demorar mais que 2 minutos, beleza?</p><p>…</p><p>Pensou?</p><p>Maravilha?</p><p>Pensou bem?</p><p>Ótimo! (ou você mentiu mas aí vai na tua consciência)</p><p>Bora lá.</p><h3>Mais Testes Testando Certo</h3><p>Nosso segundo teste aborda a questão de uma ação do usuário e responder a essa ação. Para isso, temos a maravilhosa biblioteca do @testing-library/user-event , que simula lindamente a interação de um usuário com o browser. Alguns dos métodos que ela expõe são o click, o clear e o type , dentre outros, que podem ser vistos <a href="https://testing-library.com/docs/ecosystem-user-event">aqui</a>. Então simbora para nosso teste!</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/582ee41c51e969b53628e4f88a60ece7/href">https://medium.com/media/582ee41c51e969b53628e4f88a60ece7/href</a></iframe><p>Logo de cara, repare que passamos nossas opções e título para variáveis, facilitando o reuso deles e, mais importantemente, <strong>mostrando a relação explícita entre aquele valor e o valor testado</strong>. Sempre que puder mostrar que intencionalmente verificou um valor, faça isso.</p><p>Em seguida, renderizamos o componente e checamos novamente que nenhuma opção aparece (não tem problema repetir esse pedaço do teste porque faz sentido <em>semântico</em> ao teste atual também). Agora o getByRole vai servir para pegar uma referência ao elemento principal do Dropdown e vamos usar o userEvent para disparar uma clicada nesse botão (é um componente imaginário, então <em>tô imaginando </em>que o elemento principal é um botão 🤷‍♀️). Uma vez clicado, testamos para garantir que as opções do dropdown vão estar presentes na tela (por exemplo, esse getByTest poderia ser um screen.getByRole(‘menuitem’, { name: options[0] }) caso as opções fossem ítens de um menu). De qualquer maneira, garantimos que eles estão presentes e visíveis 👀</p><p>E para nosso último teste, nada especial — vamos agora garantir que “algo aconteça” e que somos sinalizados que esse “algo” aconteceu.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1b33bdbb437f73ec5a22b086a27f060d/href">https://medium.com/media/1b33bdbb437f73ec5a22b086a27f060d/href</a></iframe><p>E <em>voilá</em>: mágica. Tudo começa igual mas repare agora que estamos passando uma função <em>mockada</em> para o onSelect, justamente porque queremos verificar se essa função vai ser chamada quando deve ser chamada. Renderizamos, abrimos e selecionamos uma opção (a melhor delas, Bulbasaur), e verificamos que o menu fechou depois de opção selecionada. Inclusive foi verificado que a função mockonSelect foi chamada para garantir que o componente sinaliza o componente-pai que uma opção foi selecionada. Você pode me questionar: “Ricardo, seu cusão, você não disse que testar implementação é errado?” e eu te respondo — Sim, mas nesse caso defendo por três razões: 1/ é uma funcionalidade essencial desse componente que, se não funcionar, inutiliza o componente 2/ não entra em muitos detalhes de implementação, apenas que “algo” acontece e 3/ Nunca leve regras <em>muito</em> a sério — se algo parece importante para você, vai lá e faça, caraio.</p><h3>Conclusão</h3><p>Agora que você sabe testar corretamente componentes, não quero ver mais aplicação quebrando por aí. Se você curtiu esse post, me faça o pequeno favor de se <a href="https://www.youtube.com/channel/UCuXbZ8Nv2oHDz2fXVJHIxVQ/about">inscrever no meu canal do YouTube</a>, onde <a href="https://www.youtube.com/watch?v=UKCIfwI8DxA&amp;feature=youtu.be">tenho um vídeo abordando justamente esse assunto em detalhes</a> ;)</p><h3>TLDR;</h3><ul><li>React Testing Library (RTL) é uma biblioteca de teste para React que facilita e incentiva tests feitos da forma correta — teste seus componentes e como seu usuário os usaria;</li><li>Teste funcionalidade e não valores — imite o que o seu usuário faria e não o que você espera do desenvolvedor;</li><li>Utilize um <em>test runner</em> qualquer como o Jest e rode seus testes normalmente, junto com as capacidades adicionais de query e testes do RTL</li></ul><p>Espero que esse post tenha te ajudado!<br>Ficou com dúvida ou quer mandar uma real? Deixa nos comentários! <br>Ah, e me acompanhe também no YouTube: <a href="https://bit.ly/3q0TIAU">https://bit.ly/3q0TIAU</a> ✌!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=580abb64ef98" width="1" height="1" alt=""><hr><p><a href="https://medium.com/reactbrasil/testes-eficientes-usando-react-testing-library-580abb64ef98">Testes Eficientes Usando React Testing Library</a> was originally published in <a href="https://medium.com/reactbrasil">React Brasil</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>