Rapide Tour d'Horizon
Le moyen le plus simple de découvrir ce que Nu peut faire est de commencer par quelques exemples, alors allons-y.
La première chose que vous remarquerez en exécutant une commande comme ls est qu'au lieu de recevoir un bloc de texte, vous obtenez un tableau structuré.
> ls
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ 404.html │ file │ 429 B │ 3 days ago │
│ 1 │ CONTRIBUTING.md │ file │ 955 B │ 8 mins ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 4 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 5 │ README.md │ file │ 213 B │ 3 days ago │
...Ce tableau fait plus qu'afficher le répertoire d'une manière différente. Comme les tableaux dans un tableur, ce tableau nous permet de travailler avec les données de manière plus interactive.
La première chose que nous allons faire est de trier notre tableau par taille. Pour ce faire, nous allons prendre la sortie de la commande ls et l'injecter à une commande qui peut trier les tableaux en fonction du contenu d'une colonne.
> ls | sort-by size | reverse
╭────┬───────────────────────┬──────┬───────────┬─────────────╮
│ # │ name │ type │ size │ modified │
├────┼───────────────────────┼──────┼───────────┼─────────────┤
│ 0 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 1 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
│ 2 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 4 │ CONTRIBUTING.md │ file │ 955 B │ 9 mins ago │
│ 5 │ books.md │ file │ 687 B │ 3 days ago │
...Vous pouvez voir que pour arriver à faire cela, nous n'avons pas passé d'arguments en ligne de commande à ls. À la place, nous avons utilisé la commande sort-by fournit par Nu pour trier la sortie de la commande ls. Pour afficher les fichiers les plus volumineux en haut, nous avons également utilisé reverse.
Nu fournit de nombreuses commandes qui peuvent fonctionner sur des tableaux. Par exemple, nous pourrions utiliser la commande where pour filtrer le contenu du tableau ls afin qu'il n'affiche que les fichiers de plus de 1 kilo-octet :
> ls | where size > 1kb
╭───┬───────────────────┬──────┬─────────┬────────────╮
│ # │ name │ type │ size │ modified │
├───┼───────────────────┼──────┼─────────┼────────────┤
│ 0 │ Gemfile │ file │ 1.1 KiB │ 3 days ago │
│ 1 │ Gemfile.lock │ file │ 6.9 KiB │ 3 days ago │
│ 2 │ LICENSE │ file │ 1.1 KiB │ 3 days ago │
│ 3 │ SUMMARY.md │ file │ 3.7 KiB │ 3 days ago │
╰───┴───────────────────┴──────┴─────────┴────────────╯Comme dans la philosophie Unix, le fait de pouvoir faire interagir les commandes entre elles nous permet de les combiner de nombreuses façons différentes. Voyons une autre commande :
> ps
╭─────┬───────┬───────┬──────────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├─────┼───────┼───────┼──────────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 87194 │ 1 │ mdworker_shared │ Sleep │ 0.00 │ 25.9 MB │ 418.0 GB │
│ 1 │ 87183 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.00 │ 59.9 MB │ 1.6 TB │
│ 2 │ 87182 │ 2314 │ Arc Helper (Renderer) │ Sleep │ 0.23 │ 224.3 MB │ 1.6 TB │
│ 3 │ 87156 │ 87105 │ Code Helper (Plugin) │ Sleep │ 0.00 │ 56.0 MB │ 457.4 GB │
...Vous connaissez peut-être la commande ps si vous avez utilisé Linux. Avec cette dernière, nous pouvons obtenir une liste de tous les processus en cours d'exécution sur le système, leur statut et leur nom. Nous pouvons également voir la charge CPU des processus.
Que faire si nous voulions afficher uniquement les processus qui utilisent activement le CPU ? Tout comme nous l'avons fait précédemment avec la commande ls, nous pouvons également travailler avec le tableau que la commande ps nous renvoie :
> ps | where cpu > 5
╭───┬───────┬───────┬─────────────────────────────────────────┬─────────┬───────┬──────────┬──────────╮
│ # │ pid │ ppid │ name │ status │ cpu │ mem │ virtual │
├───┼───────┼───────┼─────────────────────────────────────────┼─────────┼───────┼──────────┼──────────┤
│ 0 │ 86759 │ 86275 │ nu │ Running │ 6.27 │ 38.7 MB │ 419.7 GB │
│ 1 │ 89134 │ 1 │ com.apple.Virtualization.VirtualMachine │ Running │ 23.92 │ 1.5 GB │ 427.3 GB │
│ 2 │ 70414 │ 1 │ VTDecoderXPCService │ Sleep │ 19.04 │ 17.5 MB │ 419.7 GB │
│ 3 │ 2334 │ 1 │ TrackpadExtension │ Sleep │ 7.47 │ 25.3 MB │ 418.8 GB │
│ 4 │ 1205 │ 1 │ iTerm2 │ Sleep │ 11.92 │ 657.2 MB │ 421.7 GB │
╰───┴───────┴───────┴─────────────────────────────────────────┴─────────┴───────┴──────────┴──────────╯Jusqu'à présent, nous avons utilisé ls et ps pour lister des fichiers et des processus sous forme de tableau simple. Mais dans Nu, les données sont structurées et peuvent être imbriquées de manière arbitraire. Par exemple, explorons maintenant la commande help commands.
Exécuter help commands nous donne des informations sur toutes les commandes de Nushell sous forme de tableau. Cependant, la sortie sera assez grande, alors récupérons seulement la ligne pour la commande each.
> help commands | where name == each | first
╭──────────────┬────────────────────────────────────────────────────────────────────────────────────────────────╮
│ name │ each │
│ category │ filters │
│ command_type │ built-in │
│ usage │ Run a closure on each row of the input list, creating a new list with the results. │
│ │ ╭───┬──────────────────┬──────────────┬──────────┬───────────────────────────────────────────╮ │
│ params │ │ # │ name │ type │ required │ description │ │
│ │ ├───┼──────────────────┼──────────────┼──────────┼───────────────────────────────────────────┤ │
│ │ │ 0 │ closure │ closure(any) │ true │ The closure to run. │ │
│ │ │ 1 │ --help(-h) │ switch │ false │ Display the help message for this command │ │
│ │ │ 2 │ --keep-empty(-k) │ switch │ false │ keep empty result cells │ │
│ │ ╰───┴──────────────────┴──────────────┴──────────┴───────────────────────────────────────────╯ │
│ │ ╭───┬───────────┬───────────╮ │
│ input_output │ │ # │ input │ output │ │
│ │ ├───┼───────────┼───────────┤ │
│ │ │ 0 │ list<any> │ list<any> │ │
│ │ │ 1 │ table │ list<any> │ │
│ │ │ 2 │ any │ any │ │
│ │ ╰───┴───────────┴───────────╯ │
│ search_terms │ for, loop, iterate, map │
╰──────────────┴────────────────────────────────────────────────────────────────────────────────────────────────╯Ceci est un peu différent des tableaux que nous avons vus avant. Récupérer une seule ligne d'un tableau nous donne un record, qui est un ensemble de paires clé-valeur. Notez que les colonnes "params" et "input_output" contiennent en fait des tableaux plutôt que des valeurs simples. Pour afficher seulement l'une de ces colonnes, nous pouvons utiliser la commande get :
> help commands | where name == each | first | get params
╭───┬──────────────────┬──────────────┬──────────┬───────────────────────────────────────────╮
│ # │ name │ type │ required │ description │
├───┼──────────────────┼──────────────┼──────────┼───────────────────────────────────────────┤
│ 0 │ closure │ closure(any) │ true │ The closure to run. │
│ 1 │ --help(-h) │ switch │ false │ Display the help message for this command │
│ 2 │ --keep-empty(-k) │ switch │ false │ keep empty result cells │
╰───┴──────────────────┴──────────────┴──────────┴───────────────────────────────────────────╯La commande get nous permet de plonger dans le contenu des données structurées (un tableau, un record ou une liste). Nous pouvons même lui passer des colonnes imbriquées pour accéder aux données à n'importe quelle profondeur.
> help commands | where name == each | first | get params.name
╭───┬──────────────────╮
│ 0 │ closure │
│ 1 │ --help(-h) │
│ 2 │ --keep-empty(-k) │
╰───┴──────────────────╯Ces colonnes imbriquées sont appelées chemins de cellules. Nu prendra le chemin de la cellule et ira à la donnée correspondante dans un tableau, un record ou une liste. Les chemins de cellules prennent également en charge les numéros de ligne, nous aurions donc pu réécrire le pipeline précédent ainsi :
> help commands | where name == each | get 0.params.name
╭───┬──────────────────╮
│ 0 │ closure │
│ 1 │ --help(-h) │
│ 2 │ --keep-empty(-k) │
╰───┴──────────────────╯Obtenir de l'aide
Vous pouvez voir le texte d'aide pour n'importe laquelle des commandes intégrées de Nu en utilisant la commande help ou en passant l'option --help à une commande. Vous pouvez également rechercher un sujet en faisant help -f <topic>.
> help path
Explore and manipulate paths.
There are three ways to represent a path:
* As a path literal, e.g., '/home/viking/spam.txt'
* As a structured path: a table with 'parent', 'stem', and 'extension' (and
* 'prefix' on Windows) columns. This format is produced by the 'path parse'
subcommand.
* As an inner list of path parts, e.g., '[[ / home viking spam.txt ]]'.
Splitting into parts is done by the `path split` command.
All subcommands accept all three variants as an input. Furthermore, the 'path
join' subcommand can be used to join the structured path or path parts back into
the path literal.
Usage:
> path
Subcommands:
path basename - Get the final component of a path
path dirname - Get the parent directory of a path
path exists - Check whether a path exists
path expand - Try to expand a path to its absolute form
path join - Join a structured path or a list of path parts.
path parse - Convert a path into structured data.
path relative-to - Get a path as relative to another path.
path split - Split a path into parts by a separator.
path type - Get the type of the object a path refers to (e.g., file, dir, symlink)
Flags:
-h, --help
Display this help message