👏🏾 🔤 🐝 Um guia para iniciantes do Node.js Parte 3 ☠️ 🍢 ↖️

Bom dia amigos

Eu continuo a postar uma tradução deste tutorial Node.js .

Outras partes:

Parte 1

Parte 2

Parte 3

Parte 4

Obtendo dados inseridos pelo usuário no Node.js

Como faço para tornar um programa Node.js interativo?

Para fazer isso, a versão 7 do Node.js. introduz o módulo readline : é usado para obter dados de um fluxo para leitura, como process.stdinuma linha de comando durante a execução de um programa Node.js.

const readline = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})

readline.question(`What is your name?`, name => {
    console.log(`Hi ${name}!`)
    readline.close()
})

Esse código solicita o nome de usuário. Após a digitação e o clique do usuário enter, uma saudação é exibida.

O método question()imprime o primeiro parâmetro (pergunta) no console e aguarda a resposta do usuário. Quando pressionado enter, a função de retorno de chamada é executada.

Nesse retorno de chamada, fechamos a interface readline.

readlinecontém outros métodos, sobre os quais você pode ler na documentação.

Se você precisar solicitar uma senha, é melhor não devolvê-la explicitamente, mas use símbolos *.

Uma maneira de fazer isso é usar o pacote readline-sync , que é simples de entender e fácil de configurar.

Uma solução mais completa e abstrata é fornecida pelo pacote Inquirer.js .

Nós o instalamos com a ajuda npm install inquirere usamos da seguinte maneira:

const inquirer = require('inquirer')

const questions = [
    {
        type: 'input',
        name: 'name',
        message: `What's your name?`
    }
]

inquirer.prompt(questions).then(answers => {
    console.log(`Hi ${answers['name']}!`)
})

O Inquirer.js permite que você faça várias coisas legais, como sugerir várias opções, fornecer botões de opção, solicitar confirmação etc.

É mais conhecido como uma alternativa às soluções integradas, mas se você planeja levar a experiência do usuário para o próximo nível, o Inquirer.js é a melhor solução.

Estendendo a funcionalidade do arquivo Node.js usando exportação

O Node.js possui um sistema modular embutido.

O arquivo Node.js pode importar a funcionalidade de outros arquivos Node.js.

Quando você deseja importar algo que você usa const library = require('./library')

para importar a funcionalidade exportada em um arquivo library.jslocalizado no diretório atual.

Nesse arquivo, a funcionalidade deve ser exportada antes de poder ser importada em outro arquivo.

Qualquer outro objeto ou variável definido em um arquivo é por padrão privado (privado) e não pode ser usado em outros arquivos.

É isso que a interface module.exportsfornecida pelo sistema modular nos permite fazer .

Quando você atribui um objeto ou função como uma nova propriedade do objetoexports, você os exporta e, em seguida, eles podem ser importados para outro lugar no aplicativo ou em outro aplicativo.

Isso pode ser feito de duas maneiras.

A primeira maneira é atribuir um valor module.exports, que é o objeto padrão fornecido pelo sistema modular. Este método permite exportar apenas este objeto:

const car = {
    brand: 'Ford',
    model: 'Fiesta'
}

module.exports = car 

//   
const car = require('./car')

A segunda maneira é adicionar o objeto exportado como uma propriedade do objeto exports. Este método permite exportar muitos objetos, funções ou dados:

const car = {
    brand: 'Ford',
    model: 'Fiesta'
}

exports.car = car

ou então

exports.car = {
    brand: 'Ford',
    model: 'Fiesta'
}

Para usar este objeto em outro arquivo, você deve fazer um link para a importação:

const items = require('./items')
items.car

const car = require('./items').car

Qual é a diferença entre module.exportse exports?

O primeiro exporta o objeto referenciado, o segundo uma propriedade do objeto.

Uma introdução ao gerenciador de pacotes npm

Introdução ao npm

npmÉ o gerenciador de pacotes padrão do Node.js.

Em janeiro de 2017, o npm tinha mais de 350.000 pacotes, tornando-o o maior repositório de código em uma única linguagem de programação do Google Earth, e você pode ter certeza de que existem pacotes para fazer praticamente qualquer coisa.

Tudo começou com o download e o gerenciamento de dependências no Node.js, mas logo essa ferramenta começou a ser usada ativamente no desenvolvimento do lado do cliente dos aplicativos.

npmfaz várias coisas.

Uma alternativa ao npm é o fio .

Carregando

npmgerencia o carregamento de dependências do projeto.

Se existir um arquivo no projeto, o package.jsonlançamento npm installinstalará tudo o que o projeto requer no diretório node_modulescriado, se ele não existir.

Um pacote específico pode ser instalado usando npm install <package-name>.

Muitas vezes, a instalação de um pacote é acompanhada por sinalizadores:

--save - instala o pacote e inclui uma entrada sobre ele na seção de dependências do arquivo package.json
--save-dev - instala o pacote e adiciona uma entrada sobre ele na seção devDependencies do arquivo package.json

A principal diferença é que o devDependencies é usado para fins de desenvolvimento, por exemplo, para teste e as dependências são usadas na produção (ao criar um projeto).

Atualizando pacotes

A atualização é fácil com npm update.

npmirá verificar todos os pacotes para novas versões que atendam às restrições estabelecidas.

Você também pode atualizar um pacote específico: npm update <package-name>.

Versionamento

Além dos downloads padrão, o npm suporta controle de versão, para que você possa especificar qualquer versão específica de um pacote ou solicitar uma versão mais recente ou mais antiga.

Você encontrará frequentemente que uma biblioteca é compatível apenas com uma versão (principal) de outra biblioteca.

E também com os bugs das versões mais recentes que não foram corrigidas por um longo tempo.

O controle de versão também ajuda no desenvolvimento da equipe, porque cada membro da equipe sabe qual versão usar antes de atualizar o arquivo package.json.

Em todos esses casos, o controle de versão ajuda; nesse sentido, npmsegue os padrões aceitos.

Executando tarefas

package.jsonsuporta um formato para especificar comandos a serem executados no terminal com npm run <task-name>.

Por exemplo:

{
    "scripts": {
        "start-dev": "node lib/server-development",
        "start": "node lib/server-production"
    },
}

É prática comum usar esse recurso para executar o Webpack:

{
    "scripts": {
        "watch": "webpack --watch --progress --colors --config webpack.conf.js",
        "dev": "webpack --progress --colors --config webpack.conf.js",
        "prod": "NODE_ENV=production webpack -p --config webpack.conf.js"
    },
}

Isso permite, em vez de um conjunto de comandos longos, fáceis de esquecer ou fáceis de cometer erros, fazer o seguinte:

npm run watch 
npm run dev 
npm run prod

Onde o npm instala pacotes?

Ao instalar pacotes usando, npmvocê pode escolher entre dois tipos de instalação:

local
global

Por padrão, quando você insere, npm installpor exemplo:

npm install lodash

o pacote está instalado em uma pasta node_modulesno diretório atual.

Após a instalação, npmadicione um registro o lodashà seção dependenciesfile package.jsonno diretório atual.

Para uma instalação global, use o sinalizador -g:

npm install -g lodash

Em uma instalação global, o pacote é instalado não no diretório atual, mas no global.

Mas onde exatamente?

Para determinar isso, você precisa executar o comando npm root -g.

No macOS ou Linux, esse diretório pode ser /usr/local/lib/node_modules. No Windows - C:\Users\YOU\AppData\Roaming\npm\node_modules. Esse diretório pode ser diferente

quando usado nvmpara controle de versão do Node.js.

Como uso os pacotes instalados?

Como usar um node_modulespacote instalado em uma pasta ou globalmente.

Digamos que você instalou uma lodashbiblioteca auxiliar JavaScript popular npm install lodash.

Este comando será instalado lodashem um diretório local node_modules.

Para usar o programa, você precisa importar o pacote usando require:

const _ = require('lodash')

E se o pacote for executável (arquivo)?

Neste caso, o arquivo executável será colocado no diretório node_modules/.bin/.

Isso pode ser facilmente demonstrado usando a biblioteca cowsay .

Este pacote fornece um programa de linha de comando, quando executado, a vaca (e outros animais) "fala" alguma coisa.

Ao instalar um pacote via npm install cowsay, o próprio pacote e várias de suas dependências serão instaladas:

A pasta .binestá oculta e contém links simbólicos para a resposta dos dados binários:

Como executá-los?

É claro que você pode digitar ./node_modules/.bin/cowsaye deve funcionar, mas o npx incluído no npm (desde 5.2) é a melhor opção. Você apenas faznpx cowsaye o npx localizará o arquivo automaticamente: A

vaca diz "me tire daqui".

Manual do Package.json

Ao trabalhar com JavaScript, ao interagir com um projeto JavaScript, Node.js ou o front-end de um aplicativo, você provavelmente encontrará um package.json.

O que é isso? O que você deveria saber sobre ele? E o que você pode fazer com isso?

package.jsonÉ um tipo de manifesto do projeto. Ele pode fazer muitas coisas que não têm nenhuma relação entre si. Por exemplo, pode ser o arquivo principal para as configurações das ferramentas usadas. Ele também armazena os nomes e versões de todos os pacotes instalados (essas informações são usadas npme yarn).

Estrutura de arquivo

Aqui está um exemplo package.json:

{}

Como você pode ver, está vazio. Não package.jsonhá requisitos para o conteúdo . O único requisito é seu formato (JSON), caso contrário, os programas não poderão acessá-lo.

Se você estiver criando um pacote Node.js. que planeja distribuir npm, a situação mudará drasticamente e você precisará adicionar propriedades para ajudar outras pessoas a usar o pacote. Veremos isso mais tarde.

Aqui está outro exemplo package.json:

"name": "test-project"

Aqui nós definimos o nome do pacote ou aplicativo localizado no mesmo diretório que package.json.

Aqui está um exemplo de um mais complexo package.jsonemprestado de um aplicativo Vue.js.

{
  "name": "test-project",
  "version": "1.0.0",
  "description": "A Vue.js project",
  "main": "src/main.js",
  "private": true,
  "scripts": {
    "dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
    "start": "npm run dev",
    "unit": "jest --config test/unit/jest.conf.js --coverage",
    "test": "npm run unit",
    "lint": "eslint --ext .js,.vue src test/unit",
    "build": "node build/build.js"
  },
  "dependencies": {
    "vue": "^2.5.2"
  },
  "devDependencies": {
    "autoprefixer": "^7.1.2",
    "babel-core": "^6.22.1",
    "babel-eslint": "^8.2.1",
    "babel-helper-vue-jsx-merge-props": "^2.0.3",
    "babel-jest": "^21.0.2",
    "babel-loader": "^7.1.1",
    "babel-plugin-dynamic-import-node": "^1.2.0",
    "babel-plugin-syntax-jsx": "^6.18.0",
    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.0",
    "babel-plugin-transform-runtime": "^6.22.0",
    "babel-plugin-transform-vue-jsx": "^3.5.0",
    "babel-preset-env": "^1.3.2",
    "babel-preset-stage-2": "^6.22.0",
    "chalk": "^2.0.1",
    "copy-webpack-plugin": "^4.0.1",
    "css-loader": "^0.28.0",
    "eslint": "^4.15.0",
    "eslint-config-airbnb-base": "^11.3.0",
    "eslint-friendly-formatter": "^3.0.0",
    "eslint-import-resolver-webpack": "^0.8.3",
    "eslint-loader": "^1.7.1",
    "eslint-plugin-import": "^2.7.0",
    "eslint-plugin-vue": "^4.0.0",
    "extract-text-webpack-plugin": "^3.0.0",
    "file-loader": "^1.1.4",
    "friendly-errors-webpack-plugin": "^1.6.1",
    "html-webpack-plugin": "^2.30.1",
    "jest": "^22.0.4",
    "jest-serializer-vue": "^0.3.0",
    "node-notifier": "^5.1.2",
    "optimize-css-assets-webpack-plugin": "^3.2.0",
    "ora": "^1.2.0",
    "portfinder": "^1.0.13",
    "postcss-import": "^11.0.0",
    "postcss-loader": "^2.0.8",
    "postcss-url": "^7.2.1",
    "rimraf": "^2.6.0",
    "semver": "^5.3.0",
    "shelljs": "^0.7.6",
    "uglifyjs-webpack-plugin": "^1.1.1",
    "url-loader": "^0.5.8",
    "vue-jest": "^1.0.2",
    "vue-loader": "^13.3.0",
    "vue-style-loader": "^3.0.1",
    "vue-template-compiler": "^2.5.2",
    "webpack": "^3.6.0",
    "webpack-bundle-analyzer": "^2.9.0",
    "webpack-dev-server": "^2.9.1",
    "webpack-merge": "^4.1.0"
  },
  "engines": {
    "node": ">= 6.0.0",
    "npm": ">= 3.0.0"
  },
  "browserslist": ["> 1%", "last 2 versions", "not ie <= 8"]
}

Há muito aqui:

name - nome do aplicativo / pacote
version - versão do aplicativo / pacote
description - uma breve descrição do aplicativo / pacote
main - ficheiro principal (ponto de entrada) da aplicação
private- o valor trueimpede a publicação acidental do aplicativo nonpm
scripts - um conjunto de scripts (comandos) que podem ser executados (executados)
dependencies - dependências do projeto
devDependencies - dependências do projeto usadas apenas durante o desenvolvimento
engines - versões em que o aplicativo / pacote está sendo executado
browserlist - navegadores suportados (e suas versões)

Todas essas propriedades são usadas npm.

Propriedades

Nesta seção, falaremos sobre algumas das propriedades que você pode usar. Usaremos o termo "pacote", mas a maior parte do que foi dito também se aplica a aplicativos.

A maioria das propriedades é necessária para publicar o pacote npm, algumas para interagir com o pacote.

Nome nome)

Especifica o nome do pacote.

Por exemplo:

"name": "test-project"

O nome não deve exceder 214 caracteres, não deve conter espaços e pode consistir apenas em letras minúsculas (minúsculas), hífens (-) e sublinhado (_).

Isso ocorre porque um npmURL é atribuído ao pacote quando ele é publicado com base em seu nome.

Se o pacote for publicado no GitHub, é uma boa prática vincular ao repositório.

Autor

Identifica o autor do pacote.

Por exemplo:

{
    "author": "Joe <joe@whatever.com> (https://whatever.com)"
}

ou então:

{
  "author": {
    "name": "Joe",
    "email": "joe@whatever.com",
    "url": "https://whatever.com"
  }
}

Contribuintes

Especifica um ou mais contribuidores para o pacote. Esta propriedade é uma matriz de seqüências de caracteres.

Por exemplo:

{
  "contributors": ["Joe <joe@whatever.com> (https://whatever.com)"]
}

ou então:

{
  "contributors": [
    {
      "name": "Joe",
      "email": "joe@whatever.com",
      "url": "https://whatever.com"
    }
  ]
}

Erros

Define um link para um rastreador de problemas, geralmente um rastreador de problemas no GitHub.

Por exemplo:

{
  "bugs": "https://github.com/whatever/package/issues"
}

Pagina inicial

Define o endereço da página inicial.

Por exemplo:

{
  "homepage": "https://whatever.com/package"
}

Versão

Determina a versão atual do pacote.

Por exemplo:

"version": "1.0.0"

Esta propriedade segue o padrão de versão semântica. Isso significa que ele deve sempre consistir em três números separados por pontos x.x.x.

O primeiro número é a versão principal, o segundo é a versão secundária e o terceiro é o patch.

Cada número tem um significado específico: uma atualização para corrigir bugs é um patch, uma versão de alterações compatíveis com versões anteriores é uma versão menor e uma versão principal pode significar alterações incompatíveis com a versão anterior.

Licença

Especifica a licença para o pacote.

Por exemplo:

"license": "MIT"

Palavras-chave

Esta propriedade é uma matriz de palavras-chave associadas ao pacote.

Por exemplo:

"keywords": [
  "email",
  "machine learning",
  "ai"
]

Eles ajudam as pessoas a encontrar pacotes.

Descrição

Define uma breve descrição para o pacote.

Por exemplo:

"description": "A package to work with strings"

Ao publicar um pacote em uma npmdeterminada propriedade, ajuda as pessoas a entender para que serve.

Repositório

Determina onde o código fonte do pacote está localizado.

Por exemplo:

"repository": "github:whatever/testing",

Preste atenção ao prefixo github. Existem outros serviços semelhantes:

"repository": "gitlab:whatever/testing",

"repository": "bitbucket:whatever/testing",

Você também pode definir um sistema de controle de versão:

"repository": {
  "type": "git",
  "url": "https://github.com/whatever/testing.git"
}

Você pode especificar vários sistemas de controle de versão:

"repository": {
  "type": "svn",
  "url": "..."
}

a Principal

Define o arquivo principal (ponto de entrada) do pacote.

Ao importar um pacote para um aplicativo, é nesse arquivo que o aplicativo procurará os módulos exportados.

Por exemplo:

"main": "src/main.js"

privado

Definir essa propriedade como um valor trueimpede que o pacote seja publicado acidentalmente em npm.

Por exemplo:

"private": true

scripts

Define uma lista de comandos (scripts) que podem ser executados (executados).

Por exemplo:

"scripts": {
  "dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
  "start": "npm run dev",
  "unit": "jest --config test/unit/jest.conf.js --coverage",
  "test": "npm run unit",
  "lint": "eslint --ext .js,.vue src test/unit",
  "build": "node build/build.js"
}

Esses scripts são aplicativos de linha de comando. Você pode executá-los com npm run XXXXou yarn run XXXX, onde XXXXestá o nome do comando. Por exemplo: npm run dev.

Você pode usar qualquer nome como o nome do comando, o script fará o que você especificar nele.

Dependências

Define uma lista de dependências de pacotes.

Ao instalar um pacote usando npm ou yarn:

npm install <PACKAGENAME>
yarn add <PACKAGENAME>

o registro deste pacote será adicionado automaticamente à propriedade em questão.

Por exemplo:

"dependencies": {
  "vue": "^2.5.2"
}

devDependencies

Define uma lista de dependências para fins de desenvolvimento.

Eles diferem dependencies, pois são instalados apenas no computador do desenvolvedor e não entram em produção.

Ao instalar um pacote usando npm ou yarn:

npm install --save-dev <PACKAGENAME>
yarn add --save-dev <PACKAGENAME>

o registro sobre ele é automaticamente adicionado à propriedade considerada.

Por exemplo:

"devDependencies": {
  "autoprefixer": "^7.1.2",
  "babel-core": "^6.22.1"
}

motores

Determina em quais versões do Node.js ou outras ferramentas o pacote / aplicativo está executando.

Por exemplo:

"engines": {
  "node": ">= 6.0.0",
  "npm": ">= 3.0.0",
  "yarn": "^0.13.0"
}

lista de navegadores

Define uma lista de navegadores suportados (e suas versões). Essas informações são usadas pelo Babel, Autoprefixer e outras ferramentas para criar polyfills e garantir a compatibilidade com os navegadores especificados.

Por exemplo:

"browserslist": [
  "> 1%",
  "last 2 versions",
  "not ie <= 8"
]

Essa configuração significa que você deseja oferecer suporte às duas versões mais recentes de todos os navegadores que mais de 1% das pessoas usam de acordo com as estatísticas do CanIUse , com exceção do IE8 e das versões anteriores.

Propriedades especiais

package.jsonpode conter propriedades especiais para ferramentas como Babel, ESLint etc.

Cada uma dessas ferramentas possui suas próprias propriedades, por exemplo eslintConfig, babele assim por diante. Para detalhes sobre propriedades especiais, consulte a documentação correspondente.

Versões do pacote

Nos exemplos acima, você provavelmente notou entradas como esta: ~3.0.0, ^0.13.0. O que eles querem dizer? E que outros especificadores de versão posso usar?

Esses especificadores são usados para definir condições de atualização.

As regras são as seguintes:

~- write ~0.13.0significa que apenas atualizações de patches são permitidas, ou seja, release é 0.13.1válido, mas release 0.14.0não é
^- write ^0.13.0significa patch e pequenas atualizações são permitidas
*- registro *significa que qualquer atualização é permitida
> - quaisquer novas versões são permitidas
>= - versões semelhantes ou mais recentes são permitidas
<= - versões semelhantes ou mais antigas são aceitáveis
< - quaisquer versões antigas são permitidas

Aqui estão mais algumas regras:

nenhum caractere inicial - somente a versão especificada é permitida
latest - apenas a versão mais recente é permitida

Esses caracteres podem ser combinados de várias maneiras, por exemplo: 1.0.0 || >=1.1.0 <1.2.0.

Obrigado pela atenção.

Continua…

Um guia para iniciantes do Node.js Parte 3