From 412befa34c30e91bb9d5b7980a14fca7c8cdb26a Mon Sep 17 00:00:00 2001 From: Adriano Pereira Junior Date: Wed, 2 Oct 2019 17:48:42 -0300 Subject: [PATCH 1/2] Create the-process-module.md --- .../getting-started/the-process-module.md | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 locale/pt-br/knowledge/getting-started/the-process-module.md diff --git a/locale/pt-br/knowledge/getting-started/the-process-module.md b/locale/pt-br/knowledge/getting-started/the-process-module.md new file mode 100644 index 0000000000000..fee162a28104f --- /dev/null +++ b/locale/pt-br/knowledge/getting-started/the-process-module.md @@ -0,0 +1,117 @@ +--- +title: Como usar o módulo global process +date: '2011-08-26T10:08:50.000Z' +tags: + - core + - globals +difficulty: 2 +layout: knowledge-post.hbs +--- + +Cada processo do Node.js tem uma série de funcionalidades embutidas, acessíveis através do módulo global `process`. O módulo `process` não precisa ser requisitado - isso é, de certo modo, literalmente um wrapper em volta do processo sendo executado, e muitos dos métodos que isto exibe, nada mais são do que wrappers em torno de chamadas de algumas das bibliotecas em C do núcleo do Node. + +## Eventos + +Existem 2 eventos embutidos que podem ser percebidos no módulo `process`, estes são `exit` e `uncaughtException`. + +O evento `exit` é acionado sempre que algum processo estiver prestes a ter sua execução encerrada. + +```javascript +process.on('exit', function () { + fs.writeFileSync('/tmp/myfile', 'Isto PRECISA ser salvo antes de sair.'); +}); +``` + +Códigos como o acima podem ser realmente úteis para salvar algum tipo de registro final antes de encerrar a execução. Note o uso de uma chamada de um sistema de arquivos síncrono - isso é para garantir que a E/S de dados finalize antes que o processo. + +O outro evento embutido se chama `uncaughtException`. Como você já deve imaginar, ele é acionado sempre que ocorreu algum erro que não foi devidamente tratado em seu programa. Essa não é a forma ideal de processar erros, mas pode ser bem útil como última linha de defesa se um programa necessitar rodar continuamente mesmo após o erro. + +```javascript +process.on('uncaughtException', function (err) { + console.error('Um erro inesperado ocorreu!'); + console.error(err.stack); +}); +``` + +O comportamento padrão do `uncaughtException` é imprimir a descrição do erro e parar a execução - usando o código acima, seu programa vai imprimir a mensagem informada e a descrição do erro, mas **não** vai interromper sua execução. + +## Streams + +O objeto `process` também disponibiliza alguns wrappings para as três streams `STDIO`, que são `stdin`, `stdout`, and `stderr`. De forma resumida, `stdin` é uma stream de entrada (que lê as informações inseridas pelo usuário), `stdout` é uma stream de saída não bloqueante (em outras palavras, é assíncrona), e `stderr` é uma stream de saída bloqueante (síncrona). + +A mais simples de ser descrita é a `process.stdout`. Tecnicamente, a maioria das saídas em Node são acompanhadas de `process.stdout.write()` - a qual a maioria das pessoas nem sequer conhece. O código a seguir é do arquivo `console.js` no núcleo do Node: + +```javascript +exports.log = function() { + process.stdout.write(format.apply(this, arguments) + '\n'); +}; +``` + +Já que muitas pessoas têm usado a sintaxe `console.log` proveniente do desenvolvimento para navegadores, isso foi disponibilizado como um wrapper conveniente. + +Nós temos também `process.stderr`, que é bem parecido com o `process.stdout` como uma única diferença, é bloqueante. Ao imprimir algo usando `stderr`, seu processo é bloqueado até que a escrita ocorra. Node.js contem várias funções que agem como atalhos para saída, a maioria delas acaba usando `stdout` ou `stderr` atrás dos panos. Aqui temos uma lista simples com referências: + +STDOUT, ou funções não bloqueantes: `console.log`, `console.info`, `util.puts`, `util.print` + +STDERR, ou funções bloqueantes: `console.warn`, `console.error`, `util.debug` + +Por último, `process.stdin` é uma stream de leitura para obter dados de entrada do usuário. Veja em [mais de input em cli](/pt-br/knowledge/command-line/how-to-prompt-for-command-line-input/). + +## Outras Propriedades + +O objeto `process` adicionalmente possui uma lista de propriedades que permitem você obter informações sobre o projeto executado. Vamos ver alguns exemplos simples com a ajuda da REPL: + +``` +> process.pid +3290 +> process.version +'v0.4.9' +> process.platform +'linux' +> process.title +'node' +``` + +O `pid` é ID de processo do SO, `platform` é algo mais geral como 'linux' ou 'darwin', e `version` refere-se a sua versão do Node. `process.title` é um pouco mais diferente - enquanto definido como `node` por padrão, isto pode ser definido para o que voce desejar, e será o que aparecerá na sua lista de processos em execução. + +O módulo `process` também exibe `process.argv`, um array contendo os argumentos de linha de comando command-line para o processo atual, e `process.argc`, um inteiro representando a quantidade de argumentos que foram passados. Leia mais em [como manusear argumentos na linha de comando](/pt-br/knowledge/command-line/how-to-parse-command-line-arguments/) + +`process.execPath` will return the absolute path of the executable that started this process. + +`process.env` contêm suas variáveis de ambiente. Tente `process.env.HOME`, por exemplo. + +## Métodos + +Existe também uma variedade de métodos vinculados ao objeto `process`, muitos dos quais lidam com aspectos bem avançados de um programa. Vamos dar uma olhada nos que normalmente são os mais usados, enquanto deixamos as partes mais avançadas para outros artigos. + +`process.exit` encerra o processo. Se você chamar uma função assíncrona e então chamar `process.exit()` imediatamente após, você está em uma situação imprevisível - a chamada assíncrona pode, ou não ser finalizada antes do término do programa. `process.exit` aceita apenas um parâmetro adicional - um número inteiro como código de saída. `0`, por convenção, é uma saída sem erros. + +`process.cwd` retorna o 'diretório de trabalho atual' do processo - este é o diretório pelo qual o comando de início do processo será executado. + +`process.chdir` é usado para modificar o diretório de trabalho atual. Por exemplo: + +``` +> process.cwd() +'/home/avian/dev' +> process.chdir('/home/avian') +> process.cwd() +'/home/avian' +``` + +Finalmente, em uma nota mais avançada, nós temos o `process.nextTick`. Este método aceita um argumento - um callback - e coloca isso no topo da próxima execução do loop do evento. Algumas pessoas fazem algo parecido com isso: + +```javascript +setTimeout(function () { + // código aqui +}, 0) +``` + +Todavia essa não é a maneira ideal. Em Node.js, isso deveria ser usado no lugar: + +```javascript +process.nextTick(function () { + console.log('Próxima viagem pelo loop do evento, wheeee!') +}); +``` + +Assim é bem mais eficiente, e muito mais preciso. From 3fb68d052042d66bc4c17fcab0a5c6565fa24b12 Mon Sep 17 00:00:00 2001 From: Adriano Pereira Junior Date: Sun, 6 Oct 2019 13:34:57 -0300 Subject: [PATCH 2/2] Update the-process-module.md --- .../getting-started/the-process-module.md | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/locale/pt-br/knowledge/getting-started/the-process-module.md b/locale/pt-br/knowledge/getting-started/the-process-module.md index fee162a28104f..80e81209743bf 100644 --- a/locale/pt-br/knowledge/getting-started/the-process-module.md +++ b/locale/pt-br/knowledge/getting-started/the-process-module.md @@ -8,7 +8,7 @@ difficulty: 2 layout: knowledge-post.hbs --- -Cada processo do Node.js tem uma série de funcionalidades embutidas, acessíveis através do módulo global `process`. O módulo `process` não precisa ser requisitado - isso é, de certo modo, literalmente um wrapper em volta do processo sendo executado, e muitos dos métodos que isto exibe, nada mais são do que wrappers em torno de chamadas de algumas das bibliotecas em C do núcleo do Node. +Cada processo do Node.js tem uma série de funcionalidades embutidas, acessíveis através do módulo global `process`. O módulo `process` não precisa ser importado - ele é, de certo modo, literalmente um wrapper em volta do processo sendo executado, e muitos dos métodos que ele possui, nada mais são do que wrappers em torno de chamadas de algumas das bibliotecas em C do núcleo do Node. ## Eventos @@ -22,9 +22,9 @@ process.on('exit', function () { }); ``` -Códigos como o acima podem ser realmente úteis para salvar algum tipo de registro final antes de encerrar a execução. Note o uso de uma chamada de um sistema de arquivos síncrono - isso é para garantir que a E/S de dados finalize antes que o processo. +Códigos como o acima podem ser realmente úteis para salvar algum tipo de registro final antes de encerrar a execução. Note o uso de uma chamada de um sistema de arquivos síncrono - isso é para garantir que a E/S de dados finalize antes do o processo. -O outro evento embutido se chama `uncaughtException`. Como você já deve imaginar, ele é acionado sempre que ocorreu algum erro que não foi devidamente tratado em seu programa. Essa não é a forma ideal de processar erros, mas pode ser bem útil como última linha de defesa se um programa necessitar rodar continuamente mesmo após o erro. +O outro evento embutido se chama `uncaughtException`. Como você já deve imaginar, ele é acionado sempre que algum erro que não foi devidamente tratado em seu programa ocorre. Essa não é a forma ideal de processar erros, mas pode ser bem útil como última linha de defesa se um programa necessita rodar continuamente mesmo após o erro. ```javascript process.on('uncaughtException', function (err) { @@ -37,7 +37,7 @@ O comportamento padrão do `uncaughtException` é imprimir a descrição do erro ## Streams -O objeto `process` também disponibiliza alguns wrappings para as três streams `STDIO`, que são `stdin`, `stdout`, and `stderr`. De forma resumida, `stdin` é uma stream de entrada (que lê as informações inseridas pelo usuário), `stdout` é uma stream de saída não bloqueante (em outras palavras, é assíncrona), e `stderr` é uma stream de saída bloqueante (síncrona). +O objeto `process` também disponibiliza alguns wrappings para as três streams `STDIO`, que são `stdin`, `stdout`, e `stderr`. De forma resumida, `stdin` é uma stream de entrada (que lê as informações inseridas pelo usuário), `stdout` é uma stream de saída não bloqueante (em outras palavras, é assíncrona), e `stderr` é uma stream de saída bloqueante (síncrona). A mais simples de ser descrita é a `process.stdout`. Tecnicamente, a maioria das saídas em Node são acompanhadas de `process.stdout.write()` - a qual a maioria das pessoas nem sequer conhece. O código a seguir é do arquivo `console.js` no núcleo do Node: @@ -72,11 +72,11 @@ O objeto `process` adicionalmente possui uma lista de propriedades que permitem 'node' ``` -O `pid` é ID de processo do SO, `platform` é algo mais geral como 'linux' ou 'darwin', e `version` refere-se a sua versão do Node. `process.title` é um pouco mais diferente - enquanto definido como `node` por padrão, isto pode ser definido para o que voce desejar, e será o que aparecerá na sua lista de processos em execução. +O `pid` é ID de processo do SO, `platform` é algo mais geral como 'linux' ou 'darwin', e `version` refere-se a sua versão do Node. `process.title` é um pouco diferente - enquanto definido como `node` por padrão, isto pode ser definido para o que você desejar, e será o que aparecerá na sua lista de processos em execução. O módulo `process` também exibe `process.argv`, um array contendo os argumentos de linha de comando command-line para o processo atual, e `process.argc`, um inteiro representando a quantidade de argumentos que foram passados. Leia mais em [como manusear argumentos na linha de comando](/pt-br/knowledge/command-line/how-to-parse-command-line-arguments/) -`process.execPath` will return the absolute path of the executable that started this process. +`process.execPath` vai retornar o diretório absoluto do executável que começou o processo em questão. `process.env` contêm suas variáveis de ambiente. Tente `process.env.HOME`, por exemplo. @@ -84,7 +84,7 @@ O módulo `process` também exibe `process.argv`, um array contendo os argumento Existe também uma variedade de métodos vinculados ao objeto `process`, muitos dos quais lidam com aspectos bem avançados de um programa. Vamos dar uma olhada nos que normalmente são os mais usados, enquanto deixamos as partes mais avançadas para outros artigos. -`process.exit` encerra o processo. Se você chamar uma função assíncrona e então chamar `process.exit()` imediatamente após, você está em uma situação imprevisível - a chamada assíncrona pode, ou não ser finalizada antes do término do programa. `process.exit` aceita apenas um parâmetro adicional - um número inteiro como código de saída. `0`, por convenção, é uma saída sem erros. +`process.exit` encerra o processo. Se você chamar uma função assíncrona e então chamar `process.exit()` imediatamente após, você está em uma situação imprevisível - a chamada assíncrona pode ou não ser finalizada antes do término do programa. `process.exit` aceita apenas um parâmetro adicional - um número inteiro como código de saída. `0`, por convenção, é uma saída sem erros. `process.cwd` retorna o 'diretório de trabalho atual' do processo - este é o diretório pelo qual o comando de início do processo será executado. @@ -98,7 +98,7 @@ Existe também uma variedade de métodos vinculados ao objeto `process`, muitos '/home/avian' ``` -Finalmente, em uma nota mais avançada, nós temos o `process.nextTick`. Este método aceita um argumento - um callback - e coloca isso no topo da próxima execução do loop do evento. Algumas pessoas fazem algo parecido com isso: +Finalmente, em uma nota mais avançada, nós temos o `process.nextTick`. Este método aceita um argumento - um callback - e coloca isso no topo da próxima execução do event loop. Algumas pessoas fazem algo parecido com isso: ```javascript setTimeout(function () { @@ -114,4 +114,4 @@ process.nextTick(function () { }); ``` -Assim é bem mais eficiente, e muito mais preciso. +Além de bem mais eficiente, é muito mais preciso.