diff --git a/es/book/shells_en_shells.md b/es/book/shells_en_shells.md deleted file mode 100644 index 1491eb39a74..00000000000 --- a/es/book/shells_en_shells.md +++ /dev/null @@ -1,158 +0,0 @@ -# Shells en shells - -## Trabajando con múltiples directorios - -Mientras es común trabajar en un directorio puede ser beneficioso trabajar en múltiples lugares al mismo tiempo. Para esto Nu ofrece el concepto de "shells". Tal como implica, son una manera de tener activo múltiples shells en uno permitiendote rápidamente saltar entre directorios de trabajo y más. - -Para empezar entremos a un directorio: - -``` -/home/sophia/Source/nushell(master)> enter ../lark -/home/sophia/Source/lark(master)> ls -----+----------------+-----------+----------+---------+---------------+--------------- - # | name | type | readonly | size | accessed | modified -----+----------------+-----------+----------+---------+---------------+--------------- - 0 | Cargo.toml | File | | 2.2 KB | 6 months ago | 6 months ago - 1 | target | Directory | | 4.1 KB | 10 months ago | 6 months ago - 2 | notes | Directory | | 4.1 KB | 10 months ago | 6 months ago -``` - -Entrar es similar a cambiar directorios (como vimos previamente con el comando `cd`). Esto permite saltar al directorio para trabajar dentro del mismo. En lugar de cambiar de directorio, ahora estamos en dos directorios. Para ver esto con más claridad podemos usar el comando `shells` que enumera los directorios actualmente activos: - -``` -/home/sophia/Source/lark(master)> shells ----+---+------------+----------------------------- - # | | name | path ----+---+------------+----------------------------- - 0 | | filesystem | /home/sophia/Source/nushell - 1 | X | filesystem | /home/sophia/Source/lark ----+---+------------+----------------------------- -``` - -El comando `shells` nos muestra que hay dos shells activos: nuestro directorio fuente original "nushell" y ahora este nuevo directorio "lark". - -Podemos saltar entre estas shells con los accesos directos `n` y `p`, cortos de siguiente "next" y previo "previous": - -``` -/home/sophia/Source/lark(master)> n -/home/sophia/Source/nushell(master)> p -/home/sophia/Source/lark(master)> -``` - -Podemos notar el directorio cambiando pero también siempre podremos regresar al directorio previo en el cual estábamos trabajando. Esto nos permite trabajar en múltiples directorio en la misma sesión. - -## Saliendo del shell - -Puedes salir de una shell que hayas entrado (usando `enter`) a través del comando `exit`. Si esta es la última shell, Nu se cerrará. - -Siempre puedes cerrar Nu incluso si tienes múltiples shells activas usando el comando `exit` pasando la bandera `--now` de la siguiente forma `exit --now` - -## Más allá de los directorios - -Nu también puede crear shells de otras cosas aparte de las rutas del sistema de archivos. Digamos por ejemplo que estás trabajando con un gran conjunto de datos y no deseas perderte dentro del mismo. - -Para ver cómo funciona haremos el siguiente ejercicio. Actualmente en Nu tenemos enumerados los [complementos](plugins.md) desarrollados (plugins) en "Cargo.toml" digamos que también acabamos de crear un nuevo complemento en el directorio src/plugins llamado "doc.rs" y nos interesa saber que se encuentre enumerado también en "Cargo.toml" para que se instale al compilar Nu. - -Entraremos al archivo "Cargo.toml" del código fuente de Nu: - -``` -/Users/andresrobalino/Code/nushell(master)> enter Cargo.toml -/> ls -------------+--------------+------------------+----------+---------- - bin | dependencies | dev-dependencies | lib | package -------------+--------------+------------------+----------+---------- - [11 items] | [object] | [object] | [object] | [object] -------------+--------------+------------------+----------+---------- -``` - -Por el momento solo hemos entrado al archivo y podemos observar en la tabla devuelta por `ls` lo que hay. Si prestas atención hemos entrado a un archivo con formato que reconoce Nu (.toml). Nu también nos proyecta el contenido del archivo en forma de sistema de archivos para explorarlo como si estuvieramos dentro de un sistema de archivos. - -Antes de continuar revisemos las shells activas: - -``` -/> shells ----+---+-------------------------------------------------+------------------------------------ - # | | name | path ----+---+-------------------------------------------------+------------------------------------ - 0 | | filesystem | /Users/andresrobalino/Code/nushell - 1 | X | {/Users/andresrobalino/Code/nushell/Cargo.toml} | / ----+---+-------------------------------------------------+------------------------------------ - -``` - -Observamos que hay dos activas indicándonos que nos encontramos dentro de "Cargo.toml" en la ruta predeterminada "/". Revisemos el listado de nuevo: - -``` -/> ls -------------+--------------+------------------+----------+---------- - bin | dependencies | dev-dependencies | lib | package -------------+--------------+------------------+----------+---------- - [11 items] | [object] | [object] | [object] | [object] -------------+--------------+------------------+----------+---------- -``` - -Puede que los complementos se encuentren en "bin", vamos ahí: - -``` -> cd bin -/bin> ls -----+----------------------+--------------------------- - # | name | path -----+----------------------+--------------------------- - 0 | nu_plugin_inc | src/plugins/inc.rs - 1 | nu_plugin_sum | src/plugins/sum.rs - 2 | nu_plugin_add | src/plugins/add.rs - 3 | nu_plugin_edit | src/plugins/edit.rs - 4 | nu_plugin_str | src/plugins/str.rs - 5 | nu_plugin_skip | src/plugins/skip.rs - 6 | nu_plugin_sys | src/plugins/sys.rs - 7 | nu_plugin_tree | src/plugins/tree.rs - 8 | nu_plugin_binaryview | src/plugins/binaryview.rs - 9 | nu_plugin_textview | src/plugins/textview.rs - 10 | nu | src/main.rs -----+----------------------+--------------------------- -``` - -Notar que siempre podemos saltar de vuelta al directorio en el que estuvimos trabajando usando `p` (para previo). - -``` -/bin> p -``` - -Verifiquemos las shells: - -``` -/Users/andresrobalino/Code/nushell(master)> shells ----+---+-------------------------------------------------+------------------------------------ - # | | name | path ----+---+-------------------------------------------------+------------------------------------ - 0 | X | filesystem | /Users/andresrobalino/Code/nushell - 1 | | {/Users/andresrobalino/Code/nushell/Cargo.toml} | /bin ----+---+-------------------------------------------------+------------------------------------ - -``` - -Nos encontramos ahora en la shell donde estuvimos antes de entrar al archivo "Cargo.toml", vamos al directorio donde se encuentra el código fuente de los complementos (plugins): - -``` -/Users/andresrobalino/Code/nushell(master)> cd src/plugins/ -/Users/andresrobalino/Code/nushell/src/plugins(master)> ls -----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified -----+---------------+------+----------+---------+------------+------------ - 0 | doc.rs | File | | 3.0 KB | a week ago | a week ago - 1 | sum.rs | File | | 3.0 KB | a week ago | a week ago - 2 | inc.rs | File | | 11.8 KB | a week ago | a week ago - 3 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 4 | edit.rs | File | | 2.7 KB | a week ago | a week ago - 5 | str.rs | File | | 21.4 KB | 5 days ago | 5 days ago - 6 | secret.rs | File | | 1.8 KB | 2 days ago | 2 days ago - 7 | skip.rs | File | | 1.7 KB | a week ago | a week ago - 8 | binaryview.rs | File | | 13.0 KB | a week ago | a week ago - 9 | tree.rs | File | | 3.0 KB | a week ago | a week ago - 10 | add.rs | File | | 2.7 KB | a week ago | a week ago - 11 | textview.rs | File | | 9.4 KB | 5 days ago | 5 days ago -----+---------------+------+----------+---------+------------+------------ -``` - -Ahora podemos comparar los dos para verificar si faltan complementos adicionales o si hay complementos adicionales que necesitemos agregar a nuestro archivo "Cargo.toml" (¡y claramente falta agregarlo a "Cargo.toml"!) diff --git a/ja/book/aliases.md b/ja/book/aliases.md index 26295b21d0f..d454e38f26b 100644 --- a/ja/book/aliases.md +++ b/ja/book/aliases.md @@ -9,16 +9,16 @@ Nu ではパイプラインを利用して自由にデータやシステムを 例: ``` -> alias ls-names [] { ls | select name } -> ls-names -────┬──────────────────── - # │ name -────┼──────────────────── - 0 │ 404.html - 1 │ CONTRIBUTING.md - 2 │ Gemfile - 3 │ Gemfile.lock - 4 │ LICENSE +alias ls-names [] { ls | select name } +ls-names +# => ────┬──────────────────── +# => # │ name +# => ────┼──────────────────── +# => 0 │ 404.html +# => 1 │ CONTRIBUTING.md +# => 2 │ Gemfile +# => 3 │ Gemfile.lock +# => 4 │ LICENSE ``` ## パラメータ @@ -26,9 +26,9 @@ Nu ではパイプラインを利用して自由にデータやシステムを エイリアスは、ブロックに渡されるオプションのパラメータをもつことができます。これらはブロック内の新しい変数になります。 ``` -> alias e [msg] { echo $msg } -> e "hello world" -hello world +alias e [msg] { echo $msg } +e "hello world" +# => hello world ``` パラメータは任意の数設定することができ、ユーザが値を提供しなかった場合、ブロック内では Nothing と評価されて削除されます。 diff --git a/ja/book/configuration.md b/ja/book/configuration.md index ba90ab425ef..8c5d37e17b8 100644 --- a/ja/book/configuration.md +++ b/ja/book/configuration.md @@ -26,7 +26,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が これらの変数のいずれかを設定するには`config set` コマンドを利用します。例えば ``` -> config set edit_mode "vi" +config set edit_mode "vi" ``` ### パイプラインからの変数を設定 @@ -34,7 +34,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が 設定したい値をパイプラインを通じて設定することもできます。このためには`set_into`フラグを利用します。 ``` -> echo "bar" | config set_into foo +echo "bar" | config set_into foo ``` この方法は、`env`や`path`変数を設定する際に便利です。 @@ -44,13 +44,13 @@ Nu には、見た目や挙動を変更させるための内部的な変数が `config`コマンドを引数なしで実行すると現在の設定されている変数を表示します。 ``` -> config -─────────────────┬────────────────── - completion_mode │ circular - env │ [row 51 columns] - path │ [table 9 rows] - startup │ [table 1 rows] -─────────────────┴────────────────── +config +# => ─────────────────┬────────────────── +# => completion_mode │ circular +# => env │ [row 51 columns] +# => path │ [table 9 rows] +# => startup │ [table 1 rows] +# => ─────────────────┴────────────────── ``` 注: もしまだ変数を設定していない場合、出力が空の場合があります。 @@ -60,7 +60,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が `get`フラグを利用して特定の変数の値を取得できます。 ``` -> config get edit_mode +config get edit_mode ``` ### 変数の削除 @@ -68,7 +68,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が 変数を削除する場合、`remove`フラグを利用します。 ``` -> config remove edit_mode +config remove edit_mode ``` ### 設定全体のクリア @@ -76,7 +76,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が 設定全体をクリアして、最初からやりなおしたい場合は`--clear`フラグを利用できます。このコマンドを実行すると設定ファイルもクリアされるので注意してください。 ``` -> config clear +config clear ``` ### 設定が保存されている場所をみつける @@ -84,8 +84,8 @@ Nu には、見た目や挙動を変更させるための内部的な変数が 設定ファイルはデフォルトの場所から読み込まれます。この場所をみつけるには`-path`フラグを利用します。 ``` -> config path -/home/jonathant/.config/nu/config.toml +config path +# => /home/jonathant/.config/nu/config.toml ``` ### ファイルから設定を読み込む @@ -93,7 +93,7 @@ Nu には、見た目や挙動を変更させるための内部的な変数が デフォルトとは違う設定ファイルを読み込みたい場合は、`load` パラメーターを利用します。 ``` -> config load myconfiguration.toml +config load myconfiguration.toml ``` ## Nu をログインシェルとして設定する @@ -103,15 +103,15 @@ Nu をログインシェルとして利用するには、`path`と`env`変数を 切り替える前に、Bash 等の別のシェルから Nu を実行します。そして次のコマンドで環境変数と PATH をシェルから取得します。 ``` -> config set path $nu.path -> config set env $nu.env +config set path $nu.path +config set env $nu.env ``` 0.7.2 より以前のバージョンでは ``` -> config --set [path $nu:path] -> config --set [env $nu:env] +config --set [path $nu:path] +config --set [env $nu:env] ``` `$nu.path`および`$nu.env`にはそれぞれ、現在の PATH と環境変数がセットされています。これらをセットすると、のちに Nu をログインシェルとして利用したさいに利用できるようになります。 @@ -119,15 +119,15 @@ Nu をログインシェルとして利用するには、`path`と`env`変数を 次にいくつかのディストリビューションでは、Nu が`/etc/shells`のリストに含まれているかを確認する必要があります。 ``` -❯ cat /etc/shells -# /etc/shells: valid login shells -/bin/sh -/bin/dash -/bin/bash -/bin/rbash -/usr/bin/screen -/usr/bin/fish -/home/sophia/.cargo/bin/nu +cat /etc/shells +# => # /etc/shells: valid login shells +# => /bin/sh +# => /bin/dash +# => /bin/bash +# => /bin/rbash +# => /usr/bin/screen +# => /usr/bin/fish +# => /home/sophia/.cargo/bin/nu ``` これにより、`chsh`で Nu をログインシェルとして設定できるようになります。ログアウト後、次回のログイン時に Nu の素敵なプロンプトが表示されます。 diff --git a/ja/book/environment.md b/ja/book/environment.md index 8c64cd4aeb1..75e69790e11 100644 --- a/ja/book/environment.md +++ b/ja/book/environment.md @@ -5,12 +5,12 @@ アプリケーションに送られる現在の環境変数は`$nu.env`の値を echo して確認することができます。 ``` -> echo $nu.env -──────────────────────────┬────────────────────────────── - COLORTERM │ truecolor - DBUS_SESSION_BUS_ADDRESS │ unix:path=/run/user/1000/bus - DESKTOP_SESSION │ gnome - DISPLAY │ :1 +echo $nu.env +# => ──────────────────────────┬────────────────────────────── +# => COLORTERM │ truecolor +# => DBUS_SESSION_BUS_ADDRESS │ unix:path=/run/user/1000/bus +# => DESKTOP_SESSION │ gnome +# => DISPLAY │ :1 ``` 環境は Nu の設定と Nu が実行されている環境から作られます。[設定の章](configuration.md)に記載されている方法で環境を恒久的に更新できます。 @@ -18,8 +18,8 @@ コマンドやパイプラインを実行するときに一時的に環境変数を更新することもできます。 ``` -> with-env [FOO BAR] { echo $nu.env.FOO } -BAR +with-env [FOO BAR] { echo $nu.env.FOO } +# => BAR ``` `with-env`コマンドは、環境変数を一時的に与えられた値に設定します(ここでは変数"FOO"に"BAR"という値がセットされます)。ブロックは新しい環境変数が設定された状態で実行されます。 @@ -27,6 +27,6 @@ BAR Bash などにヒントを得た一般的な省略記法も用意されています。上の例は次のように書くことができます。 ``` -> FOO=BAR echo $nu.env.FOO -BAR +# => FOO=BAR echo $nu.env.FOO +# => BAR ``` diff --git a/ja/book/escaping.md b/ja/book/escaping.md index ed41126ac3c..1f9c57217a2 100644 --- a/ja/book/escaping.md +++ b/ja/book/escaping.md @@ -5,11 +5,11 @@ Nu は様々な OS で使用できる一連のコマンドを提供します。 Nu のコマンド: ``` -> ls +ls ``` ローカルコマンドへのエスケープ: ``` -> ^ls +^ls ``` diff --git a/ja/book/loading_data.md b/ja/book/loading_data.md index 2ff21311c2e..4987283f6b4 100644 --- a/ja/book/loading_data.md +++ b/ja/book/loading_data.md @@ -13,8 +13,8 @@ プロジェクトのバージョンを確認したい場合は、`get`コマンドを利用します。 ``` -> open editors/vscode/package.json | get version -1.0.0 +open editors/vscode/package.json | get version +# => 1.0.0 ``` Nu が現在、直接データをテーブルに読み込める形式は次の通りです。 @@ -29,7 +29,7 @@ Nu が現在、直接データをテーブルに読み込める形式は次の しかし、これらのいずれでもないテキストファイルを読み込むとどうなるでしょうか、試してみましょう。 ``` -> open README.md +open README.md ``` ファイルの内容が表示されます。ファイルが大きすぎる場合は、便利なスクロールビューでファイルの中身を確認してからターミナルに戻ってくることができます。読みやすさのために、ソースファイルやマークダウンといった一般的なファイル形式ではシンタックスハイライトを提供します。 @@ -43,10 +43,10 @@ Nu の外からきたデータを Nu がいつも理解できるとは限らな 以下のファイルが与えられたと想定してみましょう。 ``` -> open people.txt -Octavia | Butler | Writer -Bob | Ross | Painter -Antonio | Vivaldi | Composer +open people.txt +# => Octavia | Butler | Writer +# => Bob | Ross | Painter +# => Antonio | Vivaldi | Composer ``` 必要なデータはパイプ('|')記号で区切られており、各行はそれぞれの人物を表しています。Nu はデフォルトではパイプで区切られたファイル形式を知らないので、明示的にこのファイルをパースする必要があります。 @@ -54,75 +54,75 @@ Antonio | Vivaldi | Composer ファイルを読み込むときに最初に行うことは、１行ずつ作業することです。 ``` -> open people.txt | lines -───┬────────────────────────────── - 0 │ Octavia | Butler | Writer - 1 │ Bob | Ross | Painter - 2 │ Antonio | Vivaldi | Composer -───┴────────────────────────────── +open people.txt | lines +# => ───┬────────────────────────────── +# => 0 │ Octavia | Butler | Writer +# => 1 │ Bob | Ross | Painter +# => 2 │ Antonio | Vivaldi | Composer +# => ───┴────────────────────────────── ``` テーブルにもどってきたので、行を使って作業していることがわかります。次のステップは、行をもうすこし便利なものに分割できるかみてみることです。そのために、`split`コマンドを利用します。名前からわかるように、`split`は区切り文字を含む文字列を列に分割する方法を提供します。`split`の`column`サブコマンドを使って、複数の列に分割するします。必要なのは区切り文字を指定することだけです。 ``` -> open people.txt | lines | split column "|" -───┬──────────┬───────────┬─────────── - # │ Column1 │ Column2 │ Column3 -───┼──────────┼───────────┼─────────── - 0 │ Octavia │ Butler │ Writer - 1 │ Bob │ Ross │ Painter - 2 │ Antonio │ Vivaldi │ Composer -───┴──────────┴───────────┴─────────── +open people.txt | lines | split column "|" +# => ───┬──────────┬───────────┬─────────── +# => # │ Column1 │ Column2 │ Column3 +# => ───┼──────────┼───────────┼─────────── +# => 0 │ Octavia │ Butler │ Writer +# => 1 │ Bob │ Ross │ Painter +# => 2 │ Antonio │ Vivaldi │ Composer +# => ───┴──────────┴───────────┴─────────── ``` ほとんど正しいように見えますが、余分なスペースを含んでいます。余分なスペースを`trim`してみましょう。 ``` -> open people.txt | lines | split column "|" | str trim -───┬─────────┬─────────┬────────── - # │ Column1 │ Column2 │ Column3 -───┼─────────┼─────────┼────────── - 0 │ Octavia │ Butler │ Writer - 1 │ Bob │ Ross │ Painter - 2 │ Antonio │ Vivaldi │ Composer -───┴─────────┴─────────┴────────── +open people.txt | lines | split column "|" | str trim +# => ───┬─────────┬─────────┬────────── +# => # │ Column1 │ Column2 │ Column3 +# => ───┼─────────┼─────────┼────────── +# => 0 │ Octavia │ Butler │ Writer +# => 1 │ Bob │ Ross │ Painter +# => 2 │ Antonio │ Vivaldi │ Composer +# => ───┴─────────┴─────────┴────────── ``` 悪くありません。`split`コマンドは利用可能なデータとデフォルトのカラム名をつけてくれます。 ``` -> open people.txt | lines | split column "|" | str trim | get Column1 -───┬───────── - 0 │ Octavia - 1 │ Bob - 2 │ Antonio -───┴───────── +open people.txt | lines | split column "|" | str trim | get Column1 +# => ───┬───────── +# => 0 │ Octavia +# => 1 │ Bob +# => 2 │ Antonio +# => ───┴───────── ``` デフォルトの名前を利用するかわりに、列に名前をつけることもできます。 ``` -> open people.txt | lines | split column "|" first_name last_name job | str trim -───┬────────────┬───────────┬────────── - # │ first_name │ last_name │ job -───┼────────────┼───────────┼────────── - 0 │ Octavia │ Butler │ Writer - 1 │ Bob │ Ross │ Painter - 2 │ Antonio │ Vivaldi │ Composer -───┴────────────┴───────────┴────────── +open people.txt | lines | split column "|" first_name last_name job | str trim +# => ───┬────────────┬───────────┬────────── +# => # │ first_name │ last_name │ job +# => ───┼────────────┼───────────┼────────── +# => 0 │ Octavia │ Butler │ Writer +# => 1 │ Bob │ Ross │ Painter +# => 2 │ Antonio │ Vivaldi │ Composer +# => ───┴────────────┴───────────┴────────── ``` データをテーブルに変換できたので、これまでテーブルに利用してきたすべてのコマンドをつかうことができます。 ``` -> open people.txt | lines | split column "|" first_name last_name job | str trim | sort-by first_name -───┬────────────┬───────────┬────────── - # │ first_name │ last_name │ job -───┼────────────┼───────────┼────────── - 0 │ Antonio │ Vivaldi │ Composer - 1 │ Bob │ Ross │ Painter - 2 │ Octavia │ Butler │ Writer -───┴────────────┴───────────┴────────── +open people.txt | lines | split column "|" first_name last_name job | str trim | sort-by first_name +# => ───┬────────────┬───────────┬────────── +# => # │ first_name │ last_name │ job +# => ───┼────────────┼───────────┼────────── +# => 0 │ Antonio │ Vivaldi │ Composer +# => 1 │ Bob │ Ross │ Painter +# => 2 │ Octavia │ Butler │ Writer +# => ───┴────────────┴───────────┴────────── ``` 文字列を操作するために使用できるその他のコマンドです。 @@ -134,12 +134,12 @@ Antonio | Vivaldi | Composer データが Nu が理解できる構造をもっていることがわかっている場合に呼び出すことのできるヘルパーコマンドのセットもあります。例えば、Rust のロックファイルを開いてみましょう。 ``` -> open Cargo.lock -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -[[package]] -name = "adhoc_derive" -version = "0.1.2" +open Cargo.lock +# => # This file is automatically @generated by Cargo. +# => # It is not intended for manual editing. +# => [[package]] +# => name = "adhoc_derive" +# => version = "0.1.2" ``` "Cargo.lock"ファイルは実際には.toml ファイルですが、ファイル拡張子が.toml ではありません。でも大丈夫です、`from toml`コマンドが使えます。 @@ -153,12 +153,13 @@ version = "0.1.2" ファイルを開いてそのデータのテーブルをすぐに操作できると便利ですが、これは必ずしもやりたいことであるとは限りません。テキストをそのまま取得するために、`open`コマンドに`--raw`オプションフラグを渡すことができます。 ``` -> open Cargo.toml --raw -[package] name = "nu" -version = "0.1.3" -authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] -description = "A shell for the GitHub era" -license = "MIT" +open Cargo.toml --raw +# => [package] +# => name = "nu" +# => version = "0.1.3" +# => authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] +# => description = "A shell for the GitHub era" +# => license = "MIT" ``` ## URL からの取得 diff --git a/ja/book/math.md b/ja/book/math.md index 1db1c656e61..d7644213424 100644 --- a/ja/book/math.md +++ b/ja/book/math.md @@ -7,8 +7,8 @@ ## 四則演算 ``` -> = 1 + 3 -4 += 1 + 3 +# => 4 ``` Nu では足し算、引き算、掛け算、割り算をそれぞれ`+`,`-`,`*`そして`/`演算子でおこなうことができます。演算子の優先順位が考慮されるので`1 + 2 * 3`は`1 + (2 * 3)`として扱われます。 @@ -22,13 +22,13 @@ math mode では括弧を利用して数式をグループ化できます。こ `in`と`not-in`演算子を使って、値が集合に含まれるかどうかを調べることができます。 ``` -> = 1 in [1 2 3] -true += 1 in [1 2 3] +# => true ``` ``` -> = 1 not-in [1 2 3] -false += 1 not-in [1 2 3] +# => false ``` ## `=~`と`!~` @@ -36,13 +36,13 @@ false `=~`と`!~`演算子を使って文字列が他の文字列の中にあるかどうかを調べることができます。 ``` -> = "foobar" =~ "foo" -true += "foobar" =~ "foo" +# => true ``` ``` -> = "foobar" !~ "baz" -true += "foobar" !~ "baz" +# => true ``` ## 比較演算子 diff --git a/ja/book/metadata.md b/ja/book/metadata.md index 6dbe823bff3..26d0149d5d9 100644 --- a/ja/book/metadata.md +++ b/ja/book/metadata.md @@ -3,14 +3,14 @@ Nu を使用していると裏でなにか特別なことがおきているのではないかと思うことがあるでしょう。例えば、Nu がサポートしているファイル形式を忘れていて、余計に変換しようとしてしまったとしましょう。 ``` -> open Cargo.toml | from toml -error: Expected a string from pipeline -- shell:1:18 -1 | open Cargo.toml | from toml - | ^^^^^^^^^ requires string input -- shell:1:5 -1 | open Cargo.toml | from toml - | ---------- object originates from here +open Cargo.toml | from toml +# => error: Expected a string from pipeline +# => - shell:1:18 +# => 1 | open Cargo.toml | from toml +# => | ^^^^^^^^^ requires string input +# => - shell:1:5 +# => 1 | open Cargo.toml | from toml +# => | ---------- object originates from here ``` エラーメッセージは、`from toml`に渡したものが文字列ではなかったことだけではなく、元の値がどこから来たかも示しています。どうやってこれを知るのでしょうか。 @@ -20,11 +20,11 @@ Nu のパイプラインを流れる値には、多くの場合、メタデー もう一度`open`コマンドを実行してみましょう、ただし今回は、返されるタグを確認します。 ``` -> open Cargo.toml | tags -────────┬─────────────────────────────────────────── - span │ [row end start] - anchor │ /home/jonathant/Source/nushell/Cargo.toml -────────┴─────────────────────────────────────────── +open Cargo.toml | tags +# => ────────┬─────────────────────────────────────────── +# => span │ [row end start] +# => anchor │ /home/jonathant/Source/nushell/Cargo.toml +# => ────────┴─────────────────────────────────────────── ``` 現在、パイプライン上の値について２つのメタデータを追跡しています。このデータがどこから読み込まれたかをしめす anchor があることに気づくでしょう。これにより Nu はデータの表示方法をよりよく理解できるのです。 @@ -32,11 +32,11 @@ Nu のパイプラインを流れる値には、多くの場合、メタデー 今度は span をみてみましょう。 ``` -> open Cargo.toml | tags | get span -───────┬──── - start │ 5 - end │ 15 -───────┴──── +open Cargo.toml | tags | get span +# => ───────┬──── +# => start │ 5 +# => end │ 15 +# => ───────┴──── ``` ここでの"start"と"end"の span は下線が行のどこにあるのかを示しています。5 から 15 まで数えてみるとそれが"Cargo.toml"ファイル名と一致することがわかるでしょう。このようにして、さきほどみたエラーはどこに下線をひくべきかをしったのです。 diff --git a/ja/book/types_of_data.md b/ja/book/types_of_data.md index 47932ce3844..ab93ee818f6 100644 --- a/ja/book/types_of_data.md +++ b/ja/book/types_of_data.md @@ -96,12 +96,12 @@ row データ型は表の１行のデータで見えるものを表していま Lists は一つ以上の値を保持できます。単純な値だけでなく、rows も保持することができます。rows の lists はしばしばテーブルと呼ばれます。 ``` -> echo [sam fred george] -───┬──────── - 0 │ sam - 1 │ fred - 2 │ george -───┴──────── +echo [sam fred george] +# => ───┬──────── +# => 0 │ sam +# => 1 │ fred +# => 2 │ george +# => ───┴──────── ``` ### Blocks diff --git a/ja/book/working_with_tables.md b/ja/book/working_with_tables.md index effe6ef2d63..7623e9cb788 100644 --- a/ja/book/working_with_tables.md +++ b/ja/book/working_with_tables.md @@ -5,18 +5,18 @@ Nu でデータを表示する一般的な方法はテーブルを使用する まずはじめに、今回利用するテーブルを確認しましょう。 ``` -> ls -───┬───────────────┬──────┬─────────┬──────────── - # │ name │ type │ size │ modified -───┼───────────────┼──────┼─────────┼──────────── - 0 │ files.rs │ File │ 4.6 KB │ 5 days ago - 1 │ lib.rs │ File │ 330 B │ 5 days ago - 2 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago - 3 │ parse.rs │ File │ 49.8 KB │ 1 day ago - 4 │ path.rs │ File │ 2.1 KB │ 5 days ago - 5 │ shapes.rs │ File │ 4.7 KB │ 5 days ago - 6 │ signature.rs │ File │ 1.2 KB │ 5 days ago -───┴───────────────┴──────┴─────────┴──────────── +ls +# => ───┬───────────────┬──────┬─────────┬──────────── +# => # │ name │ type │ size │ modified +# => ───┼───────────────┼──────┼─────────┼──────────── +# => 0 │ files.rs │ File │ 4.6 KB │ 5 days ago +# => 1 │ lib.rs │ File │ 330 B │ 5 days ago +# => 2 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago +# => 3 │ parse.rs │ File │ 49.8 KB │ 1 day ago +# => 4 │ path.rs │ File │ 2.1 KB │ 5 days ago +# => 5 │ shapes.rs │ File │ 4.7 KB │ 5 days ago +# => 6 │ signature.rs │ File │ 1.2 KB │ 5 days ago +# => ───┴───────────────┴──────┴─────────┴──────────── ``` ## データのソート @@ -24,18 +24,18 @@ Nu でデータを表示する一般的な方法はテーブルを使用する ソートに利用する列名を指定して、`sort-by`コマンドを呼びだすことでテーブルをソートできます。ファイルのサイズでテーブルをソートしたいとしましょう。 ``` -> ls | sort-by size -───┬───────────────┬──────┬─────────┬──────────── - # │ name │ type │ size │ modified -───┼───────────────┼──────┼─────────┼──────────── - 0 │ lib.rs │ File │ 330 B │ 5 days ago - 1 │ signature.rs │ File │ 1.2 KB │ 5 days ago - 2 │ path.rs │ File │ 2.1 KB │ 5 days ago - 3 │ files.rs │ File │ 4.6 KB │ 5 days ago - 4 │ shapes.rs │ File │ 4.7 KB │ 5 days ago - 5 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago - 6 │ parse.rs │ File │ 49.8 KB │ 1 day ago -───┴───────────────┴──────┴─────────┴──────────── +ls | sort-by size +# => ───┬───────────────┬──────┬─────────┬──────────── +# => # │ name │ type │ size │ modified +# => ───┼───────────────┼──────┼─────────┼──────────── +# => 0 │ lib.rs │ File │ 330 B │ 5 days ago +# => 1 │ signature.rs │ File │ 1.2 KB │ 5 days ago +# => 2 │ path.rs │ File │ 2.1 KB │ 5 days ago +# => 3 │ files.rs │ File │ 4.6 KB │ 5 days ago +# => 4 │ shapes.rs │ File │ 4.7 KB │ 5 days ago +# => 5 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago +# => 6 │ parse.rs │ File │ 49.8 KB │ 1 day ago +# => ───┴───────────────┴──────┴─────────┴──────────── ``` 比較さえできれば任意の列でソートが行なえます。例えば、"name"、"accessed"、または"modified"列でソートすることができます。 @@ -45,33 +45,33 @@ Nu でデータを表示する一般的な方法はテーブルを使用する 列や行を選択することでテーブルから必要なデータを選択できます。テーブルからいくつかの列を選択してみましょう。 ``` -> ls | select name size -───┬───────────────┬───────── - # │ name │ size -───┼───────────────┼───────── - 0 │ files.rs │ 4.6 KB - 1 │ lib.rs │ 330 B - 2 │ lite_parse.rs │ 6.3 KB - 3 │ parse.rs │ 49.8 KB - 4 │ path.rs │ 2.1 KB - 5 │ shapes.rs │ 4.7 KB - 6 │ signature.rs │ 1.2 KB -───┴───────────────┴───────── +ls | select name size +# => ───┬───────────────┬───────── +# => # │ name │ size +# => ───┼───────────────┼───────── +# => 0 │ files.rs │ 4.6 KB +# => 1 │ lib.rs │ 330 B +# => 2 │ lite_parse.rs │ 6.3 KB +# => 3 │ parse.rs │ 49.8 KB +# => 4 │ path.rs │ 2.1 KB +# => 5 │ shapes.rs │ 4.7 KB +# => 6 │ signature.rs │ 1.2 KB +# => ───┴───────────────┴───────── ``` こうすることで、より必要とするデータにフォーカスしたテーブルを作ることができます。次にディレクトリからもっとも小さい 5 つのファイルを表示してみます。 ``` -> ls | sort-by size | first 5 -───┬──────────────┬──────┬────────┬──────────── - # │ name │ type │ size │ modified -───┼──────────────┼──────┼────────┼──────────── - 0 │ lib.rs │ File │ 330 B │ 5 days ago - 1 │ signature.rs │ File │ 1.2 KB │ 5 days ago - 2 │ path.rs │ File │ 2.1 KB │ 5 days ago - 3 │ files.rs │ File │ 4.6 KB │ 5 days ago - 4 │ shapes.rs │ File │ 4.7 KB │ 5 days ago -───┴──────────────┴──────┴────────┴──────────── +ls | sort-by size | first 5 +# => ───┬──────────────┬──────┬────────┬──────────── +# => # │ name │ type │ size │ modified +# => ───┼──────────────┼──────┼────────┼──────────── +# => 0 │ lib.rs │ File │ 330 B │ 5 days ago +# => 1 │ signature.rs │ File │ 1.2 KB │ 5 days ago +# => 2 │ path.rs │ File │ 2.1 KB │ 5 days ago +# => 3 │ files.rs │ File │ 4.6 KB │ 5 days ago +# => 4 │ shapes.rs │ File │ 4.7 KB │ 5 days ago +# => ───┴──────────────┴──────┴────────┴──────────── ``` もっとも小さいファイルを取得するためにまずサイズでソートし、それから`first 5`を利用してテーブルから最初の 5 行を返しています。 @@ -79,14 +79,14 @@ Nu でデータを表示する一般的な方法はテーブルを使用する 不要な行を`skip`することもできます。上記で返された５行のうち最初の２行をスキップしてみましょう。 ``` -> ls | sort-by size | first 5 | skip 2 -───┬───────────┬──────┬────────┬──────────── - # │ name │ type │ size │ modified -───┼───────────┼──────┼────────┼──────────── - 0 │ path.rs │ File │ 2.1 KB │ 5 days ago - 1 │ files.rs │ File │ 4.6 KB │ 5 days ago - 2 │ shapes.rs │ File │ 4.7 KB │ 5 days ago -───┴───────────┴──────┴────────┴──────────── +ls | sort-by size | first 5 | skip 2 +# => ───┬───────────┬──────┬────────┬──────────── +# => # │ name │ type │ size │ modified +# => ───┼───────────┼──────┼────────┼──────────── +# => 0 │ path.rs │ File │ 2.1 KB │ 5 days ago +# => 1 │ files.rs │ File │ 4.6 KB │ 5 days ago +# => 2 │ shapes.rs │ File │ 4.7 KB │ 5 days ago +# => ───┴───────────┴──────┴────────┴──────────── ``` 関心のある３行に絞り込みました。 @@ -94,26 +94,26 @@ Nu でデータを表示する一般的な方法はテーブルを使用する データを選択するための他のコマンドもみてみましょう。テーブルの各行が数字をもつことを疑問に思っているかもしれません。これは単一の行を簡単に指定する方法として機能します。テーブルをファイル名でソートして、`nth`コマンドを利用して n 行目を選択してみましょう。 ``` -> ls | sort-by name -───┬───────────────┬──────┬─────────┬──────────── - # │ name │ type │ size │ modified -───┼───────────────┼──────┼─────────┼──────────── - 0 │ files.rs │ File │ 4.6 KB │ 5 days ago - 1 │ lib.rs │ File │ 330 B │ 5 days ago - 2 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago - 3 │ parse.rs │ File │ 49.8 KB │ 1 day ago - 4 │ path.rs │ File │ 2.1 KB │ 5 days ago - 5 │ shapes.rs │ File │ 4.7 KB │ 5 days ago - 6 │ signature.rs │ File │ 1.2 KB │ 5 days ago +ls | sort-by name +# => ───┬───────────────┬──────┬─────────┬──────────── +# => # │ name │ type │ size │ modified +# => ───┼───────────────┼──────┼─────────┼──────────── +# => 0 │ files.rs │ File │ 4.6 KB │ 5 days ago +# => 1 │ lib.rs │ File │ 330 B │ 5 days ago +# => 2 │ lite_parse.rs │ File │ 6.3 KB │ 5 days ago +# => 3 │ parse.rs │ File │ 49.8 KB │ 1 day ago +# => 4 │ path.rs │ File │ 2.1 KB │ 5 days ago +# => 5 │ shapes.rs │ File │ 4.7 KB │ 5 days ago +# => 6 │ signature.rs │ File │ 1.2 KB │ 5 days ago ───┴───────────────┴──────┴─────────┴──────────── -> ls | sort-by name | nth 5 -──────────┬──────────── - name │ shapes.rs - type │ File - size │ 4.7 KB - modified │ 5 days ago -──────────┴──────────── +ls | sort-by name | nth 5 +# => ──────────┬──────────── +# => name │ shapes.rs +# => type │ File +# => size │ 4.7 KB +# => modified │ 5 days ago +# => ──────────┴──────────── ``` ## テーブルからデータを取得する @@ -121,16 +121,16 @@ Nu でデータを表示する一般的な方法はテーブルを使用する これまでは、テーブルを必要なものだけにトリミングする操作を行ってきました。ときには一歩進んで、列全体ではなく、セル自体の値が必要になるかもしれません。たとえば、ファイル名のリストだけを取得したいとしましょう。この場合`get`コマンドを利用することができます。 ``` -> ls | get name -───┬─────────────── - 0 │ files.rs - 1 │ lib.rs - 2 │ lite_parse.rs - 3 │ parse.rs - 4 │ path.rs - 5 │ shapes.rs - 6 │ signature.rs -───┴─────────────── +ls | get name +# => ───┬─────────────── +# => 0 │ files.rs +# => 1 │ lib.rs +# => 2 │ lite_parse.rs +# => 3 │ parse.rs +# => 4 │ path.rs +# => 5 │ shapes.rs +# => 6 │ signature.rs +# => ───┴─────────────── ``` これで各ファイルの名前が取得できました。 @@ -138,18 +138,18 @@ Nu でデータを表示する一般的な方法はテーブルを使用する これはさきほどみた`select`コマンドと同じにみえるかもしれません、比較のために`select`コマンドの出力もみておきましょう。 ``` -> ls | select name -───┬─────────────── - # │ name -───┼─────────────── - 0 │ files.rs - 1 │ lib.rs - 2 │ lite_parse.rs - 3 │ parse.rs - 4 │ path.rs - 5 │ shapes.rs - 6 │ signature.rs -───┴─────────────── +ls | select name +# => ───┬─────────────── +# => # │ name +# => ───┼─────────────── +# => 0 │ files.rs +# => 1 │ lib.rs +# => 2 │ lite_parse.rs +# => 3 │ parse.rs +# => 4 │ path.rs +# => 5 │ shapes.rs +# => 6 │ signature.rs +# => ───┴─────────────── ``` 両者は非常に似ています！両者の違いを明確にしておきましょう。 @@ -170,40 +170,40 @@ Nu でデータを表示する一般的な方法はテーブルを使用する `add`コマンドを使用して、新しい列をテーブルに追加できます。例をみてみましょう。 ``` -> open rustfmt.toml -─────────┬────── - edition │ 2018 -─────────┴────── +open rustfmt.toml +# => ─────────┬────── +# => edition │ 2018 +# => ─────────┴────── ``` 値が 2021 の"next_edition"列を追加してみましょう。 ``` -> open rustfmt.toml | insert next_edition 2021 -──────────────┬────── - edition │ 2018 - next_edition │ 2021 -──────────────┴────── +open rustfmt.toml | insert next_edition 2021 +# => ──────────────┬────── +# => edition │ 2018 +# => next_edition │ 2021 +# => ──────────────┴────── ``` 元のファイルは変更されていないことに注意してください。 ``` -> open rustfmt.toml -─────────┬────── - edition │ 2018 -─────────┴────── +open rustfmt.toml +# => ─────────┬────── +# => edition │ 2018 +# => ─────────┴────── ``` Nu の変更は永続的な変更ではなく、値自体に作用する関数的な変更です。これにより、結果を書き出す準備ができるまでパイプライン上で様々な種類の作業をおこなうことができます。ここでは、`save`コマンドを使用して結果を書き出すことができます。 ``` -> open rustfmt.toml | insert next_edition 2021 | save rustfmt2.toml -> open rustfmt2.toml -──────────────┬────── - edition │ 2018 - next_edition │ 2021 -──────────────┴────── +open rustfmt.toml | insert next_edition 2021 | save rustfmt2.toml +open rustfmt2.toml +# => ──────────────┬────── +# => edition │ 2018 +# => next_edition │ 2021 +# => ──────────────┴────── ``` ### 列を更新する @@ -211,19 +211,19 @@ Nu の変更は永続的な変更ではなく、値自体に作用する関数 `insert`コマンドと同様に、`update`コマンドを利用して列の内容を新しい値に変更することもできます。実際に動作を確認するために同じファイルを開いてみましょう。 ``` -> open rustfmt.toml -─────────┬────── - edition │ 2018 -─────────┴────── +open rustfmt.toml +# => ─────────┬────── +# => edition │ 2018 +# => ─────────┴────── ``` 今度は、サポートした次の edition を指定するよう更新しましょう。 ``` -> open rustfmt.toml | update edition 2021 -─────────┬────── - edition │ 2021 -─────────┴────── +open rustfmt.toml | update edition 2021 +# => ─────────┬────── +# => edition │ 2021 +# => ─────────┴────── ``` ### 値を増やす @@ -231,23 +231,23 @@ Nu の変更は永続的な変更ではなく、値自体に作用する関数 数字やバージョンを扱う際に便利なコマンドがもうひとつあります、`inc`です。 ``` -> open rustfmt.toml -─────────┬────── - edition │ 2018 -─────────┴────── -> open rustfmt.toml | inc edition -─────────┬────── - edition │ 2019 -─────────┴────── +open rustfmt.toml +# => ─────────┬────── +# => edition │ 2018 +# => ─────────┴────── +open rustfmt.toml | inc edition +# => ─────────┬────── +# => edition │ 2019 +# => ─────────┴────── ``` "edition"の値は数字なので、`inc`を使って更新することができます。バージョンを扱う際には`inc`がその真価を発揮します。 ``` -> open Cargo.toml | get package.version -0.1.3 -> open Cargo.toml | inc package.version --minor | get package.version -0.2.0 +open Cargo.toml | get package.version +# => 0.1.3 +open Cargo.toml | inc package.version --minor | get package.version +# => 0.2.0 ``` バージョンを扱う際には、フラグを利用して、バージョンのインクリメント方法を指定できます。 diff --git a/pt-BR/book/carregando_dados.md b/pt-BR/book/carregando_dados.md index 976bf9c776e..6ee33802f25 100644 --- a/pt-BR/book/carregando_dados.md +++ b/pt-BR/book/carregando_dados.md @@ -7,16 +7,16 @@ Anteriormente vimos como você pode usar comandos como `ls`, `ps`, `date` e `sys 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: ```nu -> open editors/vscode/package.json -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- - name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen - | ion | | | | ry | r | es | | | onEvents | | tes | | dencies -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- - lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object] - | support | develope | | | | | items] | | | | tension | | | - | for VS | rs | | | | | | | | | | | | - | Code | | | | | | | | | | | | | -------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +open editors/vscode/package.json +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +# => name | descript | author | license | version | reposito | publishe | categori | keywords | engines | activati | main | contribu | scripts | devDepen +# => | ion | | | | ry | r | es | | | onEvents | | tes | | dencies +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- +# => lark | Lark | Lark | MIT | 1.0.0 | [object] | vscode | [0 | [1 item] | [object] | [1 item] | ./out/ex | [object] | [object] | [object] +# => | support | develope | | | | | items] | | | | tension | | | +# => | for VS | rs | | | | | | | | | | | | +# => | Code | | | | | | | | | | | | | +# => ------+----------+----------+---------+---------+----------+----------+----------+----------+----------+----------+----------+----------+----------+---------- ``` 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. @@ -24,8 +24,8 @@ De um jeito similar ao comando `ls`, abrir um tipo de arquivo que o Nu entende v Se quisermos checar a versão do projeto que estamos olhando, podemos usar o comando `get`. ```nu -> open editors/vscode/package.json | get version -1.0.0 +open editors/vscode/package.json | get version +# => 1.0.0 ``` 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 Mas o que acontece se você carregar um arquivo texto cujo formato não é um desses? Vamos tentar: ```nu -> open README.md +open README.md ``` 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,10 +54,10 @@ Uma parte importante de se trabalhar com dados vindos de fora do Nu é que eles Vamos imaginar que obtivemos esse arquivo de dados: ```nu -> open people.txt -Octavia | Butler | Writer -Bob | Ross | Painter -Antonio | Vivaldi | Composer +open people.txt +# => Octavia | Butler | Writer +# => Bob | Ross | Painter +# => Antonio | Vivaldi | Composer ``` 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. @@ -65,79 +65,79 @@ Cada pedacinho de dado que queremos está separado pelo símbolo de pipe ('|') e A primeira coisa que queremos fazer ao carregar o arquivo é trabalhar com ele linha a linha: ```nu -> open people.txt | lines ----+------------------------------ - # | value ----+------------------------------ - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+------------------------------ +open people.txt | lines +# => ---+------------------------------ +# => # | value +# => ---+------------------------------ +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+------------------------------ ``` 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: ```nu -> open people.txt | lines | split column "|" ----+----------+-----------+----------- - # | Column1 | Column2 | Column3 ----+----------+-----------+----------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+----------+-----------+----------- +open people.txt | lines | split column "|" +# => ---+----------+-----------+----------- +# => # | Column1 | Column2 | Column3 +# => ---+----------+-----------+----------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+----------+-----------+----------- ``` Está quase certo. Parece que tem um espaço extra ali. Vamos mudar nosso delimitador: ```nu -> open people.txt | lines | split column " | " ----+---------+---------+---------- - # | Column1 | Column2 | Column3 ----+---------+---------+---------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+---------+---------+---------- +open people.txt | lines | split column " | " +# => ---+---------+---------+---------- +# => # | Column1 | Column2 | Column3 +# => ---+---------+---------+---------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+---------+---------+---------- ``` 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: ```nu -> open people.txt | lines | split column " | " | get Column1 ----+--------- - # | value ----+--------- - 0 | Octavia - 1 | Bob - 2 | Antonio ----+--------- +open people.txt | lines | split column " | " | get Column1 +# => ---+--------- +# => # | value +# => ---+--------- +# => 0 | Octavia +# => 1 | Bob +# => 2 | Antonio +# => ---+--------- ``` Podemos também nomear nossas colunas ao invés de usar os nomes padrão: ```nu -> open people.txt | lines | split column " | " first_name last_name job ----+------------+-----------+---------- - # | first_name | last_name | job ----+------------+-----------+---------- - 0 | Octavia | Butler | Writer - 1 | Bob | Ross | Painter - 2 | Antonio | Vivaldi | Composer ----+------------+-----------+---------- +open people.txt | lines | split column " | " first_name last_name job +# => ---+------------+-----------+---------- +# => # | first_name | last_name | job +# => ---+------------+-----------+---------- +# => 0 | Octavia | Butler | Writer +# => 1 | Bob | Ross | Painter +# => 2 | Antonio | Vivaldi | Composer +# => ---+------------+-----------+---------- ``` Agora que nossos dados estão em uma tabela, podemos usar todos os comandos que já usávamos antes em tabelas: ```nu -> open people.txt | lines | split column " | " first_name last_name job | sort-by first_name ----+------------+-----------+---------- - # | first_name | last_name | job ----+------------+-----------+---------- - 0 | Antonio | Vivaldi | Composer - 1 | Bob | Ross | Painter - 2 | Octavia | Butler | Writer ----+------------+-----------+---------- +open people.txt | lines | split column " | " first_name last_name job | sort-by first_name +# => ---+------------+-----------+---------- +# => # | first_name | last_name | job +# => ---+------------+-----------+---------- +# => 0 | Antonio | Vivaldi | Composer +# => 1 | Bob | Ross | Painter +# => 2 | Octavia | Butler | Writer +# => ---+------------+-----------+---------- ``` 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: 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: ```nu -> open Cargo.lock -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -[[package]] -name = "adhoc_derive" -version = "0.1.2" +open Cargo.lock +# => # This file is automatically @generated by Cargo. +# => # It is not intended for manual editing. +# => [[package]] +# => name = "adhoc_derive" +# => version = "0.1.2" ``` 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`: ```nu -> open Cargo.lock | from toml -----------+------------- - metadata | package -----------+------------- - [object] | [405 items] -----------+------------- +open Cargo.lock | from toml +# => ----------+------------- +# => metadata | package +# => ----------+------------- +# => [object] | [405 items] +# => ----------+------------- ``` Há um comando `from` para cada formato de dados estruturados em texto que o Nu entende e pode abrir. @@ -175,12 +175,13 @@ Há um comando `from` para cada formato de dados estruturados em texto que o Nu 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`: ```nu -> open Cargo.toml --raw -[package] name = "nu" -version = "0.1.3" -authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] -description = "A shell for the GitHub era" -license = "MIT" +open Cargo.toml --raw +# => [package] +# => name = "nu" +# => version = "0.1.3" +# => authors = ["Yehuda Katz ", "Sophia Turner <547158+sophiajt@users.noreply.github.com>"] +# => description = "A shell for the GitHub era" +# => license = "MIT" ``` ## Abrindo URLs @@ -188,10 +189,10 @@ license = "MIT" 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ê: ```nu -> open https://www.jonathanturner.org/feed.xml ----------- - rss ----------- - [1 item] ----------- +open https://www.jonathanturner.org/feed.xml +# => ---------- +# => rss +# => ---------- +# => [1 item] +# => ---------- ``` diff --git a/pt-BR/book/escapando.md b/pt-BR/book/escapando.md index ec3f44d4752..0353e37d816 100644 --- a/pt-BR/book/escapando.md +++ b/pt-BR/book/escapando.md @@ -5,11 +5,11 @@ O Nu fornece um conjunto de comandos que você pode usar entre diferentes SOs e Comando Nu: ```nu -> ls +ls ``` Escapando para o comando local: ```nu -> ^ls +^ls ``` diff --git a/pt-BR/book/explorando.md b/pt-BR/book/explorando.md index a4e23160bd6..5e543d8794d 100644 --- a/pt-BR/book/explorando.md +++ b/pt-BR/book/explorando.md @@ -11,13 +11,13 @@ Como vimos em outros capítulos, `ls` é um comando para visualizar o conteúdo 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". ```nu -> ls *.txt ----+--------------+------+----------+---------+--------------+-------------- - # | name | type | readonly | size | accessed | modified ----+--------------+------+----------+---------+--------------+-------------- - 0 | history.txt | File | | 1.3 KB | 2 months ago | a day ago - 1 | readonly.txt | File | readonly | | 2 months ago | 2 months ago ----+--------------+------+----------+---------+--------------+-------------- +ls *.txt +# => ---+--------------+------+----------+---------+--------------+-------------- +# => # | name | type | readonly | size | accessed | modified +# => ---+--------------+------+----------+---------+--------------+-------------- +# => 0 | history.txt | File | | 1.3 KB | 2 months ago | a day ago +# => 1 | readonly.txt | File | readonly | | 2 months ago | 2 months ago +# => ---+--------------+------+----------+---------+--------------+-------------- ``` 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'". @@ -25,16 +25,16 @@ O asterisco (\*) usado no parâmetro opcional acima "\*.txt" é chamado de corin Nu também usa coringas modernos, que permitem acesso a diretórios mais profundos. ```nu -> ls **/*.rs ------+-----------------------------------------------------+------+----------+----------+----------------+---------------- - # | name | type | readonly | size | accessed | modified ------+-----------------------------------------------------+------+----------+----------+----------------+---------------- - 0 | src/cli.rs | File | | 19.1 KB | 15 hours ago | 15 hours ago - 1 | src/commands/args.rs | File | | 244 B | 2 months ago | 2 months ago - 2 | src/commands/autoview.rs | File | | 2.5 KB | 15 hours ago | 15 hours ago - 3 | src/commands/cd.rs | File | | 277 B | a week ago | a week ago - 4 | src/commands/classified.rs | File | | 13.5 KB | 15 hours ago | 15 hours ago - 5 | src/commands/clip.rs | File | | 2.0 KB | 2 days ago | 2 days ago +ls **/*.rs +# => -----+-----------------------------------------------------+------+----------+----------+----------------+---------------- +# => # | name | type | readonly | size | accessed | modified +# => -----+-----------------------------------------------------+------+----------+----------+----------------+---------------- +# => 0 | src/cli.rs | File | | 19.1 KB | 15 hours ago | 15 hours ago +# => 1 | src/commands/args.rs | File | | 244 B | 2 months ago | 2 months ago +# => 2 | src/commands/autoview.rs | File | | 2.5 KB | 15 hours ago | 15 hours ago +# => 3 | src/commands/cd.rs | File | | 277 B | a week ago | a week ago +# => 4 | src/commands/classified.rs | File | | 13.5 KB | 15 hours ago | 15 hours ago +# => 5 | src/commands/clip.rs | File | | 2.0 KB | 2 days ago | 2 days ago ``` 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". @@ -42,7 +42,7 @@ Aqui estamos procurando qualquer arquivo cujo nome termine com ".rs" e os dois a ## Mudando o diretório atual ```nu -> cd new_directory +cd new_directory ``` 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,19 +54,19 @@ Nu também fornece alguns comandos básicos de sistemas de arquivos que funciona Podemos mover um item de um lugar para outro usando o comando `mv`. ```nu -> mv item location +mv item location ``` Podemos copiar um item de um local para outro: ```nu -> cp item location +cp item location ``` Podemos remover um item: ```nu -> rm item +rm item ``` Os três comandos também podem usar os coringas que vimos anteriormente com `ls`. @@ -74,5 +74,5 @@ Os três comandos também podem usar os coringas que vimos anteriormente com `ls Por fim, podemos criar um novo diretório usando o comando `mkdir`: ```nu -> mkdir new_directory +mkdir new_directory ``` diff --git a/pt-BR/book/instalacao.md b/pt-BR/book/instalacao.md index d29e22f1d23..2d2fc278e33 100644 --- a/pt-BR/book/instalacao.md +++ b/pt-BR/book/instalacao.md @@ -95,7 +95,7 @@ brew install openssl cmake Quando tivermos todas as dependências de que o Nu precisa, podemos instalá-lo usando o comando `cargo`, que vem junto com o compilador Rust. ```nu -> cargo install nu --locked +cargo install nu --locked ``` Pronto! A ferramenta cargo fará o download do Nu e das dependências do fonte, o build e a instalação no caminho bin do cargo, de forma que possamos rodá-lo. @@ -103,7 +103,7 @@ Pronto! A ferramenta cargo fará o download do Nu e das dependências do fonte, Se quiser instalar todas as funcionalidades, inclusive algumas opcionais divertidas, você pode usar: ```nu -> cargo install nu --locked --features=stable +cargo install nu --locked --features=stable ``` Para esse comando funcionar, certifique-se de ter todas as dependências (mostradas acima) instaladas no seu sistema. @@ -120,20 +120,20 @@ $ nu Também podemos fazer o build do código fonte diretamente do GitHub. Isso nos dá acesso imediato às últimas funcionalidades e correções do Nu. ```nu -> git clone https://github.com/nushell/nushell.git +git clone https://github.com/nushell/nushell.git ``` O Git vai clonar o repositório principal do nushell e daí podemos fazer o build e rodar o Nu: ```bash -> cd nushell -nushell> cargo build --workspace --features=stable; cargo run --features=stable +cd nushell +cargo build --workspace --features=stable; cargo run --features=stable ``` Você também pode fazer o build e rodar o Nu em modo release: ```nu -nushell> cargo build --release --workspace --features=stable; cargo run --release --features=stable +cargo build --release --workspace --features=stable; cargo run --release --features=stable ``` Pessoas mais acostumadas com Rust podem se perguntar por que fazemos tanto o "build" como o "run" se o "run" já faz o build por padrão. Isso serve para contornar uma falha da nova opção `default-run` no Cargo e assegurar que será feito o build de todos os plugins, embora possa não ser necessário no futuro. diff --git a/pt-BR/book/introducao.md b/pt-BR/book/introducao.md index ae9011c32a1..713432e8f59 100644 --- a/pt-BR/book/introducao.md +++ b/pt-BR/book/introducao.md @@ -13,17 +13,17 @@ O jeito mais fácil de ver o que o Nu pode fazer é começar com alguns exemplos A primeira coisa que você vai perceber quando rodar um comando como `ls` é que ao invés de um bloco de texto, você recebe de volta uma tabela estruturada. ```nu -> ls -----+------------------+-----------+----------+----------+----------------+---------------- - # | name | type | readonly | size | accessed | modified -----+------------------+-----------+----------+----------+----------------+---------------- - 0 | .azure | Directory | | 4.1 KB | 2 months ago | a week ago - 1 | IMG_1291.jpg | File | | 115.5 KB | a month ago | 4 months ago - 2 | Cargo.toml | File | | 3.1 KB | 17 minutes ago | 17 minutes ago - 3 | LICENSE | File | | 1.1 KB | 2 months ago | 2 months ago - 4 | readonly.txt | File | readonly | | a month ago | a month ago - 5 | target | Directory | | 4.1 KB | 2 days ago | 15 minutes ago -... +ls +# => ----+------------------+-----------+----------+----------+----------------+---------------- +# => # | name | type | readonly | size | accessed | modified +# => ----+------------------+-----------+----------+----------+----------------+---------------- +# => 0 | .azure | Directory | | 4.1 KB | 2 months ago | a week ago +# => 1 | IMG_1291.jpg | File | | 115.5 KB | a month ago | 4 months ago +# => 2 | Cargo.toml | File | | 3.1 KB | 17 minutes ago | 17 minutes ago +# => 3 | LICENSE | File | | 1.1 KB | 2 months ago | 2 months ago +# => 4 | readonly.txt | File | readonly | | a month ago | a month ago +# => 5 | target | Directory | | 4.1 KB | 2 days ago | 15 minutes ago +# => ... ``` Essa tabela faz mais do que somente mostrar o diretório de um jeito diferente. Assim como uma planilha, ela nos permite trabalhar com os dados interativamente. @@ -31,17 +31,17 @@ Essa tabela faz mais do que somente mostrar o diretório de um jeito diferente. A primeira coisa que vamos fazer é ordenar a tabela por nome. Para isso, vamos direcionar a saída do `ls` para um comando capaz de ordenar tabelas com base no conteúdo de uma coluna. ```nu -> ls | sort-by name -----+------------------+-----------+----------+----------+----------------+---------------- - # | name | type | readonly | size | accessed | modified -----+------------------+-----------+----------+----------+----------------+---------------- - 0 | .azure | Directory | | 4.1 KB | 2 months ago | a week ago - 1 | .cargo | Directory | | 4.1 KB | 2 months ago | 2 months ago - 2 | .editorconfig | File | | 148 B | 2 months ago | 2 months ago - 3 | .git | Directory | | 4.1 KB | 2 months ago | 20 minutes ago - 4 | .gitignore | File | | 58 B | a week ago | a week ago - 5 | .vscode | Directory | | 4.1 KB | a month ago | a month ago -... +ls | sort-by name +# => ----+------------------+-----------+----------+----------+----------------+---------------- +# => # | name | type | readonly | size | accessed | modified +# => ----+------------------+-----------+----------+----------+----------------+---------------- +# => 0 | .azure | Directory | | 4.1 KB | 2 months ago | a week ago +# => 1 | .cargo | Directory | | 4.1 KB | 2 months ago | 2 months ago +# => 2 | .editorconfig | File | | 148 B | 2 months ago | 2 months ago +# => 3 | .git | Directory | | 4.1 KB | 2 months ago | 20 minutes ago +# => 4 | .gitignore | File | | 58 B | a week ago | a week ago +# => 5 | .vscode | Directory | | 4.1 KB | a month ago | a month ago +# => ... ``` Você pode ver que, para fazer isso funcionar, não passamos parâmetros de linha de comando para o `ls`. Ao invés disso, usamos o comando `sort-by`, fornecido pelo Nu, para ordenar a saída do comando `ls`. @@ -49,31 +49,31 @@ Você pode ver que, para fazer isso funcionar, não passamos parâmetros de linh O Nu fornece muitos comandos que trabalham com tabelas. Por exemplo, podemos filtrar o conteúdo da tabela do `ls` para que ela mostre apenas os arquivos com mais de 4 kilobytes: ```nu -> ls | where size > 4kb -----+----------------+------+----------+----------+----------------+---------------- - # | name | type | readonly | size | accessed | modified -----+----------------+------+----------+----------+----------------+---------------- - 0 | IMG_1291.jpg | File | | 115.5 KB | a month ago | 4 months ago - 1 | README.md | File | | 11.1 KB | 2 days ago | 2 days ago - 2 | IMG_1291.png | File | | 589.0 KB | a month ago | a month ago - 3 | IMG_1381.jpg | File | | 81.0 KB | a month ago | 4 months ago - 4 | butterfly.jpeg | File | | 4.2 KB | a month ago | a month ago - 5 | Cargo.lock | File | | 199.6 KB | 22 minutes ago | 22 minutes ago +ls | where size > 4kb +# => ----+----------------+------+----------+----------+----------------+---------------- +# => # | name | type | readonly | size | accessed | modified +# => ----+----------------+------+----------+----------+----------------+---------------- +# => 0 | IMG_1291.jpg | File | | 115.5 KB | a month ago | 4 months ago +# => 1 | README.md | File | | 11.1 KB | 2 days ago | 2 days ago +# => 2 | IMG_1291.png | File | | 589.0 KB | a month ago | a month ago +# => 3 | IMG_1381.jpg | File | | 81.0 KB | a month ago | 4 months ago +# => 4 | butterfly.jpeg | File | | 4.2 KB | a month ago | a month ago +# => 5 | Cargo.lock | File | | 199.6 KB | 22 minutes ago | 22 minutes ago ``` Assim como na filosofia Unix, fazer os comandos conversarem uns com os outros nos permite combiná-los de muitas maneiras diferentes. Vamos ver outro comando: ```nu -> ps ------+-------+----------+------+-------------------------------------------------------------------------------- - # | pid | status | cpu | name ------+-------+----------+------+-------------------------------------------------------------------------------- - 0 | 1003 | Unknown | 0.00 | - 1 | 1515 | Sleeping | 0.00 | /usr/lib/gnome-settings-daemon/gsd-screensaver-proxy - 2 | 2128 | Sleeping | 0.00 | /usr/lib/gnome-settings-daemon/gsd-screensaver-proxy - 3 | 2285 | Unknown | 0.00 | - 4 | 8872 | Sleeping | 0.00 | /usr/lib/gvfs/gvfsd-dnssd--spawner:1.23/org/gtk/gvfs/exec_spaw/4 - 5 | 1594 | Sleeping | 0.00 | /usr/lib/ibus/ibus-engine-simple +ps +# => -----+-------+----------+------+-------------------------------------------------------------------------------- +# => # | pid | status | cpu | name +# => -----+-------+----------+------+-------------------------------------------------------------------------------- +# => 0 | 1003 | Unknown | 0.00 | +# => 1 | 1515 | Sleeping | 0.00 | /usr/lib/gnome-settings-daemon/gsd-screensaver-proxy +# => 2 | 2128 | Sleeping | 0.00 | /usr/lib/gnome-settings-daemon/gsd-screensaver-proxy +# => 3 | 2285 | Unknown | 0.00 | +# => 4 | 8872 | Sleeping | 0.00 | /usr/lib/gvfs/gvfsd-dnssd--spawner:1.23/org/gtk/gvfs/exec_spaw/4 +# => 5 | 1594 | Sleeping | 0.00 | /usr/lib/ibus/ibus-engine-simple ``` Você deve conhecer o comando `ps` se já usou Linux. Com ele, vemos uma lista com todos os processos que o sistema está rodando atualmente, seus estados e seus nomes. Também podemos ver a carga de CPU para cada processo. @@ -81,14 +81,14 @@ Você deve conhecer o comando `ps` se já usou Linux. Com ele, vemos uma lista c E se quiséssemos mostrar somente os processos que estão usando a CPU de fato? Exatamente como fizemos com o comando `ls` anteriormente, podemos também manipular a tabela que o comando `ps` nos retorna: ```nu -> ps | where cpu > 10 ----+-------+----------+-------+----------------------------- - # | pid | status | cpu | name ----+-------+----------+-------+----------------------------- - 0 | 1992 | Sleeping | 44.52 | /usr/bin/gnome-shell - 1 | 1069 | Sleeping | 16.15 | - 2 | 24116 | Sleeping | 13.70 | /opt/google/chrome/chrome - 3 | 21976 | Sleeping | 12.67 | /usr/share/discord/Discord +ps | where cpu > 10 +# => ---+-------+----------+-------+----------------------------- +# => # | pid | status | cpu | name +# => ---+-------+----------+-------+----------------------------- +# => 0 | 1992 | Sleeping | 44.52 | /usr/bin/gnome-shell +# => 1 | 1069 | Sleeping | 16.15 | +# => 2 | 24116 | Sleeping | 13.70 | /opt/google/chrome/chrome +# => 3 | 21976 | Sleeping | 12.67 | /usr/share/discord/Discord ``` Até agora vimos como usar `ls` e `ps` para listar arquivos e processos. O Nu também oferece outros comandos que podem criar tabelas com informações úteis. A seguir vamos explorar `date` e `sys`. @@ -96,41 +96,41 @@ Até agora vimos como usar `ls` e `ps` para listar arquivos e processos. O Nu ta Ao executar `date` obtemos informações sobre a data e hora correntes: ```nu -> date -------+-------+-----+------+--------+--------+---------- - year | month | day | hour | minute | second | timezone -------+-------+-----+------+--------+--------+---------- - 2019 | 8 | 17 | 19 | 20 | 50 | +12:00 -------+-------+-----+------+--------+--------+---------- +date +# => ------+-------+-----+------+--------+--------+---------- +# => year | month | day | hour | minute | second | timezone +# => ------+-------+-----+------+--------+--------+---------- +# => 2019 | 8 | 17 | 19 | 20 | 50 | +12:00 +# => ------+-------+-----+------+--------+--------+---------- ``` E ao executar `sys` obtemos informações sobre o sistema em que o Nu está rodando: ```nu -> sys -----------+----------+-----------+----------+-----------+----------- - host | cpu | disks | mem | temp | net -----------+----------+-----------+----------+-----------+----------- - [object] | [object] | [3 items] | [object] | [3 items] | [3 items] -----------+----------+-----------+----------+-----------+----------- +sys +# => ----------+----------+-----------+----------+-----------+----------- +# => host | cpu | disks | mem | temp | net +# => ----------+----------+-----------+----------+-----------+----------- +# => [object] | [object] | [3 items] | [object] | [3 items] | [3 items] +# => ----------+----------+-----------+----------+-----------+----------- ``` Essa tabela é um pouco diferente das que vimos antes. O comando `sys` retorna uma tabela que contém tabelas estruturadas em suas células, ao invés de valores simples. Para dar uma olhada nesses dados, precisamos selecionar a coluna que queremos ver: ```nu -> sys | get host --------+------------------+----------+--------+----------+---------- - name | release | hostname | arch | uptime | users --------+------------------+----------+--------+----------+---------- - Linux | 5.0.0-21-generic | pop-os | x86_64 | [object] | [1 item] --------+------------------+----------+--------+----------+---------- +sys | get host +# => -------+------------------+----------+--------+----------+---------- +# => name | release | hostname | arch | uptime | users +# => -------+------------------+----------+--------+----------+---------- +# => Linux | 5.0.0-21-generic | pop-os | x86_64 | [object] | [1 item] +# => -------+------------------+----------+--------+----------+---------- ``` O comando `get` permite que tenhamos acesso ao conteúdo de uma coluna da tabela. Aqui, estamos olhando para dentro da coluna `host`, que contém informações a respeito da máquina host em que o Nu está rodando, como nome do SO (sistema operacional), o nome de host, a CPU e outros dados mais. Vamos ver os nomes dos usuários do sistema: ```nu -> sys | get host.users -sophia +sys | get host.users +# => sophia ``` Nesse momento só tem um único usuário no sistema, chamado "sophia". Note que nós podemos passar um caminho e não apenas o nome de uma coluna. O Nu vai seguir esse caminho até o dado correspondente na tabela. @@ -140,8 +140,8 @@ Talvez você tenha notado mais alguma coisa de diferente. Ao invés de uma tabel Vejamos como as strings funcionam fora do Nu. Vamos usar nosso exemplo anterior e executar o comando externo `echo`, presente na maioria dos SOs: ```nu -> sys | get host.users | echo $it -sophia +sys | get host.users | echo $it +# => sophia ``` Se isso lhe parece bastante similar ao que tínhamos anteriormente, você tem um olho afiado! É similar, mas com uma diferença importante: chamamos `echo` com o valor retornado antes. Isso permite que passemos dados para o `echo` fora do Nu (ou para qualquer outro comando de fora do Nu, como `git`, por exemplo). @@ -149,20 +149,20 @@ Se isso lhe parece bastante similar ao que tínhamos anteriormente, você tem um _Nota: você pode obter um texto de ajuda para quaisquer comandos embutidos do Nu usando o comando `help`_: ```nu -> help config -Configuration management. -Usage: - > config {flags} - -Subcommands: - config get - - config set - - config set_into - - config clear - - config load - - config remove - - config path - - -Flags: - -h, --help: Display this help message +help config +# => Configuration management. +# => Usage: +# => > config {flags} +# => +# => Subcommands: +# => config get - +# => config set - +# => config set_into - +# => config clear - +# => config load - +# => config remove - +# => config path - +# => +# => Flags: +# => -h, --help: Display this help message ``` diff --git a/pt-BR/book/metadados.md b/pt-BR/book/metadados.md index 5a60895158f..3f830b07491 100644 --- a/pt-BR/book/metadados.md +++ b/pt-BR/book/metadados.md @@ -3,14 +3,14 @@ Usando o Nu vocë pode se deparar com momentos em que sente como se houvesse algo a mais acontecendo nos bastidores. Por exemplo, digamos que vocë vai tentar abrir um arquivo mas se esquece que ele é suportado pelo Nu e tenta convertê-lo novamente: ```nu -> open Cargo.toml | from toml -error: Expected a string from pipeline -- shell:1:18 -1 | open Cargo.toml | from toml - | ^^^^^^^^^ requires string input -- shell:1:5 -1 | open Cargo.toml | from toml - | ---------- object originates from here +open Cargo.toml | from toml +# => error: Expected a string from pipeline +# => - shell:1:18 +# => 1 | open Cargo.toml | from toml +# => | ^^^^^^^^^ requires string input +# => - shell:1:5 +# => 1 | open Cargo.toml | from toml +# => | ---------- object originates from here ``` A mensagem de erro nos diz não só que o que passamos para o `from toml` não era uma string, mas também de onde o valor veio originalmente. Como o Nu sabe isso? @@ -20,12 +20,12 @@ Valores que fluem pelo pipeline do Nu normalmente trazem consigo um conjunto adi Vamos executar o comando `open` de novo, mas, dessa vez, vamos olhar as tags que ele retorna: ```nu -> open Cargo.toml | tags -----------+---------------------------------------- - span | origin -----------+---------------------------------------- - [object] | /home/sophia/Source/nushell/Cargo.toml -----------+---------------------------------------- +open Cargo.toml | tags +# => ----------+---------------------------------------- +# => span | origin +# => ----------+---------------------------------------- +# => [object] | /home/sophia/Source/nushell/Cargo.toml +# => ----------+---------------------------------------- ``` Atualmente, rastreamos dois pedaços de metadados dos valores no pipeline. Você pode observar que temos a origem, que nos dá a localização de onde os dados foram carregados, o que pode ajudar o Nu a entender melhor como apresentá-los. @@ -33,12 +33,12 @@ Atualmente, rastreamos dois pedaços de metadados dos valores no pipeline. Você Há também um coluna intervalo (span). Vamos ver mais de perto: ```nu -> open Cargo.toml | tags | get span --------+----- - start | end --------+----- - 5 | 15 --------+----- +open Cargo.toml | tags | get span +# => -------+----- +# => start | end +# => -------+----- +# => 5 | 15 +# => -------+----- ``` O início (start) e fim (end) do intervalo aqui se referem a onde o sublinhado ficará na linha da mensagem de erro. Se você contar até depois do 5 e então até 15, verá que esse intervalo coincide com o nome do arquivo "Cargo.toml". É assim que o erro que vimos antes sabe onde sublinhar a mensagem. diff --git a/pt-BR/book/pipeline.md b/pt-BR/book/pipeline.md index be4de8c2750..2ec00f35416 100644 --- a/pt-BR/book/pipeline.md +++ b/pt-BR/book/pipeline.md @@ -7,7 +7,7 @@ Um dos principais designs do Nu é o pipeline, uma ideia de design que tem suas Um pipeline é construído com três partes: a entrada, o filtro e a saída. ```nu -> open "Cargo.toml" | inc package.version | save "Cargo_new.toml" +open "Cargo.toml" | inc package.version | save "Cargo_new.toml" ``` O primeiro comando, `open "Cargo.toml"`, é uma entrada (às vezes também chamado de "fonte" ou "produtor"). Ele cria ou carrega dados com os quais alimenta o pipeline. É a partir da entrada que os pipelines conseguem dados para trabalhar. Comandos como `ls` também são entradas, já que pegam dados do sistema de arquivos e os enviam através dos pipelines para que possam ser usados adiante. @@ -39,13 +39,13 @@ Você pode ter se perguntado como vemos uma tabela se o `ls` é uma entrada e n Com efeito, o comando: ```nu -> ls +ls ``` E o pipeline: ```nu -> ls | autoview +ls | autoview ``` São a mesma coisa. diff --git a/pt-BR/book/shells_em_shells.md b/pt-BR/book/shells_em_shells.md deleted file mode 100644 index 30cbe03b65d..00000000000 --- a/pt-BR/book/shells_em_shells.md +++ /dev/null @@ -1,158 +0,0 @@ -# Shells em shells - -## Trabalhando em múltiplos diretórios - -Embora seja comum trabalhar em um único diretório, pode ser útil trabalhar em múltiplos locais ao mesmo tempo. Para isso, Nu oferece o conceito de "shells". Como o nome implica, eles são uma maneira de executar múltiplos shells em um, permitindo que você salte rapidamente entre diretórios e muito mais. - -Para começar, vamos entrar num diretório: - -```nu -/home/sophia/Source/nushell(master)> enter ../lark -/home/sophia/Source/lark(master)> ls -----+----------------+-----------+----------+---------+---------------+--------------- - # | name | type | readonly | size | accessed | modified -----+----------------+-----------+----------+---------+---------------+--------------- - 0 | Cargo.toml | File | | 2.2 KB | 6 months ago | 6 months ago - 1 | target | Directory | | 4.1 KB | 10 months ago | 6 months ago - 2 | notes | Directory | | 4.1 KB | 10 months ago | 6 months ago -``` - -Entrar é semlhante a mudar de diretório (como vimos com o comando `cd`), permitindo que você salte para o diretório dentro do qual vai trabalhar. Ao invés de mudar de diretório, nós agora estamos em dois diretórios. Para ver isso mais claramente, podemos usar o comando `shells` para listar os diretórios ativos agora: - -```nu -/home/sophia/Source/lark(master)> shells ----+---+------------+----------------------------- - # | | name | path ----+---+------------+----------------------------- - 0 | | filesystem | /home/sophia/Source/nushell - 1 | X | filesystem | /home/sophia/Source/lark ----+---+------------+----------------------------- -``` - -O comando `shells` nos mostra que há dois diretórios ativos agora: nosso diretório original "nushell" e agora esse novo diretório "lark". - -Podemos saltar entre esses shells com os atalhos `n` e `p`, abrevisções para "next" (próximo) e "previous" (anterior): - -``` -/home/sophia/Source/lark(master)> n -/home/sophia/Source/nushell(master)> p -/home/sophia/Source/lark(master)> -``` - -Podemos ver a alteração de diretórios, mas sempre somos capazes de voltar para um diretório anterior em que estávamos trabalhando. Isso nos permite trabalhar em múltiplos diretórios na mesma sessão. - -## Saindo do shell - -Você pode sair de um shell em que tenha entrado (usando `enter`) através do comando `exit`. Se esse for o último shell aberto, Nu será encerrado. - -Você sempre pode emcerrar o Nu, mesmo que múltiplos shells estejam ativos, passando o modificador `--now` para o comando `exit`. Assim: `exit --now`. - -## Indo além de diretórios - -O Nu também pode criar shells a partir de outras coisas além de caminhos do sistema de arquivos. Digamos, por exemplo, que você está trabalhando com uma grande massa de dadose não quer perder seu lugar dentro dela. - -Para ver como isso funciona, vamos fazer o seguinte exercício. Atualmente, listamos os [plugins](plugins.md) que desenvolvemos para o Nu no arquivo "Cargo.toml". Digamos que tenhamos acabado de criar um novo plugin no diretório src/plugins chamado "doc.rs" e queremos saber se ele também está listado, de forma que possa ser compilado e instalado corretamente. - -Vamos entrar no arquivo "Cargo.toml" do código fonte do Nu: - -```nu -/Users/andresrobalino/Code/nushell(master)> enter Cargo.toml -/> ls -------------+--------------+------------------+----------+---------- - bin | dependencies | dev-dependencies | lib | package -------------+--------------+------------------+----------+---------- - [11 items] | [object] | [object] | [object] | [object] -------------+--------------+------------------+----------+---------- -``` - -Até o momento, apenas entramos no arquivo (usando o comando `enter`) e podemos ver o que há dentro dele pela tabela que o `ls` nos retorna. Se você prestar bastante atenção, dessa vez entramos num arquivo cujo formato o Nu entende (.toml). O Nu também projeta o conteúdo do arquivo em algo semelhante a um sistema de arquivos para que possamos explorá-lo como se fosse um sistema de arquivos regular. - -Antes de continuarmos, vamos checar os shells ativos: - -```nu -/> shells ----+---+-------------------------------------------------+------------------------------------ - # | | name | path ----+---+-------------------------------------------------+------------------------------------ - 0 | | filesystem | /Users/andresrobalino/Code/nushell - 1 | X | {/Users/andresrobalino/Code/nushell/Cargo.toml} | / ----+---+-------------------------------------------------+------------------------------------ - -``` - -Podemos observar que temos dois shells ativos e que estamos agora dentro do arquivo "Cargo.toml" com um caminho raíz padrão "/". Vamos ver seu contéudo novamente: - -```nu -/> ls -------------+--------------+------------------+----------+---------- - bin | dependencies | dev-dependencies | lib | package -------------+--------------+------------------+----------+---------- - [11 items] | [object] | [object] | [object] | [object] -------------+--------------+------------------+----------+---------- -``` - -O que estamos procurando pode estar dentro da coluna "bin", então vamos entrar lá: - -```nu -> cd bin -/bin> ls -----+----------------------+--------------------------- - # | name | path -----+----------------------+--------------------------- - 0 | nu_plugin_inc | src/plugins/inc.rs - 1 | nu_plugin_sum | src/plugins/sum.rs - 2 | nu_plugin_add | src/plugins/add.rs - 3 | nu_plugin_edit | src/plugins/edit.rs - 4 | nu_plugin_str | src/plugins/str.rs - 5 | nu_plugin_skip | src/plugins/skip.rs - 6 | nu_plugin_sys | src/plugins/sys.rs - 7 | nu_plugin_tree | src/plugins/tree.rs - 8 | nu_plugin_binaryview | src/plugins/binaryview.rs - 9 | nu_plugin_textview | src/plugins/textview.rs - 10 | nu | src/main.rs -----+----------------------+--------------------------- -``` - -Daqui, sempre podemos voltar para o diretório em que estávamos trabalhando antes usando p (de prévio, anterior). - -```nu -/bin> p -``` - -Vamos verificar os shells de novo: - -```nu -/Users/andresrobalino/Code/nushell(master)> shells ----+---+-------------------------------------------------+------------------------------------ - # | | name | path ----+---+-------------------------------------------------+------------------------------------ - 0 | X | filesystem | /Users/andresrobalino/Code/nushell - 1 | | {/Users/andresrobalino/Code/nushell/Cargo.toml} | /bin ----+---+-------------------------------------------------+------------------------------------ - -``` - -Estamos de volta ao diretório onde estávamos trabalhando antes de entrar no arquivo "Cargo.toml". Agora vamos mudar para o diretório onde então os códigos fonte dos plugins e rastreá-los: - -```nu -/Users/andresrobalino/Code/nushell(master)> cd src/plugins/ -/Users/andresrobalino/Code/nushell/src/plugins(master)> ls -----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified -----+---------------+------+----------+---------+------------+------------ - 0 | doc.rs | File | | 3.0 KB | a week ago | a week ago - 1 | sum.rs | File | | 3.0 KB | a week ago | a week ago - 2 | inc.rs | File | | 11.8 KB | a week ago | a week ago - 3 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 4 | edit.rs | File | | 2.7 KB | a week ago | a week ago - 5 | str.rs | File | | 21.4 KB | 5 days ago | 5 days ago - 6 | secret.rs | File | | 1.8 KB | 2 days ago | 2 days ago - 7 | skip.rs | File | | 1.7 KB | a week ago | a week ago - 8 | binaryview.rs | File | | 13.0 KB | a week ago | a week ago - 9 | tree.rs | File | | 3.0 KB | a week ago | a week ago - 10 | add.rs | File | | 2.7 KB | a week ago | a week ago - 11 | textview.rs | File | | 9.4 KB | 5 days ago | 5 days ago -----+---------------+------+----------+---------+------------+------------ -``` - -Podemos agora comparar os dois para ver se há algum plugin faltando ou a mais que precisemos adicionao ao nosso arquivo (claramente precisamos adicionar o plugin `doc.rs` que criamos ao arquivo "Cargo.toml"!). diff --git a/pt-BR/book/trabalhando_com_tabelas.md b/pt-BR/book/trabalhando_com_tabelas.md index e05e8f6d81b..918d76aa594 100644 --- a/pt-BR/book/trabalhando_com_tabelas.md +++ b/pt-BR/book/trabalhando_com_tabelas.md @@ -5,21 +5,21 @@ Uma forma comum de ver os dados no Nu é por meio de uma tabela. O Nu traz um co Para começar, vamos usar a seguinte tabela: ```nu -> ls ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 2 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 3 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago - 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 5 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 6 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 7 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 8 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 9 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago ----+---------------+------+----------+---------+------------+------------ +ls +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 2 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 3 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 5 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 6 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 7 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 8 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 9 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => ---+---------------+------+----------+---------+------------+------------ ``` ## Ordenando os dados @@ -27,21 +27,21 @@ Para começar, vamos usar a seguinte tabela: Podemos ordenar uma tabela chamando o comando `sort-by` e informando quais colunas queremos usar na ordenação. Digamos que queremos ordenar nossa tabela pelo tamanho do arquivo: ```nu -> ls | sort-by size ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 5 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 6 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 7 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 8 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 9 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago ----+---------------+------+----------+---------+------------+------------ +ls | sort-by size +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 5 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => 6 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 7 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 8 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 9 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => ---+---------------+------+----------+---------+------------+------------ ``` Podemos ordenar uma tabela por qualquer coluna que possa ser comparada. Por exemplo, poderíamos também ter ordenado a tabela acima usando as colunas "name", "accessed" ou "modified". @@ -51,36 +51,36 @@ Podemos ordenar uma tabela por qualquer coluna que possa ser comparada. Por exem Podemos selecionar dados de uma tabela escolhendo colunas ou linhas específicas. Vamos escolher algumas colunas da nossa tabela: ```nu -> ls | select name size ----+---------------+--------- - # | name | size ----+---------------+--------- - 0 | add.rs | 2.7 KB - 1 | sum.rs | 3.0 KB - 2 | inc.rs | 11.8 KB - 3 | str.rs | 21.4 KB - 4 | skip.rs | 1.7 KB - 5 | textview.rs | 9.4 KB - 6 | binaryview.rs | 13.0 KB - 7 | edit.rs | 2.7 KB - 8 | tree.rs | 3.0 KB - 9 | sys.rs | 9.2 KB ----+---------------+--------- +ls | select name size +# => ---+---------------+--------- +# => # | name | size +# => ---+---------------+--------- +# => 0 | add.rs | 2.7 KB +# => 1 | sum.rs | 3.0 KB +# => 2 | inc.rs | 11.8 KB +# => 3 | str.rs | 21.4 KB +# => 4 | skip.rs | 1.7 KB +# => 5 | textview.rs | 9.4 KB +# => 6 | binaryview.rs | 13.0 KB +# => 7 | edit.rs | 2.7 KB +# => 8 | tree.rs | 3.0 KB +# => 9 | sys.rs | 9.2 KB +# => ---+---------------+--------- ``` Isso ajuda a criar uma tabela mais focada no que precisamos. A seguir, digamos que queremos ver apenas os 5 menores arquivos do diretório: ```nu -> ls | sort-by size | first 5 ----+---------+------+----------+--------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------+------+----------+--------+------------+------------ - 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ----+---------+------+----------+--------+------------+------------ +ls | sort-by size | first 5 +# => ---+---------+------+----------+--------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------+------+----------+--------+------------+------------ +# => 0 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 1 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 4 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => ---+---------+------+----------+--------+------------+------------ ``` Note que primeiro ordenamos a tabela por tamanho e depois usamos o `first 5` para retornar as primeiras 5 linhas da tabela. @@ -88,14 +88,14 @@ Note que primeiro ordenamos a tabela por tamanho e depois usamos o `first 5` par Você também pode usar `skip` para pular as linhas que não quiser. Vamos pular as duas primeiras das 5 linhas que retornamos acima: ```nu -> ls | sort-by size | first 5 | skip 2 ----+---------+------+----------+--------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------+------+----------+--------+------------+------------ - 0 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 2 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ----+---------+------+----------+--------+------------+------------ +ls | sort-by size | first 5 | skip 2 +# => ---+---------+------+----------+--------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------+------+----------+--------+------------+------------ +# => 0 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 2 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => ---+---------+------+----------+--------+------------+------------ ``` Restringimos os dados às 3 linhas que nos interessam. @@ -103,28 +103,28 @@ Restringimos os dados às 3 linhas que nos interessam. Vamos examinar alguns outros comandos para selecionar dados. Você pode ter se perguntado por que as linhas da tabela são numeradas. Isso serve como uma maneira prática de acessar uma linha específica. Vamos ordenar nossa tabela pelo nome do arquivo e então escolher uma das linhas com o comando `nth`, usando o número da linha: ```nu -> ls | sort-by name ----+---------------+------+----------+---------+------------+------------ - # | name | type | readonly | size | accessed | modified ----+---------------+------+----------+---------+------------+------------ - 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 1 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago - 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago - 3 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago - 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago - 5 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago - 6 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago - 7 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago - 8 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago - 9 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago ----+---------------+------+----------+---------+------------+------------ - -> ls | sort-by name | nth 5 ---------+------+----------+---------+------------+------------ - name | type | readonly | size | accessed | modified ---------+------+----------+---------+------------+------------ - str.rs | File | | 21.4 KB | 2 days ago | 2 days ago ---------+------+----------+---------+------------+------------ +ls | sort-by name +# => ---+---------------+------+----------+---------+------------+------------ +# => # | name | type | readonly | size | accessed | modified +# => ---+---------------+------+----------+---------+------------+------------ +# => 0 | add.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 1 | binaryview.rs | File | | 13.0 KB | a day ago | a day ago +# => 2 | edit.rs | File | | 2.7 KB | 2 days ago | 2 days ago +# => 3 | inc.rs | File | | 11.8 KB | 2 days ago | 2 days ago +# => 4 | skip.rs | File | | 1.7 KB | 2 days ago | 2 days ago +# => 5 | str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => 6 | sum.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => 7 | sys.rs | File | | 9.2 KB | 2 days ago | 2 days ago +# => 8 | textview.rs | File | | 9.4 KB | 2 days ago | 2 days ago +# => 9 | tree.rs | File | | 3.0 KB | 2 days ago | 2 days ago +# => ---+---------------+------+----------+---------+------------+------------ + +ls | sort-by name | nth 5 +# => --------+------+----------+---------+------------+------------ +# => name | type | readonly | size | accessed | modified +# => --------+------+----------+---------+------------+------------ +# => str.rs | File | | 21.4 KB | 2 days ago | 2 days ago +# => --------+------+----------+---------+------------+------------ ``` ## Obtendo dados de uma tabela @@ -132,21 +132,21 @@ Vamos examinar alguns outros comandos para selecionar dados. Você pode ter se p Até agora, trabalhamos as tabelas reduzindo-as para somente o que precisamos. Às vezes queremos ir um passo além e só ver os valores das células e não de uma coluna toda. Digamos, por exemplo, que queremos somente uma lista com os nomes do arquivos. Para isso, usamos o comando `get`: ```nu -> ls | get name ----+--------------- - # | value ----+--------------- - 0 | add.rs - 1 | sum.rs - 2 | inc.rs - 3 | str.rs - 4 | skip.rs - 5 | textview.rs - 6 | binaryview.rs - 7 | edit.rs - 8 | tree.rs - 9 | sys.rs ----+--------------- +ls | get name +# => ---+--------------- +# => # | value +# => ---+--------------- +# => 0 | add.rs +# => 1 | sum.rs +# => 2 | inc.rs +# => 3 | str.rs +# => 4 | skip.rs +# => 5 | textview.rs +# => 6 | binaryview.rs +# => 7 | edit.rs +# => 8 | tree.rs +# => 9 | sys.rs +# => ---+--------------- ``` Agora temos os valores para cada um dos nomes de arquivo. @@ -154,21 +154,21 @@ Agora temos os valores para cada um dos nomes de arquivo. Parece muito com o comando `select` que vimos antes, então vamos colocá-lo aqui de novo para compararmos os dois: ```nu -> ls | select name ----+--------------- - # | name ----+--------------- - 0 | add.rs - 1 | sum.rs - 2 | inc.rs - 3 | str.rs - 4 | skip.rs - 5 | textview.rs - 6 | binaryview.rs - 7 | edit.rs - 8 | tree.rs - 9 | sys.rs ----+--------------- +ls | select name +# => ---+--------------- +# => # | name +# => ---+--------------- +# => 0 | add.rs +# => 1 | sum.rs +# => 2 | inc.rs +# => 3 | str.rs +# => 4 | skip.rs +# => 5 | textview.rs +# => 6 | binaryview.rs +# => 7 | edit.rs +# => 8 | tree.rs +# => 9 | sys.rs +# => ---+--------------- ``` São muito parecidos! Vamos tentar explicar a diferença entre esses dois comandos para esclarecer: @@ -189,46 +189,46 @@ Além de selecionar dados de uma tabela, podemos também alterar o que a tabela Podemos usar o comando `add` para adicionar uma nova coluna na tabela. Vejamos um exemplo: ```nu -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- ``` Vamos adicionar uma coluna chamada "next_edition" com o valor 2021: ```nu -> open rustfmt.toml | add next_edition 2021 ----------+-------------- - edition | next_edition ----------+-------------- - 2018 | 2021 ----------+-------------- +open rustfmt.toml | add next_edition 2021 +# => ---------+-------------- +# => edition | next_edition +# => ---------+-------------- +# => 2018 | 2021 +# => ---------+-------------- ``` Note que, se abrirmos o arquivo original, seu conteúdo permanece o mesmo: ```nu -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- ``` Alterações no Nu são alterações funcionais, isto é, atuam sobre os valores em si ao invés de tentar causar uma alteração permanente, o que nos permite executar muitos tipos diferentes de ações no nosso pipeline até que estejamos prontos para escrever o resultado com quaisquer mudanças, se assim quisermos. Aqui poderíamos salvar o resultado usando o comando `save`: ```nu -> open rustfmt.toml | add next_edition 2021 | save rustfmt2.toml -> open rustfmt2.toml ----------+-------------- - edition | next_edition ----------+-------------- - 2018 | 2021 ----------+-------------- +open rustfmt.toml | add next_edition 2021 | save rustfmt2.toml +open rustfmt2.toml +# => ---------+-------------- +# => edition | next_edition +# => ---------+-------------- +# => 2018 | 2021 +# => ---------+-------------- ``` ### Editando uma coluna @@ -247,12 +247,12 @@ open rustfmt.toml E agora vamos alterar a coluna `edition` para mostrar a próxima edição à qual esperamos dar suporte: ```nu -> open rustfmt.toml | edit edition 2021 ---------- - edition ---------- - 2021 ---------- +open rustfmt.toml | edit edition 2021 +# => --------- +# => edition +# => --------- +# => 2021 +# => --------- ``` ### Incrementando valores @@ -260,27 +260,27 @@ E agora vamos alterar a coluna `edition` para mostrar a próxima edição à qua Existe mais um comando do Nu que nos ajudará a trabalhar com números e versões: `inc`. ```nu -> open rustfmt.toml ---------- - edition ---------- - 2018 ---------- -> open rustfmt.toml | inc edition ---------- - edition ---------- - 2019 ---------- +open rustfmt.toml +# => --------- +# => edition +# => --------- +# => 2018 +# => --------- +open rustfmt.toml | inc edition +# => --------- +# => edition +# => --------- +# => 2019 +# => --------- ``` Como o valor em "edition" é um número, podemos usar `inc` para alterá-lo. Onde `inc` realmente se destaca é trabalhando com versões: ```nu -> open Cargo.toml | get package.version -0.1.3 -> open Cargo.toml | inc package.version --minor | get package.version -0.2.0 +open Cargo.toml | get package.version +# => 0.1.3 +open Cargo.toml | inc package.version --minor | get package.version +# => 0.2.0 ``` Quando estamos trabalhando com versões, podemos usar um dos modificadores a seguir para informar como incrementar a versão: