Node.js: criando sua primeira biblioteca

Criando um projeto em Node.js - Apresentação

Olá, boas-vindas ao curso de criação de bibliotecas com JavaScript e Node.js!

Vamos aprender a desenvolver um programa que automatiza ou otimiza processos e tarefas em programação. Bibliotecas podem ser utilizadas por outras partes de um programa, programas de terceiros ou outras pessoas e empresas.

Desenvolver bibliotecas envolve todos os fundamentos do JavaScript, como manipulação de dados, criação de funções com parâmetros e retornos e manipulação de arrays e objetos.

Para além dos fundamentos, também entenderemos comandos do terminal, desenvolvimento web, requisições, respostas e códigos HTTP. Também vamos começar a escrever expressões regulares e praticar funções, Libs e APIs específicas do Node.js.

Esse curso é voltado a iniciantes no mundo da programação, mas que já tenham contato com os fundamentos mencionados acima, como funções, tipos de dados, arrays e objetos.

Aqui, não entraremos em assuntos relativos à parte de front-end. Embora este não seja um curso de API, se você já tiver familiaridade com esse assunto, entendendo o funcionamento do Node.js e do NPM, já trabalhar bem com linhas de comando e expressões regulares e tiver prática com algumas das APIs e bibliotecas nativas do Node.js,esse curso pode não ser para você.

Aprenderemos o que é o Node.js, como trabalhar com algumas de suas APIs nativas e NPM, como funcionam exportações de módulos, dependências, como o JavaScript *acessa arquivos externos e trabalha com a *file system, a biblioteca resonsável por interagir com os arquivos do nosso computador.

Também vamos trabalhar com promessas, a forma usada pelo JavaScript para trabalhar com programação assíncrona. Além disso, conheceremos as expressões regulares, um recurso computacional que identifica padrões em sequências de caracteres, algo usado em todas as linguagens de programação comerciais.

Por fim, vamos entender como funcionam os comandos que utilizamos na CLI e o que são as requisições e respostas, como o* erro 404* que sempre encontramos na Internet.

Depois do fim do curso, teremos conhecido vários conceitos importantes para trabalhar com Node.js e suas bibliotecas específicas.

E aí, vamos lá?

Criando um projeto em Node.js - Entendendo o problema

Nesse projeto, vamos construir uma biblioteca: um conjunto de códigos para executar tarefas específicas.

Todo programa é constituído por partes menores, que são as bibliotecas. Elas podem ser escritas por nós ou por outras pessoas que enfrentaram problemas específicos, os quais também podemos encontrar.

Antes de colocar a mão na massa, vamos entender o problema e como atacá-lo. Vamos trabalhar no contexto de um blog de programação, como a seção de artigos do site da Alura. Quase todo dia, novos artigos são publicados lá.

Os textos são escritos em Markdown, uma linguagem de marcação de sintaxe simplificada, ótima para formatar textos. Markdown é ideal para textos que precisam de formatação, listas, título, subtítulos, partes de código, links e imagens.

Essa linguagem é muito mais simples que a HTML e, no final do processo, pode ser convertida em HTML e exibida na tela. Ela também é utilizada para escrever os arquivos "README" no Github.

Vamos acessar o repositório do Node.js no Github e acessar o arquivo "README.md". Nele, vemos na tela, renderizado, um texto complexo, com vários elementos. Ainda no Github, se clicarmos no botão "Raw", veremos o arquivo pré-renderização. Assim, podemos ver o arquivo Markdown na forma em que é escrito.

As tags <h> do HTML, que são os títulos e subtítulos, são representados por cerquilhas (#). Uma cerquilha representa o H1, duas, o H2, e assim sucessivamente. Textos em negrito precisam de dois asteriscos antes e dois depois. Textos em itálico são quase a mesma coisa, mas exigem apenas um asterisco antes e um depois.

Para criar listas, inserimos um asterisco antes do texto. E links, por fim, são escritos com o título do link entre colchetes, seguido pelo link, entre parênteses, assim:

[Supporte](#support)

Mas o que isso tem a ver com o blog da Alura e seus arquivos? Todos os artigos dele têm links clicáveis. Mas, com o passar do tempo, pode ser que um desses links saia do ar. Para gerenciar isso numa plataforma com milhares de arquivos com links, como é o nosso caso, vamos contar com a ajuda dos nossos computadores.

Vamos automatizar essa tarefa. É isso que aprenderemos a fazer durante nosso projeto: criaremos uma biblioteca que resolva este problema específico, capaz de acessar arquivos de texto em Markdown, capturar os links espalhados pelo texto e testá-los.

Fazendo isso, descobriremos se os links ainda estão no ar. Antes de começarmos a escrever código, porém, vamos dar uma olhada no que já temos para trabalhar.

Se você ainda não deu uma olhada na seção "Preparando o ambiente", volte e baixe os arquivos iniciais do projeto, que são o index.js, uma pasta arquivos com o arquivo texto.md e package.json, o arquivo-manifesto de qualquer projeto em Node.js.

Obs: Se você quiser aprender o que é Node.js e quais são suas particularidades, pause este vídeo e volte para o material extra.

Obs: Nesse curso, trabalharemos com a versão 18, a mais recente do Node.js durante a gravação do curso. Ela se tornará a versão LTS (suporte a longo prazo) a partir de Outubro de 2022.

Por isso, será importante que nos certifiquemos de que estamos usando a versão correta do Node.js. Para verificar isso, abriremos a pasta do projeto no nosso terminal. Vamos inserir o comando node --version. Depois de executar, o terminal nos informará a versão instalada.

Caso você não esteja trabalhando com a versão 18, acesse nosso tutorial de Node Version Manager (NVM). Assim, você faz a transição para a versão correta de maneira simplificada.

Agora já sabemos o que devemos construir, qual o problema a ser resolvido e temos um esqueleto do arquivo. A partir do próximo vídeo, começaremos a resolver esse problema.

Criando um projeto em Node.js - Instalando dependências

Já temos uma base para nosso projeto em Node.js, conferimos o projeto e conversamos sobre o que são bibliotecas e qual sua função.

Para entendermos melhor a ideia de pegar códigos, métodos e funções disponibilizadas por outras empresas ou pessoas, vamos instalar outra biblioteca no nosso projeto.

Nesse momento, nosso projeto "index.js" só tem uma linha de código, que devolve uma string no terminal:

console.log('ola mundo');

Porém, usaremos o terminal para fazer tudo do projeto, inclusive exibir nossa lista de links. Quando o terminal começa a ficar com muita informação, a tendência é que nos perdamos um pouco entre textos. Teremos dificuldade em encontrar nossos console.log, por exemplo.

Seria interessante separar as informações que queremos exibir no terminal. Assim, a visualização seria facilitada. Antes de instalarmos a biblioteca, vamos copiar a primeira, e, até agora, única linha do nosso código. Vamos repeti-la duas vezes, com uma quebra de linha antes de cada repetição:

console.log('ola mundo');
console.log('ola mundo');
console.log('ola mundo');

Agora vamos abrir o arquivo "texto.md" e copiar o conteúdo da linha 3, até https://developer.mozilla.com/pt-NR/docs/Web/API/HTMLCanvasElement. Vamos substituir a string 'ola mundo' nas linhas 2 e 3 de "index.js" por essas informações:

console.log('ola mundo');
console.log('São geralmente recuperados a partir de um objeto [FileList] (https://developer.mozilla.org/pt-BR/docs/Web/API/FileList) que é retornado como resultado da seleção, pelo usuário, de arquivos através do elemento [<input>](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Input), a partir do objeto [DataTransfer](https://developer.mozilla.org/pt-BR/docs/Web/API/');
console.log('São geralmente recuperados a partir de um objeto [FileList] (https://developer.mozilla.org/pt-BR/docs/Web/API/FileList) que é retornado como resultado da seleção, pelo usuário, de arquivos através do elemento [<input>](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Input), a partir do objeto [DataTransfer](https://developer.mozilla.org/pt-BR/docs/Web/API/');

Agora temos 3 console.log que aparecerão no terminal quando executarmos o arquivo. Vamos voltar ao terminal, na pasta correta do projeto, e realizar a execução com o comando node index.js.

Em seguida, vários textos serão exibidos no console. Lembra quando comentamos que as bibliotecas costumam resolver problemas comuns em programação? Este é um desses casos.

No NPM, vamos encontrar a biblioteca necessária para possibilitar que separemos textos por cor, adicionemos negrito, highlights ou underlines em algum dos textos para facilitar a identificação no terminal.

Vamos acessar https://www.npmjs.com/package/chalk, uma biblioteca pública do NPM chamada Chalk, que significa giz de cera em português. Nesse site, temos acesso a várias informações, como exemplos de uso, como instalar, documentação da biblioteca e versão.

No momento de gravação do curso, o Chalk estava na versão 5.0.1. Guarde esse número, porque é nessa versão que devemos trabalhar. Agora vamos instalar a biblioteca e aprender a utilizá-la.

De volta ao terminal, vamos rodar o comando npm install chalk@5.0.1 --save-exact.

Obs: Se você já começou a trabalhar com Node.js e instalou suas primeiras dependências, bastaria digitar npm install chalk para realizar a instalação. No vídeo, a instrutora escreve um comando maior para baixarmos especificamente a versão 5.0.1, utilizada por ela no curso. Para que não haja nenhum conflito com o que é ensinado no vídeo, devemos trabalhar com essa exata versão.

Depois de executar o comando, os arquivos do Chalk *serão puxados do repositório do *NPM para nosso terminal local. Se voltarmos à nossa IDE, veremos que a pasta "node_modules" foi baixada. Dentro dela há a pasta "chalk", com os arquivos da biblioteca.

Além disso, recebemos os arquivos package-lock.json, que controla as dependências e suas versões, e package.json, na parte de dependências, com a informação da versão do Chalk instalada na linha 21 do código.

As bibliotecas, muitas vezes, são desenvolvidas por pessoas, comunidades ou empresas para universalizar a solução de problemas comuns. No caso do Chalk, vamos adicionar cores e efeitos aos textos do terminal. E, dentro da página do Chalk no NPM, aprendemos a usar a biblioteca.

Sempre começaremos importando a biblioteca no projeto, com o código import chalk from 'chalk';. Depois, encontramos um console.log inicial de uso. Vamos inserir essas informações na primeira linha do código em "index.js", substituindo 'Hello world!' por 'olá mundo':

import chalk from 'chalk';

console.log(chalk.blue('olá mundo'));

console.log('ola mundo');
console.log('São geralmente recuperados a partir de um objeto [FileList] (https://developer.mozilla.org/pt-BR/docs/Web/API/FileList) que é retornado como resultado da seleção, pelo usuário, de arquivos através do elemento [<input>](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Input), a partir do objeto [DataTransfer](https://developer.mozilla.org/pt-BR/docs/Web/API/');
console.log('São geralmente recuperados a partir de um objeto [FileList] (https://developer.mozilla.org/pt-BR/docs/Web/API/FileList) que é retornado como resultado da seleção, pelo usuário, de arquivos através do elemento [<input>](https://developer.mozilla.org/pt-BR/docs/Web/HTML/Element/Input), a partir do objeto [DataTransfer](https://developer.mozilla.org/pt-BR/docs/Web/API/');

Agora vamos salvar e voltar ao terminal. É hora de tentarmos executar o arquivo "index.js" com o comando node index.js. Ao fazer isso, vamos nos deparar com um erro importante para entendermos como o Node.js funciona.

Esse erro de sintaxe aconteceu na primeira linha, onde lemos import chalk from 'chalk';. Ou seja, a linha na qual importamos o conteúdo da biblioteca para o nosso arquivo. O Node.js também nos informa que não podemos usar o statement import fora de um módulo.

Até sua versão 13, o Node.js importava e exportava códigos entre arquivos e projetos de outra maneira. Isso era feito a partir da criação de uma constante, usando a função require. E, dentro da função, passávamos uma string com o nome da biblioteca desejada.

Essa forma foi substituída, nas versões mais atuais, pela sintaxe ECMAScript Modules. Ela é, basicamente, a sintaxe que utilizamos na primeira linha do nosso código. Ela é a forma mais moderna e indicada para trabalhar com importação no JavaScript.

O indicador que utilizamos junto ao import, chalk, no caso, age como uma variável. E, 'chalk', após o from, passa o nome, caso seja uma biblioteca externa. Caso estejamos lidando com outra função, ou uma variável de outra parte do código, passaremos o endereço do arquivo.

O uso da função require está sendo abandonado aos poucos, embora ainda consigamos encontrar informações sobre ela nas documentações do Node.js.

Obs: Depois desse vídeo, nós encontraremos um conteúdo extra que esclarece as questões relacionadas a importação e exportação de módulos em JavaScript e em Node.js.

Para que o erro de sintaxe da primeira linha não aconteça, precisaremos acessar o arquivo package.json e adicionar a propriedade type: "module", para avisar que estamos usando a sintaxe de módulos, após a propriedade main. Sempre entre aspas, porque estamos manipulando um arquivo .json:

"main": "index.js",
"type": "module",

Depois de salvar, podemos voltar ao terminal e tentar executar novamente com o comando node index.js. Basta apertar a seta para cima para recuperar este comando, porque ele foi o último que executamos.

Agora teremos sucesso. O console.log "olá mundo" será exibido na nossa tela, pintado de azul, e os outros textos terão a cor branca. Agora, podemos ir à documentação do Chalk e deixar a imaginação correr solta, porque há inúmeras opções de cores, efeitos e visualizações.

É possível inverter a cor do texto ou do fundo, por exemplo. Vamos voltar ao projeto e, em sua raiz, adicionar o arquivo ".gitignore". Esse arquivo serve para não incluir a pasta "node_modules" no Git, quando salvarmos nosso projeto.

Essa pasta só deve existir localmente, porque, sempre que fazemos a instalação de um projeto, o NPM puxa os arquivos. Isso faz com que a pasta tenda a ficar muito grande. Por esta razão, não devemos subir essa pasta para o Git.

À linha 1 do código do arquivo ".gitignore", vamos adicionar node_modules. Caso estejamos utilizando o sistema operacional macOS para desenvolver, podemos adicionar uma segunda linha com o arquivo .DS_Store, um arquivo oculto desse sistema que guarda atributos visuais das pastas e outras informações.

Agora aprendemos a utilizar uma biblioteca de pequenos trechos de código para resolver problemas comuns de código. Na maior parte das vezes, alguém já enfrentou esses problemas antes e o código para resolvê-los já existe.

No próximo vídeo, vamos começar a pensar em como fazer o JavaScript ler um arquivo.

Sobre o curso Node.js: criando sua primeira biblioteca

O curso Node.js: criando sua primeira biblioteca possui 232 minutos de vídeos, em um total de 61 atividades. Gostou? Conheça nossos outros cursos de Node.JS em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Criando um projeto em Node.js
• Carregamento de arquivos
• Capturando links
• Usando a linha de comando
• Validando links