Não há falta de bibliotecas e frameworks JavaScript para desenvolvedores web modernos. Uma das bibliotecas mais populares é o React, que o Facebook (agora Meta) criou para construir aplicativos ricos em recursos. Os aplicativos React tradicionalmente rodam em navegadores web, mas o framework Next.js estende a funcionalidade React para o lado do servidor através do ambiente de tempo de execução JavaScript Node.js.
Neste artigo, iremos analisar o Next.js e React para que você possa decidir se eles são adequados para o seu próximo projeto.
Confira nosso guia em vídeo sobre Next.js vs React:
Next.js e React: JavaScript no próximo nível
Uma pesquisa SlashData de 2022 descobriu que existem mais de 17 milhões de programadores JavaScript ao redor do mundo, liderando um grupo que inclui linguagens populares como Python e Java. JavaScript pode ser usado tanto no lado do cliente quanto do servidor, e esta versatilidade significa que os desenvolvedores podem construir aplicativos completas usando uma única linguagem de programação.
A introdução de bibliotecas JavaScript, como React e frameworks como Next.js, melhorou ainda mais esse desenvolvimento. Essas bibliotecas e frameworks fornecem recursos que simplificam a integração do frontend e backend. Além disso, os desenvolvedores podem estender os recursos JavaScript usando gerenciadores de pacotes como o npm (o gerenciador de pacotes Node.js) para instalar bibliotecas e ferramentas JavaScript. Estes recursos fornecem recursos sofisticados que reduzem a quantidade de código que você mesmo tem que escrever.
A extensibilidade do JavaScript significa que um conhecimento abrangente de suas ferramentas mais populares é a chave para o seu sucesso como um desenvolvedor web.
O que é Next.js?
Lançado inicialmente em 2016 pela Vercel, Next.js é um framework de código aberto React que fornece os blocos de build para criar aplicativos web de alto desempenho. Desde então, grandes empresas o adotaram, incluindo Twitch, TikTok, e Uber, para citar algumas.
Next.js oferece uma das melhores experiências de desenvolvimento para a construção de aplicativos rápidos e amigáveis ao SEO. Abaixo estão algumas funcionalidades do Next.js que fazem dele uma framework de produção excepcional:
- Capacidade de renderização híbrida
- Divisão automática de códigos
- Otimização de imagens
- Suporte integrado para pré-processadores CSS e bibliotecas CSS-in-JS
- Roteamento embutido
Essas funcionalidades ajudam os desenvolvedores do Next.js a economizar um tempo considerável na configuração e ferramentas. Você pode ir diretamente para a construção do seu aplicativo, que pode suportar projetos como os seguintes:
- Lojas de eCommerce
- Blogs
- Painel de Controle
- Aplicativos de uma página
- Interfaces de usuário interativas
- Sites estáticos
O que é React?
React é uma biblioteca JavaScript usada para construir interfaces de usuário dinâmicas. Além de criar interfaces web, você pode construir aplicativos para dispositivos móveis usando React Native.
Alguns benefícios do uso do React incluem:
- Melhoria de desempenho: Ao invés de atualizar cada componente no DOM, React usa um DOM virtual para atualizar apenas os componentes alterados.
- Baseado em componentes pesados: Uma vez que você cria um componente, você pode reutilizá-lo repetidamente.
- Depuração fácil: Os aplicativos React usam um fluxo de dados unidirecional — apenas dos componentes superiores para os componentes inferiores.
Next.js vs React
Embora os desenvolvedores frequentemente usem Next.js e React para o mesmo propósito, existem algumas diferenças fundamentais entre os dois.
Facilidade de uso
É fácil começar com Next.js e React. Cada um requer executar comandos únicos em seu terminal usando npx, que é parte do npm para Node.js.
Para o Next.js, o comando mais simples é:
npx create-next-appSem etapas adicionais para create-next-app, a instalação prosseguirá em modo interativo. Você será perguntado por um nome de projeto (que será usado para o diretório do projeto), e se você deseja incluir suporte ao TypeScript e ao linter de código ESLint.
Será algo parecido com isso:
Ao inicializar uma instância React, o comando mais simples inclui um nome para o diretório do projeto:
npx create-react-app new-appIsso cria uma pasta que contém todas as configurações e dependências iniciais necessárias.
Embora ambos facilitem o início, lembre-se que o Next.js é construído com base no React. Então, você não pode aprender Next.js sem primeiro aprender React e entender como ele funciona. Felizmente, o React possui uma curva de aprendizado suave e é ótimo para iniciantes.
Também é importante notar que React é relativamente desestruturado. Você deve instalar e configurar um roteador React e decidir como lidar com a busca de dados, otimização de imagens e divisão de código. Esta configuração requer que você instale e configure bibliotecas e ferramentas adicionais.
Em contraste, Next.js vem com estas ferramentas pré-instaladas e pré-configuradas. Com o Next.js, qualquer arquivo adicionado à pasta pages serve automaticamente como uma rota. Devido a este suporte integrado, Next.js é mais fácil de trabalhar diariamente, permitindo que você comece a codificar a lógica do seu aplicativo imediatamente.
Funcionalidades do Next.js e React
Como o Next.js é baseado no React, eles compartilham algumas funcionalidades. No entanto, o Next.js vai além e inclui recursos adicionais, como roteamento, divisão de código, pré-renderização e suporte a APIs, prontos para uso. Esses são recursos que você precisaria configurar por conta própria ao usar o React.
Coleta de dados
React renderiza dados do lado do cliente. O servidor envia arquivos estáticos para o navegador e então o navegador pega os dados das APIs para preencher o aplicativo. Este processo reduz o desempenho do aplicativo e fornece uma experiência ruim para o usuário, uma vez que o aplicativo carrega lentamente. O Next.js resolve este problema através de uma pré-renderização.
Com a pré-renderização, o servidor faz as chamadas API necessárias e busca os dados antes de enviar o aplicativo para o navegador. Como tal, o navegador recebe páginas de internet prontas para renderização.
A pré-renderização pode se referir à geração de sites estáticos (SSG) ou renderização do lado do servidor (SSR). No SSG, as páginas HTML são geradas em tempo de build e reutilizadas para múltiplas requisições. Next.js pode gerar páginas HTML com ou sem dados.
Abaixo está um exemplo de como o Next.js gera páginas sem dados:
function App() {
return <div>Welcome</div>
}
export default AppPara páginas estáticas que consomem dados externos, use a função getStaticProps(). Uma vez que você exporta getStaticProps() de uma página, Next.js irá pré-renderizar a página usando os adereços que ela retorna. Esta função sempre roda no servidor, então use getStaticProps() quando os dados que a página usa estiverem disponíveis no momento da construção. Por exemplo, você pode usá-lo para buscar artigos de blogs de um CMS.
const Posts= ({ posts }) => {
return (
<div className={styles.container}>
{posts.map((post, index) => (
// render each post
))}
</div>
);
};
export const getStaticProps = async () => {
const posts = getAllPosts();
return {
props: { posts },
};
};Em situações onde os caminhos da página dependem de dados externos, use a função getStaticPaths(). Então, para criar um caminho baseado no ID do artigo, exporte o getStaticPaths() da página.
Por exemplo, você pode exportar getStaticPaths() das páginas/posts/[id].js como mostrado abaixo.
export getStaticPaths = async() => {
// Get all the posts
const posts = await getAllPosts()
// Get the paths you want to pre-render based on posts
const paths = posts.map((post) => ({
params: { id: post.id },
}))
return { paths, fallback: false }
}getStaticPaths() é frequentemente emparelhado com getStaticProps(). Neste exemplo, você usaria getStaticProps() para buscar os detalhes do ID no caminho.
export const getStaticProps = async ({ params }) => {
const post = await getSinglePost(params.id);
return {
props: { post }
};
};Na SSR, os dados são buscados no momento solicitado e enviados para o navegador. Para usar SSR, exporte a função getServerSide() props da página que você deseja renderizar. O servidor chama esta função em cada solicitação, tornando o SSR útil para páginas que consomem dados dinâmicos.
Por exemplo, você pode usá-lo para buscar dados de uma API de notícias.
const News = ({ data }) => {
return (
// render data
);
};
export async function getServerSideProps() {
const res = await fetch(`https://app-url/data`)
const data = await res.json()
return { props: { data } }
}Os dados são buscados em cada solicitação e passados para o componente News por meio de props.
Divisão de código
A divisão do código significa dividir o código em partes que o navegador pode carregar sob demanda. Ela reduz a quantidade de código enviado ao navegador durante o carregamento inicial, já que o servidor envia apenas o que o usuário precisa. Bundlers como Webpack, Rollup e Browserify suportam a divisão de código em React.
Next.js suporta a divisão de código por padrão.
Com o Next.js, cada página é dividida em código (code-splitting), e adicionar páginas ao aplicativo não aumenta o tamanho do pacote (bundle). O Next.js também suporta importações dinâmicas, o que permite que você importe módulos JavaScript e carregue-os dinamicamente durante o tempo de execução. As importações dinâmicas contribuem para velocidades de página mais rápidas porque os pacotes são carregados sob demanda (lazy-loaded).
Por exemplo, no componente Home abaixo, o servidor não irá incluir o componente hero no pacote inicial.
const DynamicHero = dynamic(() => import('../components/Hero'), {
suspense: true,
})
export default function Home() {
return (
<Suspense fallback={`Loading...`}>
<DynamicHero />
</Suspense>
)
}Em vez disso, o elemento fallback do suspense será renderizado antes que o componente hero seja carregado.
Suporte API no Next.js vs React
O recurso de roteamento Next.js API permite que você escreva código backend e frontend na mesma base de código. Qualquer página salva na pasta /pages/api/ é mapeada para a rota /api/*, e Next.js trata como um endpoint API.
Por exemplo, você pode criar uma rota API page/api/user.js que retorna o nome do usuário atual desta forma:
export default function user(req, res) {
res.status(200).json({ username: 'Jane' });
}Se você visitar a URL https://app-url/api/user, você verá o objeto username.
{
username: 'Jane'
}As rotas API são úteis quando você quer mascarar a URL de um serviço que você está acessando ou quer manter as variáveis de ambiente em segredo sem codificar um aplicativo backend inteira.
Desempenho
Next.js é sem dúvida superior em sua capacidade de criar aplicativos de melhor desempenho com um processo simplificado. Os aplicativos SSR e SSG Next.js têm melhor desempenho do que os aplicativos React do lado do cliente (CSR). Ao buscar dados no servidor e enviar tudo o que o navegador precisa para renderizar, o Next.js elimina a necessidade de uma requisição de banco de dados para as APIs. Isso significa tempos de carregamento mais rápidos.
Porque o Next.js suporta o roteamento do lado do cliente. O navegador não precisa buscar dados do servidor cada vez que um usuário navega para outra rota. Além disso, o componente de imagem Next.js permite a otimização automática da imagem. As imagens são carregadas somente quando elas entram no viewport. Onde possível, o Next.js também serve imagens em formatos modernos como WebP.
Next.js também fornece otimizações de fontes, pré-busca de rotas inteligentes, e otimizações de agrupamento. Estas otimizações não estão automaticamente disponíveis em React.
Suporte
Como o React existe há mais tempo que o Next.js, ele tem uma comunidade mais extensa. No entanto, muitos desenvolvedores do React estão adotando o Next.js, de modo que a comunidade está crescendo constantemente. Os desenvolvedores estão mais facilmente encontrando soluções existentes para problemas que encontram do que tendo que construir soluções do zero.
Next.js também apresenta excelente documentação com exemplos abrangentes que são fáceis de entender. Apesar da sua popularidade, a documentação React não é tão navegável.
Resumo
Escolher Next.js ou React se resume aos requisitos de um aplicativo.
Next.js melhora as capacidades do React ao fornecer estrutura e ferramentas que melhoram o desempenho. Estas ferramentas, como roteamento, divisão de código e otimização de imagem, são incorporadas no Next.js, significando que os desenvolvedores não têm que configurar nada manualmente. Graças a estas funcionalidades, o Next.js é fácil de usar, e os desenvolvedores podem começar a codificar a lógica do negócio imediatamente.
Devido às diferentes opções de renderização, Next.js é adequado para aplicativos renderizadas do lado do servidor ou aplicativos que combinam geração estática e renderização do lado do servidor Node.js. Além disso, graças ao recurso de otimização fornecido pelo Next.js, ele é perfeito para sites que precisam ser rápidos, como lojas de eCommerce.
React é uma biblioteca JavaScript que pode ajudar você a criar e escalar aplicativos frontend robustas. Sua sintaxe também é simples, especialmente para desenvolvedores com experiência em JavaScript. Além disso, você tem controle sobre as ferramentas que você usa em seu aplicativo e como você os configura.
Planejando desenvolver seu próprio aplicativo que dominará o mundo? Confira a abordagem da Kinsta para a hospedagem de aplicativos Node.js em serviços de suporte ao React e Next.js.
Salman Ravoof é um desenvolvedor web autodidata, escritor, criador e grande admirador de Software Livre e de Código Aberto (FOSS). Além de tecnologia, ele se entusiasma com ciência, filosofia, fotografia, artes, gatos e comida. Saiba mais sobre ele em seu site e conecte-se com Salman no X.
Deixe um comentário