Skip to content

Commit 5e730da

Browse files
0x4D53520x4D5352
committed
update pt-BR book
1 parent 0c62780 commit 5e730da

File tree

8 files changed

+393
-392
lines changed

8 files changed

+393
-392
lines changed

‎pt-BR/book/carregando_dados.md‎

Lines changed: 89 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -7,25 +7,25 @@ Anteriormente vimos como você pode usar comandos como `ls`, `ps`, `date` e `sys
77
Uma das funcionalidades mais poderosas do Nu para lidar com dados é o comando `open`. Ele é uma ferramenta múltipla, capaz de trabalhar com diversos formatos de dados. Para vermos o que isso significa, vamos tentar abrir um arquivo json:
88

99
```nu
10-
> open editors/vscode/package.json
11-
------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
12-
name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen
13-
| ion | | | | ry | r | es | | | onEvents | | tes | | dencies
14-
------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
15-
lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object]
16-
| support | develope | | | | | items] | | | | tension | | |
17-
| for VS | rs | | | | | | | | | | | |
18-
| Code | | | | | | | | | | | | |
19-
------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
10+
open editors/vscode/package.json
11+
# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
12+
# => name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen
13+
# => | ion | | | | ry | r | es | | | onEvents | | tes | | dencies
14+
# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
15+
# => lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object]
16+
# => | support | develope | | | | | items] | | | | tension | | |
17+
# => | for VS | rs | | | | | | | | | | | |
18+
# => | Code | | | | | | | | | | | | |
19+
# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+----------
2020
```
2121

2222
De um jeito similar ao comando `ls`, abrir um tipo de arquivo que o Nu entende vai nos retornar algo que é mais do que apenas texto (ou um fluxo de bytes). Aqui nós abrimos um arquivo "package.json" de um projeto JavaScript. O Nu abre e reconhece o texto JSON e retorna uma tabela de dados.
2323

2424
Se quisermos checar a versão do projeto que estamos olhando, podemos usar o comando `get`.
2525

2626
```nu
27-
> open editors/vscode/package.json | get version
28-
1.0.0
27+
open editors/vscode/package.json | get version
28+
# => 1.0.0
2929
```
3030

3131
O Nu atualmente suporta carregar dados diretamente para tabelas a partir dos seguintes formatos:
@@ -40,7 +40,7 @@ O Nu atualmente suporta carregar dados diretamente para tabelas a partir dos seg
4040
Mas o que acontece se você carregar um arquivo texto cujo formato não é um desses? Vamos tentar:
4141

4242
```nu
43-
> open README.md
43+
open README.md
4444
```
4545

4646
O conteúdo do arquivo é mostrado. Se o arquivo for muito grande, obteremos uma visão rolável para examinar o arquivo e depois voltar para o terminal. Para ajudar na legibilidade, Nu faz realce de sintaxe para formatos comuns como arquivos de código fonte, markdown e outros.
@@ -54,90 +54,90 @@ Uma parte importante de se trabalhar com dados vindos de fora do Nu é que eles
5454
Vamos imaginar que obtivemos esse arquivo de dados:
5555

5656
```nu
57-
> open people.txt
58-
Octavia | Butler | Writer
59-
Bob | Ross | Painter
60-
Antonio | Vivaldi | Composer
57+
open people.txt
58+
# => Octavia | Butler | Writer
59+
# => Bob | Ross | Painter
60+
# => Antonio | Vivaldi | Composer
6161
```
6262

6363
Cada pedacinho de dado que queremos está separado pelo símbolo de pipe ('|') e cada pessoa está numa linha em separado. Nu não possui por padrão um formato de arquivos delimitados por pipe, então teremos que interpretá-lo nós mesmos.
6464

6565
A primeira coisa que queremos fazer ao carregar o arquivo é trabalhar com ele linha a linha:
6666

6767
```nu
68-
> open people.txt | lines
69-
---+------------------------------
70-
# | value
71-
---+------------------------------
72-
0 | Octavia | Butler | Writer
73-
1 | Bob | Ross | Painter
74-
2 | Antonio | Vivaldi | Composer
75-
---+------------------------------
68+
open people.txt | lines
69+
# => ---+------------------------------
70+
# => # | value
71+
# => ---+------------------------------
72+
# => 0 | Octavia | Butler | Writer
73+
# => 1 | Bob | Ross | Painter
74+
# => 2 | Antonio | Vivaldi | Composer
75+
# => ---+------------------------------
7676
```
7777

7878
Podemos notar que estamos lidando com linhas porque voltamos a ver uma lista. Nosso próximo passo é tentar dividir as linhas em algo um pouco mais útil. Para isso, vamos usar o comando `split column`. Como o nome implica, esse comando nos dá uma forma de dividir em colunas uma string delimitada. Informamos qual é o delimitador e o comando faz o resto:
7979

8080
```nu
81-
> open people.txt | lines | split column "|"
82-
---+----------+-----------+-----------
83-
# | Column1 | Column2 | Column3
84-
---+----------+-----------+-----------
85-
0 | Octavia | Butler | Writer
86-
1 | Bob | Ross | Painter
87-
2 | Antonio | Vivaldi | Composer
88-
---+----------+-----------+-----------
81+
open people.txt | lines | split column "|"
82+
# => ---+----------+-----------+-----------
83+
# => # | Column1 | Column2 | Column3
84+
# => ---+----------+-----------+-----------
85+
# => 0 | Octavia | Butler | Writer
86+
# => 1 | Bob | Ross | Painter
87+
# => 2 | Antonio | Vivaldi | Composer
88+
# => ---+----------+-----------+-----------
8989
```
9090

9191
Está quase certo. Parece que tem um espaço extra ali. Vamos mudar nosso delimitador:
9292

9393
```nu
94-
> open people.txt | lines | split column " | "
95-
---+---------+---------+----------
96-
# | Column1 | Column2 | Column3
97-
---+---------+---------+----------
98-
0 | Octavia | Butler | Writer
99-
1 | Bob | Ross | Painter
100-
2 | Antonio | Vivaldi | Composer
101-
---+---------+---------+----------
94+
open people.txt | lines | split column " | "
95+
# => ---+---------+---------+----------
96+
# => # | Column1 | Column2 | Column3
97+
# => ---+---------+---------+----------
98+
# => 0 | Octavia | Butler | Writer
99+
# => 1 | Bob | Ross | Painter
100+
# => 2 | Antonio | Vivaldi | Composer
101+
# => ---+---------+---------+----------
102102
```
103103

104104
Nada mal. O comando `split column` retorna dados que podemos usar. Ele também vai além e nos dá nomes de coluna padrão:
105105

106106
```nu
107-
> open people.txt | lines | split column " | " | get Column1
108-
---+---------
109-
# | value
110-
---+---------
111-
0 | Octavia
112-
1 | Bob
113-
2 | Antonio
114-
---+---------
107+
open people.txt | lines | split column " | " | get Column1
108+
# => ---+---------
109+
# => # | value
110+
# => ---+---------
111+
# => 0 | Octavia
112+
# => 1 | Bob
113+
# => 2 | Antonio
114+
# => ---+---------
115115
```
116116

117117
Podemos também nomear nossas colunas ao invés de usar os nomes padrão:
118118

119119
```nu
120-
> open people.txt | lines | split column " | " first_name last_name job
121-
---+------------+-----------+----------
122-
# | first_name | last_name | job
123-
---+------------+-----------+----------
124-
0 | Octavia | Butler | Writer
125-
1 | Bob | Ross | Painter
126-
2 | Antonio | Vivaldi | Composer
127-
---+------------+-----------+----------
120+
open people.txt | lines | split column " | " first_name last_name job
121+
# => ---+------------+-----------+----------
122+
# => # | first_name | last_name | job
123+
# => ---+------------+-----------+----------
124+
# => 0 | Octavia | Butler | Writer
125+
# => 1 | Bob | Ross | Painter
126+
# => 2 | Antonio | Vivaldi | Composer
127+
# => ---+------------+-----------+----------
128128
```
129129

130130
Agora que nossos dados estão em uma tabela, podemos usar todos os comandos que já usávamos antes em tabelas:
131131

132132
```nu
133-
> open people.txt | lines | split column " | " first_name last_name job | sort-by first_name
134-
---+------------+-----------+----------
135-
# | first_name | last_name | job
136-
---+------------+-----------+----------
137-
0 | Antonio | Vivaldi | Composer
138-
1 | Bob | Ross | Painter
139-
2 | Octavia | Butler | Writer
140-
---+------------+-----------+----------
133+
open people.txt | lines | split column " | " first_name last_name job | sort-by first_name
134+
# => ---+------------+-----------+----------
135+
# => # | first_name | last_name | job
136+
# => ---+------------+-----------+----------
137+
# => 0 | Antonio | Vivaldi | Composer
138+
# => 1 | Bob | Ross | Painter
139+
# => 2 | Octavia | Butler | Writer
140+
# => ---+------------+-----------+----------
141141
```
142142

143143
Há outros comandos que você pode usar para trabalhar com strings:
@@ -149,23 +149,23 @@ Há outros comandos que você pode usar para trabalhar com strings:
149149
Há também um conjunto de comandos auxiliares que podemos chamar se soubermos que os dados têm uma estrutura que o Nu deve ser capaz de entender. Por exemplo, vamos abrir um arquivo de lock do Rust:
150150

151151
```nu
152-
> open Cargo.lock
153-
# This file is automatically @generated by Cargo.
154-
# It is not intended for manual editing.
155-
[[package]]
156-
name = "adhoc_derive"
157-
version = "0.1.2"
152+
open Cargo.lock
153+
# => # This file is automatically @generated by Cargo.
154+
# => # It is not intended for manual editing.
155+
# => [[package]]
156+
# => name = "adhoc_derive"
157+
# => version = "0.1.2"
158158
```
159159

160160
O arquivo "Cargo.lock" é na verdade um arquivo .toml, mas a extensão do arquivo não é .toml. Tudo bem, podemos usar o comando `from toml`:
161161

162162
```nu
163-
> open Cargo.lock | from toml
164-
----------+-------------
165-
metadata | package
166-
----------+-------------
167-
[object] | [405 items]
168-
----------+-------------
163+
open Cargo.lock | from toml
164+
# => ----------+-------------
165+
# => metadata | package
166+
# => ----------+-------------
167+
# => [object] | [405 items]
168+
# => ----------+-------------
169169
```
170170

171171
Há um comando `from` para cada formato de dados estruturados em texto que o Nu entende e pode abrir.
@@ -175,23 +175,23 @@ Há um comando `from` para cada formato de dados estruturados em texto que o Nu
175175
Embora seja útil poder abrir um arquivo e trabalhar imediatamente com uma tabela dos seus dados, nem sempre é isso o que queremos fazer. Para ter acesso ao texto subjacente, o comando `open` pode receber um modificador opcional `--raw`:
176176

177177
```nu
178-
> open Cargo.toml --raw
179-
[package] name = "nu"
180-
version = "0.1.3"
181-
authors = ["Yehuda Katz <[email protected]>", "Sophia Turner <[email protected]>"]
182-
description = "A shell for the GitHub era"
183-
license = "MIT"
178+
open Cargo.toml --raw
179+
# => [package] name = "nu"
180+
# => version = "0.1.3"
181+
# => authors = ["Yehuda Katz <[email protected]>", "Sophia Turner <[email protected]>"]
182+
# => description = "A shell for the GitHub era"
183+
# => license = "MIT"
184184
```
185185

186186
## Abrindo URLs
187187

188188
Além de carregar dados a partir do sistema de arquivos, você também pode passar uma URL para o comando `open`. Ele trará da internet o conteúdo dessa URL e o retornará para você:
189189

190190
```nu
191-
> open https://www.jonathanturner.org/feed.xml
192-
----------
193-
rss
194-
----------
195-
[1 item]
196-
----------
191+
open https://www.jonathanturner.org/feed.xml
192+
# => ----------
193+
# => rss
194+
# => ----------
195+
# => [1 item]
196+
# => ----------
197197
```

‎pt-BR/book/escapando.md‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,11 @@ O Nu fornece um conjunto de comandos que você pode usar entre diferentes SOs e
55
Comando Nu:
66

77
```nu
8-
> ls
8+
ls
99
```
1010

1111
Escapando para o comando local:
1212

1313
```nu
14-
> ^ls
14+
^ls
1515
```

‎pt-BR/book/explorando.md‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -11,38 +11,38 @@ Como vimos em outros capítulos, `ls` é um comando para visualizar o conteúdo
1111
O comando `ls` também recebe um parâmetro opcional para mudar o que você gostaria de ver. Por exemplo, podemos listar os arquivos cujo nome termina em ".txt".
1212

1313
```nu
14-
> ls *.txt
15-
---+--------------+------+----------+---------+--------------+--------------
16-
# | name | type | readonly | size | accessed | modified
17-
---+--------------+------+----------+---------+--------------+--------------
18-
0 | history.txt | File | | 1.3 KB | 2 months ago | a day ago
19-
1 | readonly.txt | File | readonly | <empty> | 2 months ago | 2 months ago
20-
---+--------------+------+----------+---------+--------------+--------------
14+
ls *.txt
15+
# => ---+--------------+------+----------+---------+--------------+--------------
16+
# => # | name | type | readonly | size | accessed | modified
17+
# => ---+--------------+------+----------+---------+--------------+--------------
18+
# => 0 | history.txt | File | | 1.3 KB | 2 months ago | a day ago
19+
# => 1 | readonly.txt | File | readonly | <empty> | 2 months ago | 2 months ago
20+
# => ---+--------------+------+----------+---------+--------------+--------------
2121
```
2222

2323
O asterisco (\*) usado no parâmetro opcional acima "\*.txt" é chamado de coringa. Ele faz uma correspondência com qualquer coisa. Você pode ler o coringa "\*.txt" como "aceite qualquer nome de arquivo, desde que termine com '.txt'".
2424

2525
Nu também usa coringas modernos, que permitem acesso a diretórios mais profundos.
2626

2727
```nu
28-
> ls **/*.rs
29-
-----+-----------------------------------------------------+------+----------+----------+----------------+----------------
30-
# | name | type | readonly | size | accessed | modified
31-
-----+-----------------------------------------------------+------+----------+----------+----------------+----------------
32-
0 | src/cli.rs | File | | 19.1 KB | 15 hours ago | 15 hours ago
33-
1 | src/commands/args.rs | File | | 244 B | 2 months ago | 2 months ago
34-
2 | src/commands/autoview.rs | File | | 2.5 KB | 15 hours ago | 15 hours ago
35-
3 | src/commands/cd.rs | File | | 277 B | a week ago | a week ago
36-
4 | src/commands/classified.rs | File | | 13.5 KB | 15 hours ago | 15 hours ago
37-
5 | src/commands/clip.rs | File | | 2.0 KB | 2 days ago | 2 days ago
28+
ls **/*.rs
29+
# => -----+-----------------------------------------------------+------+----------+----------+----------------+----------------
30+
# => # | name | type | readonly | size | accessed | modified
31+
# => -----+-----------------------------------------------------+------+----------+----------+----------------+----------------
32+
# => 0 | src/cli.rs | File | | 19.1 KB | 15 hours ago | 15 hours ago
33+
# => 1 | src/commands/args.rs | File | | 244 B | 2 months ago | 2 months ago
34+
# => 2 | src/commands/autoview.rs | File | | 2.5 KB | 15 hours ago | 15 hours ago
35+
# => 3 | src/commands/cd.rs | File | | 277 B | a week ago | a week ago
36+
# => 4 | src/commands/classified.rs | File | | 13.5 KB | 15 hours ago | 15 hours ago
37+
# => 5 | src/commands/clip.rs | File | | 2.0 KB | 2 days ago | 2 days ago
3838
```
3939

4040
Aqui estamos procurando qualquer arquivo cujo nome termine com ".rs" e os dois asteriscos dizem ainda "em qualquer diretório começando a partir daqui".
4141

4242
## Mudando o diretório atual
4343

4444
```nu
45-
> cd new_directory
45+
cd new_directory
4646
```
4747

4848
Para mudar do diretório atual para um outro, usamos o comando `cd`. Assim como em outros shells, podemos usar o nome do diretório ou, se quisermos ir para um diretório acima, podemos usar o atalho `..`.
@@ -54,25 +54,25 @@ Nu também fornece alguns comandos básicos de sistemas de arquivos que funciona
5454
Podemos mover um item de um lugar para outro usando o comando `mv`.
5555

5656
```nu
57-
> mv item location
57+
mv item location
5858
```
5959

6060
Podemos copiar um item de um local para outro:
6161

6262
```nu
63-
> cp item location
63+
cp item location
6464
```
6565

6666
Podemos remover um item:
6767

6868
```nu
69-
> rm item
69+
rm item
7070
```
7171

7272
Os três comandos também podem usar os coringas que vimos anteriormente com `ls`.
7373

7474
Por fim, podemos criar um novo diretório usando o comando `mkdir`:
7575

7676
```nu
77-
> mkdir new_directory
77+
mkdir new_directory
7878
```

0 commit comments

Comments
 (0)