pt-BR：Translation of 'locale/pt-br/knowledge/REPL/how-to-create-a-custom-repl.md' (#2285)

This is a translation of 'locale/pt-br/knowledge/REPL/how-to-create-a-custom-repl.md'

Author: pehprado

locale/pt-br/knowledge/REPL/how-to-create-a-custom-repl.md

@@ -11,10 +11,12 @@ layout: knowledge-post.hbs
 O Node permite aos usuários criarem seus próprios REPLs com o [módulo `repl`](https://nodejs.org/dist/latest/docs/api/repl.html). A forma de uso mais básica se parece com isso:
 
 ```js
+var repl = require('repl')
+
 repl.start(prompt, stream);
 ```
 
-`prompt` é uma string que é usada para o prompt do seu REPL e tem por padrão o "> ". `stream` é um stream que o repl escuta e tem por padrão o `processo.stdin`. Quando você executa o comando `node` pelo prompt de comando, o que ele faz nos bastidores é executar `repl.start()` para fornecer o REPL padrão.
+No exemplo acima, o `prompt` é uma string que é usada para o prompt do seu REPL, que tem por padrão o "> ". `stream` é um stream que o repl escuta e tem por padrão o `process.stdin`. Quando você executa o comando `node` pelo prompt de comando, o que ele faz nos bastidores é executar `repl.start()` para fornecer o REPL padrão.
 
 Entretanto, o repl é bem flexível. Abaixo segue um exemplo que demonstra isso:
 
@@ -46,59 +48,58 @@ var local = repl.start("node::local> ");
 local.context.mood = mood;
 ```
 
-Este script cria *dois* REPLs: Um é normal, exceto pelo prompt customizado. Porém o  *outro* é exposto através do módulo net de forma que se possa fazer a conexão telnet para ele! Além disso, ele usa a propriedade `context` para expor a função "mood" para os dois REPLs, e a string "bonus" apenas para o REPL remoto. Como pode ver, essa forma de tentar expor objetos em um REPL e não no outro *não funciona*.
+Este script cria *dois* REPLs: Um é normal, exceto pelo prompt customizado. Porém o  *outro* é exposto através do módulo net de forma que se possa fazer a conexão telnet para ele! Além disso, ele usa a propriedade `context` para expor a função "mood" para os dois REPLs, e a string "bonus" apenas para o REPL remoto. Como você verá, essa forma de tentar expor objetos em um REPL e não no outro *não funciona*.
 
 Além disso, todos os objetos no escopo global também serão acessíveis para os seus REPLs.
 
-Observe o que acontece quando eu executo o script:
-
-    $ node repl.js 
-    REPL remoto iniciou na porta 5001.
-    node::local> .exit
-    ^Cjosh@pidgey:/tmp/telnet$ node repl.js 
-    REPL remoto iniciou na porta 5001.
-    node::local> mood()
-    '^__^'
-    node::local> bonus
-    ReferenceError: bonus is not defined
-        at [object Context]:1:1
-        at Interface.<anonymous> (repl.js:171:22)
-        at Interface.emit (events.js:64:17)
-        at Interface._onLine (readline.js:153:10)
-        at Interface._line (readline.js:408:8)
-        at Interface._ttyWrite (readline.js:585:14)
-        at ReadStream.<anonymous> (readline.js:73:12)
-        at ReadStream.emit (events.js:81:20)
-        at ReadStream._emitKey (tty_posix.js:307:10)
-        at ReadStream.onData (tty_posix.js:70:12)
+Aqui é o que acontece quando você executa o script:
+
+```shell
+$ node repl.js 
+REPL remoto iniciou na porta 5001.
+node::local> .exit
+# <ctrl>-C
 
+$ node repl.js 
+REPL remoto iniciou na porta 5001.
+node::local> mood()
+'^__^'
+node::local> bonus
+ReferenceError: bonus is not defined
+```
 
 Como podem notar, a função `mood` é usada junto do REPL local. Mas a string `bonus` não. Isso é esperado.
 
 Observem agora o que acontece quando fazemos um telnet para a porta 5001:
 
-    josh@pidgey:/tmp/telnet$ telnet localhost 5001
-    Trying ::1...
-    Trying 127.0.0.1...
-    Connected to localhost.
-    Escape character is '^]'.
-    node::remote> mood()
-    '>.<'
-    node::remote> bonus
-    'DESBLOQUEADO'
+```shell
+$ telnet localhost 5001
+Trying ::1...
+Trying 127.0.0.1...
+Connected to localhost.
+Escape character is '^]'.
+node::remote> mood()
+'>.<'
+node::remote> bonus
+'DESBLOQUEADO'
+```
 
-Como podem notar, a função `mood` *também* é disponibilizada através da telnet! Além disso `bonus` também é.
+Como você pode ver, a função `mood` *também* é disponibilizada através da telnet! Além disso `bonus` também é.
 
 Outro ponto interessante das minhas ações é que bonus agora também é definida no REPL local:
 
-    node::local> bonus
-    'UNLOCKED'
+```shell
+node::local> bonus
+'DESBLOQUEADO'
+```
 
 Parece que nós "desbloqueamos" a string `bonus` no REPL local também. Como parece ser, quaisquer variáveis criadas em um REPL também estão disponíveis no outro:
 
-    node::local> var node = "INCRÍVEL!"
+```shell
+node::local> var node = "INCRÍVEL!"
 
-    node::remote> node
-    'INCRÍVEL!'
+node::remote> node
+'INCRÍVEL!'
+```
 
-Como você pode ver, o REPL do node é potente e flexível.
+Como você pode ver, o REPL do node é poderoso e flexível.

locale/pt-br/knowledge/REPL/how-to-use-nodejs-repl.md

@@ -8,52 +8,116 @@ difficulty: 1
 layout: knowledge-post.hbs
 ---
 
+# Aprenda a usar o REPL
 
-O Node.js vem com seu próprio REPL, que é uma abreviação para 'Read-Eval-Print Loop'. É o shell do Node.js. Qualquer JavaScript válido que pode ser escrito em um script, pode ser passado para o REPL. Pode ser extremamente útil para experimentos com o node.js, depurar código e entender alguns comportamentos excêntricos do JavaScript.
+O Node.js vem com seu próprio REPL, que é uma abreviação para 'Read-Eval-Print Loop'. É o shell interativo do Node.js. Qualquer JavaScript válido que pode ser escrito em um script, pode ser passado para o REPL. Pode ser extremamente útil para experimentos com o node.js, depurar código e entender alguns comportamentos excêntricos do JavaScript.
 
-Para executar é simples - execute o node sem um nome de arquivo.
+Node.js tem um REPL independente, acessível a partir da linha de comando, e um módulo REPL integrado que você pode usar para
+[criar seu próprio REPL customizado](https://nodejs.org/api/repl.html#repl_repl). Nós vamos aprender o básico do REPL indepente.
 
-     docs@nodejitsu:~/$ node
+## Como começar com REPL
 
-Ele então te deixa em um prompt simples ('>') onde você pode escrever qualquer comando JavaScript que desejar. Assim como na maioria dos shells, você pode apertar as setas para cima e para baixo para navegar através do histórico de comandos e modificar comandos anteriores. O REPL também utiliza a tecla <kbd>Tab</kbd> para completar o comando.
+Iniciar o REPL é simples, basta executar o node na linha de comando sem um nome de arquivo.
 
-Qualquer que seja o comando, ele imprimirá o valor de retorno deste comando. Se você quiser reutilizar um valor de retorno anterior, você pode usar a variável especial `_`.
+```shell
+$ node
+```
 
-Por exemplo:
+Ele te deixa em um prompt simples ('>') onde você pode escrever qualquer comando JavaScript que desejar. Assim como na maioria dos shells, você pode apertar as setas para cima e para baixo para navegar através do histórico de comandos e modificar comandos anteriores. 
+
+```shell
+$ node
+> var x = "Olá, Mundo!"
+undefined
+> x
+"Olá, Mundo!"
+> .exit
+```
+
+Você pode também usar a tecla `Tab` para autocompletar alguns comandos. Quando várias opçõeS de preenchimento estiverem disponíveis, use `Tab` novamente para percorrê-las.
+
+## Comandos especiais e sair do REPL
+
+Os seguintes comandos especiais são surpotados por todas as instâncias do REPL (do [Documentação Node.js REPL](https://nodejs.org/api/repl.html#repl_commands_and_special_keys))
+
+* `.exit` - Fecha o fluxo de E/S, fazendo com que o REPL saia.
+* `.break` - Quando no processo de entrada de multilinha de expressão, entra o comando `.break` (ou a combinação das teclas `ctrl+C` é pressionada), as próximos entradas ou o processo daquela expressão serão abortados.
+* `.clear` - Reseta o `contexto` do REPL para um objeto vazio e limpa qualquer multilinha de expressão que tenha sido inserida atualmente.
+* `.help` - Mostra a lista de comandos especiais.
+* `.save` - Salva a sessão atual do REPL em um arquivo.
+  `> .save ./documentos/salvo.js`
+* `.load` - Carrega um arquivo dentro da sessão atual do REPL.
+  `> .load ./documentos/carregar.js`
+* `.editor` - Entra no modo editor (`ctrl+D` para terminar, `ctrl+C` para cancelar).
+
+```shell
+> .editor
+# Entering editor mode (^D to finish, ^C to cancel)
+function saudacao(nome) {
+  return `Olá, ${nome}!`;
+}
+
+saudacao('usuário do Node.js');
 
-     node
-     > 1+1
-     2
-     > _+1
-     3
+# ctrl+D
+'Olá, usuário do Node.js!'
+>
+```
+
+As seguintes combiações de teclas no REP têm esses efeitos especiais:
+
+* `ctr+C` - Quando pressionado uma vez, tem o mesmo efeito que o comando `.break`.
+  Quando pressionando duas vezes em um linha vazia, tem o mesmo efeito que o comando `.exit`.
+* `ctrl+D` - Tem o mesmo efeito que o comando `.exit`.
+* `tab` - Quando pressionado numa linha vazia, mostra as variáveis globais e locais (escopo).
+  Quando pressionado durando a entrada de um comando, mostra as opções relevantes que preenchem o comando.
+
+## Retornar valores
+
+Qualquer que seja o comando, ele imprimirá o valor de retorno deste comando. Se você quiser reutilizar o valor de retorno anterior, você pode usar a variável especial `_`.
+
+Por exemplo:
+```shell
+$ node
+> 1+1
+2
+> _+1
+3
+```
 
 Algo importante de notar é onde os valores de retorno do REPL são aplicados:
 
-     > x = 10
-     10
-     > var y = 5
-     > x
-     10
-     > y
-     5
+```shell
+> x = 10
+10
+> var y = 5
+> x
+10
+> y
+5
+```
 
 Quando a palavra-chave `var` é utilizada, o valor da expressão é armazenado. Porém, *NÃO* retornado. Quando um simples identificador é utilizado, o valor é retornado também, assim como armazenado.
 
+## Acessando Módulos
+
 Se você precisar acessar quaisquer módulos nativos, ou módulos terceiros, eles podem ser acessados através do `require`, assim como em qualquer parte do Node.
 
 Por exemplo:
 
-     node
-     > path = require('path')
-     { resolve: [Function],
-       normalize: [Function],
-       join: [Function],
-       dirname: [Function],
-       basename: [Function],
-       extname: [Function],
-       exists: [Function],
-       existsSync: [Function] }
-     > path.basename("/a/b/c.txt")
-     'c.txt'
+```shell
+$ node
+> path = require('path')
+{ resolve: [Function],
+  normalize: [Function],
+  join: [Function],
+  dirname: [Function],
+  basename: [Function],
+  extname: [Function],
+  exists: [Function],
+  existsSync: [Function] }
+> path.basename("/a/b/c.txt")
+'c.txt'
+```
 
 Note novamente que sem a palavra-chave `var`, o conteúdo do objeto é retornado imediatamente e apresentado no `stdout`.