Nushell

Shell moderne à données structurées qui traite la sortie des commandes comme des tables et prend en charge les pipelines avec des données typées, le filtrage et les scripts multiplateformes.

Installation

Commande	Description
`brew install nushell`	Installer sur macOS avec Homebrew
`cargo install nu`	Installer depuis crates.io
`winget install nushell`	Installer sur Windows avec winget
`sudo apt install nushell`	Installer sur Debian/Ubuntu
`pacman -S nushell`	Installer sur Arch Linux
`nix-env -i nushell`	Installer sur NixOS
`nu`	Lancer Nushell
`nu --version`	Afficher la version installée
`nu -c "ls"`	Exécuter une seule commande et quitter
`nu script.nu`	Exécuter un fichier script Nushell
`chsh -s /usr/bin/nu`	Définir Nushell comme shell par défaut

Commandes de base

Informations système

Commande	Description
`sys`	Afficher les informations système complètes
`sys host`	Afficher les détails de l’hôte (nom, OS, noyau)
`sys mem`	Afficher l’utilisation de la mémoire
`sys cpu`	Afficher les informations du processeur
`sys disks`	Afficher l’utilisation des disques
`sys net`	Afficher les interfaces réseau
`sys temp`	Afficher les capteurs de température
`date now`	Afficher la date et l’heure actuelles
`date now \| format date "%Y-%m-%d"`	Formater la date actuelle
`$nu.home-path`	Afficher le chemin du répertoire personnel
`$nu.os-info`	Afficher les détails du système d’exploitation

Liste des fichiers

Commande	Description
`ls`	Lister les fichiers sous forme de table structurée
`ls -l`	Liste détaillée avec informations
`ls -a`	Afficher les fichiers cachés
`ls */.rs`	Glob récursif pour les fichiers Rust
`ls \| where size > 1mb`	Filtrer les fichiers de plus de 1 Mo
`ls \| where type == dir`	Filtrer les répertoires uniquement
`ls \| sort-by modified -r`	Trier par date de modification (plus récent en premier)
`ls \| sort-by size -r`	Trier par taille décroissante
`ls \| get name`	Obtenir uniquement la colonne des noms de fichiers

Gestion des processus

Commande	Description
`ps`	Lister les processus sous forme de table
`ps \| where cpu > 10`	Trouver les processus utilisant plus de 10% du CPU
`ps \| where name =~ "node"`	Trouver les processus par motif de nom
`ps \| sort-by mem -r \| first 10`	Top 10 des processus par mémoire
`ps \| where pid == 1234`	Trouver un processus par PID

Système d’aide

Commande	Description
`help`	Afficher l’aide générale
`help commands`	Lister toutes les commandes disponibles
`help ls`	Afficher l’aide pour une commande spécifique
`help operators`	Lister les opérateurs disponibles
`help escapes`	Afficher les séquences d’échappement de chaînes

Pipelines et filtres

Opérations sur les tables

Commande	Description
`ls \| select name size`	Sélectionner des colonnes spécifiques
`ls \| reject modified`	Supprimer des colonnes spécifiques
`ls \| rename filename filesize`	Renommer des colonnes
`ls \| first 5`	Obtenir les 5 premières lignes
`ls \| last 3`	Obtenir les 3 dernières lignes
`ls \| skip 10`	Ignorer les 10 premières lignes
`ls \| length`	Compter le nombre de lignes
`ls \| reverse`	Inverser l’ordre des lignes
`ls \| shuffle`	Mélanger l’ordre des lignes
`ls \| flatten`	Aplatir les tables imbriquées
`ls \| columns`	Lister les noms de colonnes

Filtrage et tri

Commande	Description
`ls \| where size > 1mb`	Filtrer par comparaison
`ls \| where name =~ "test"`	Filtrer par correspondance regex
`ls \| where name starts-with "src"`	Filtrer par préfixe
`ls \| where name ends-with ".md"`	Filtrer par suffixe
`ls \| where type in ["file" "dir"]`	Filtrer par liste de valeurs
`ls \| sort-by size -r`	Trier par ordre décroissant
`ls \| sort-by name -i`	Trier sans tenir compte de la casse
`ls \| uniq-by type`	Supprimer les doublons par colonne
`ls \| group-by type`	Regrouper les lignes par valeur de colonne

Transformation

Commande	Description
`ls \| each { \|it\| $it.name }`	Transformer chaque ligne
`ls \| par-each { \|it\| $it.name }`	Transformer en parallèle
`ls \| update size { \|it\| $it.size / 1kb }`	Mettre à jour les valeurs d’une colonne
`ls \| insert label { \|it\| $it.name + "-file" }`	Ajouter une nouvelle colonne
`ls \| reduce -f 0 { \|it, acc\| $acc + $it.size }`	Accumuler des valeurs
`ls \| enumerate`	Ajouter une colonne d’index
`ls \| window 3`	Fenêtre glissante de 3 lignes
`ls \| zip [1 2 3]`	Fusionner avec une autre liste
`ls \| transpose`	Échanger lignes et colonnes

Types de données

Primitifs

Commande	Description
`42`	Entier
`3.14`	Flottant
`"hello"`	Chaîne de caractères
`true` / `false`	Booléen
`null`	Valeur nulle
`2024-01-15`	Date
`5sec` / `3min` / `2hr`	Durée
`1kb` / `5mb` / `2gb`	Taille de fichier
`0b1010`	Littéral binaire
`0xff`	Littéral hexadécimal

Collections

Commande	Description
`[1 2 3]`	Liste
`[1 2 3] \| append 4`	Ajouter à la fin d’une liste
`[1 2 3] \| prepend 0`	Ajouter au début d’une liste
`{name: "Alice", age: 30}`	Enregistrement
`{a: 1} \| merge {b: 2}`	Fusionner des enregistrements
`[[name age]; ["Alice" 30] ["Bob" 25]]`	Littéral de table
`0..9`	Intervalle (0 à 9)
`0..<9`	Intervalle exclusif (0 à 8)
`0..2..10`	Intervalle avec pas (0, 2, 4, 6, 8, 10)

Conversions de types

Commande	Description
`"42" \| into int`	Chaîne vers entier
`"3.14" \| into float`	Chaîne vers flottant
`42 \| into string`	Nombre vers chaîne
`"true" \| into bool`	Chaîne vers booléen
`"2024-01-15" \| into datetime`	Chaîne vers date/heure
`1024 \| into filesize`	Nombre vers taille de fichier
`5 \| into duration --unit sec`	Nombre vers durée
`42 \| into binary`	Nombre vers binaire
`[1 2 3] \| into record`	Liste vers enregistrement
`{a: 1} \| into record`	Convertir en enregistrement

Travail avec les fichiers

Ouverture et analyse

Commande	Description
`open data.json`	Ouvrir et analyser un fichier JSON
`open data.csv`	Ouvrir et analyser un fichier CSV
`open data.yaml`	Ouvrir et analyser un fichier YAML
`open data.toml`	Ouvrir et analyser un fichier TOML
`open data.xml`	Ouvrir et analyser un fichier XML
`open data.tsv`	Ouvrir et analyser un fichier TSV
`open data.sqlite`	Ouvrir une base de données SQLite
`open file.txt`	Ouvrir en texte brut
`open data.json \| get users`	Ouvrir et naviguer dans les données

Sauvegarde et conversion

Commande	Description
`"hello" \| save hello.txt`	Sauvegarder une chaîne dans un fichier
`ls \| save files.json`	Sauvegarder une table en JSON
`ls \| save files.csv`	Sauvegarder une table en CSV
`ls \| save files.yaml`	Sauvegarder une table en YAML
`open data.json \| to csv`	Convertir JSON en CSV
`open data.csv \| to json`	Convertir CSV en JSON
`open data.json \| save data.yaml`	Convertir entre formats
`open data.csv \| save -f data.csv`	Forcer l’écrasement d’un fichier existant
`"line1\nline2" \| save -a log.txt`	Ajouter à un fichier

Manipulation de fichiers

Commande	Description
`open file.txt \| lines`	Diviser un fichier en lignes
`open file.txt \| lines \| length`	Compter les lignes d’un fichier
`open file.csv \| where status == "active"`	Filtrer les lignes d’un CSV
`open file.json \| select name email`	Sélectionner des champs d’un JSON
`open file.json \| to yaml \| save file.yaml`	Convertir JSON en YAML
`glob "*/.md" \| each { \|f\| open $f }`	Ouvrir tous les fichiers correspondants

Opérations sur les chaînes

Casse et formatage

Commande	Description
`"hello world" \| str upcase`	Convertir en majuscules
`"HELLO" \| str downcase`	Convertir en minuscules
`"hello" \| str capitalize`	Mettre la première lettre en majuscule
`" hello " \| str trim`	Supprimer les espaces
`"hello" \| str trim --char "h"`	Supprimer un caractère spécifique
`"hello" \| str reverse`	Inverser une chaîne

Recherche et remplacement

Commande	Description
`"hello world" \| str replace "world" "nu"`	Remplacer la première occurrence
`"aabaa" \| str replace -a "a" "x"`	Remplacer toutes les occurrences
`"hello world" \| str replace -r '\w+' 'word'`	Remplacer avec une regex
`"hello world" \| str contains "world"`	Vérifier si la chaîne contient
`"hello world" \| str starts-with "hello"`	Vérifier le préfixe
`"hello world" \| str ends-with "world"`	Vérifier le suffixe
`"hello world" \| str index-of "world"`	Trouver la position d’une sous-chaîne

Division et jointure

Commande	Description
`"hello world" \| split row " "`	Diviser par délimiteur
`"a,b,c" \| split row ","`	Diviser une chaîne style CSV
`"hello" \| split chars`	Diviser en caractères
`["hello" "world"] \| str join " "`	Joindre une liste en chaîne
`["a" "b" "c"] \| str join ","`	Joindre avec une virgule
`"hello" \| str length`	Obtenir la longueur d’une chaîne
`"hello world" \| str substring 0..5`	Extraire une sous-chaîne

Interpolation de chaînes

# Interpolation de base
let name = "World"
$"Hello, ($name)!"

# Interpolation d'expressions
$"Total: (1 + 2 + 3)"

# Chaînes multi-lignes
$"Line 1
Line 2
Line 3"

# Chaînes brutes (pas d'échappement)
r#'C:\Users\path'#

Commandes personnalisées

Définition de fonctions

Commande	Description
`def greet [name: string] { $"Hello, ($name)!" }`	Commande personnalisée de base
`def add [a: int, b: int] -> int { $a + $b }`	Commande avec annotations de type
`def greet [name = "World"] { ... }`	Commande avec paramètre par défaut
`def "git branches" [] { git branch \| lines }`	Nom de type sous-commande
`def --wrapped cmd [...rest] { ... }`	Accepter des arguments supplémentaires

Variables et flux de contrôle

Commande	Description
`let x = 42`	Variable immuable
`mut x = 0; $x = $x + 1`	Variable mutable
`const PI = 3.14159`	Constante de compilation
`if $x > 0 { "pos" } else { "neg" }`	Expression conditionnelle
`match $x { 1 => "one", 2 => "two", _ => "other" }`	Correspondance de motifs
`for item in [1 2 3] { print $item }`	Boucle for
`while $x < 10 { $x = $x + 1 }`	Boucle while
`loop { if $x > 10 { break }; $x += 1 }`	Boucle infinie avec break
`try { risky_op } catch { "failed" }`	Gestion des erreurs

Fonctions avancées

# Fonction avec paramètre drapeau
def greet [
  name: string       # Nom à saluer
  --excited (-e)     # Utiliser un point d'exclamation
] {
  if $excited {
    $"Hello, ($name)!"
  } else {
    $"Hello, ($name)."
  }
}

# Fonction avec paramètres rest
def sum [...nums: int] -> int {
  $nums | math sum
}

# Fonction avec entrée pipeline
def double-all [] {
  each { |x| $x * 2 }
}
# Utilisation : [1 2 3] | double-all

Mathématiques et agrégation

Commande	Description
`[1 2 3 4 5] \| math sum`	Somme des valeurs
`[1 2 3 4 5] \| math avg`	Moyenne des valeurs
`[1 2 3 4 5] \| math min`	Valeur minimale
`[1 2 3 4 5] \| math max`	Valeur maximale
`[1 2 3 4 5] \| math median`	Valeur médiane
`[1 2 3 4 5] \| math stddev`	Écart type
`[1 2 3 4 5] \| math variance`	Variance
`[1 2 3] \| math product`	Produit des valeurs
`10 \| math abs`	Valeur absolue
`10 \| math sqrt`	Racine carrée
`2 \| math round -p 2`	Arrondir à la précision
`10 \| math log 2`	Logarithme base 2

HTTP et réseau

Commande	Description
`http get https://api.example.com/data`	Requête GET
`http post https://api.example.com/data {name: "test"}`	Requête POST avec JSON
`http put https://api.example.com/data/1 {name: "updated"}`	Requête PUT
`http delete https://api.example.com/data/1`	Requête DELETE
`http get url --headers [Accept application/json]`	GET avec en-têtes personnalisés
`http get url \| get data`	GET et extraire un champ
`port 8080`	Vérifier si un port est utilisé

Exemple HTTP

# Récupérer et traiter une API JSON
let users = (http get "https://jsonplaceholder.typicode.com/users")
$users | select name email | first 5

# POST avec en-têtes et corps
http post "https://api.example.com/items" {
  name: "New Item"
  price: 29.99
} --headers [Authorization $"Bearer ($env.API_TOKEN)"]

Configuration

Chemins de configuration

Commande	Description
`$nu.config-path`	Afficher le chemin du fichier de configuration
`$nu.env-path`	Afficher le chemin de la configuration d’environnement
`$nu.default-config-dir`	Afficher le répertoire de configuration
`config nu`	Ouvrir la configuration dans l’éditeur
`config env`	Ouvrir la configuration d’environnement dans l’éditeur

Paramètres de configuration

Commande	Description
`$env.config.show_banner = false`	Désactiver la bannière de démarrage
`$env.config.buffer_editor = "vim"`	Définir l’éditeur pour Ctrl+O
`$env.config.history.file_format = "sqlite"`	Utiliser l’historique SQLite
`$env.config.history.max_size = 100_000`	Définir le nombre maximum d’entrées
`$env.config.completions.external.enable = true`	Activer les complétions externes
`$env.config.cursor_shape.emacs = "line"`	Définir la forme du curseur
`$env.config.footer_mode = "25"`	Afficher le pied de page pour les grandes tables
`$env.config.table.mode = "rounded"`	Définir le style de bordure des tables

Environnement et PATH

Commande	Description
`$env.PATH = ($env.PATH \| prepend "/usr/local/bin")`	Ajouter au début du PATH
`$env.PATH = ($env.PATH \| append "~/.local/bin")`	Ajouter à la fin du PATH
`$env.EDITOR = "vim"`	Définir une variable d’environnement
`alias ll = ls -l`	Créer un alias de commande
`source ~/.config/nushell/custom.nu`	Charger une configuration supplémentaire

Exemple de configuration

# env.nu — configuration de l'environnement
$env.PATH = ($env.PATH | split row (char esep)
  | prepend "/usr/local/bin"
  | prepend ($env.HOME | path join ".cargo" "bin")
  | append ($env.HOME | path join "go" "bin")
)

$env.EDITOR = "nvim"
$env.VISUAL = "nvim"
$env.PAGER = "less"

# config.nu — configuration du shell
$env.config = {
  show_banner: false
  buffer_editor: "nvim"
  table: {
    mode: rounded
    index_mode: auto
    trim: {
      methodology: wrapping
      wrapping_try_keep_words: true
    }
  }
  history: {
    file_format: "sqlite"
    max_size: 100_000
    sync_on_enter: true
    isolation: false
  }
  completions: {
    case_sensitive: false
    quick: true
    partial: true
    algorithm: "prefix"
    external: {
      enable: true
      max_results: 100
    }
  }
}

Modules et overlays

Commande	Description
`module greet { export def hello [] { "hi" } }`	Définir un module en ligne
`use greet hello`	Importer une commande depuis un module
`use greet *`	Importer tout depuis un module
`use utils.nu`	Importer depuis un fichier module
`overlay use spam`	Activer un overlay
`overlay hide spam`	Désactiver un overlay
`overlay list`	Lister les overlays actifs

Exemple de module

# fichier : utils.nu
export def "str kebab" [] {
  $in | str downcase | str replace -a " " "-"
}

export def "str title" [] {
  $in | split row " "
  | each { |w| $w | str capitalize }
  | str join " "
}

# Utilisation :
# use utils.nu
# "Hello World" | str kebab    # "hello-world"
# "hello world" | str title    # "Hello World"

Opérations sur les bases de données

Commande	Description
`open data.db`	Ouvrir une base de données SQLite
`open data.db \| query db "SELECT * FROM users"`	Exécuter une requête SQL
`open data.db \| query db "SELECT * FROM users WHERE age > 30"`	Requête filtrée
`open data.db \| schema`	Afficher le schéma de la base de données
`[[name age]; ["Alice" 30]] \| into sqlite data.db`	Créer un SQLite depuis une table
`ls \| into sqlite -t files data.db`	Sauvegarder une table dans SQLite

Système de plugins

Commande	Description
`plugin list`	Lister les plugins installés
`plugin add /path/to/plugin`	Enregistrer un plugin
`plugin rm plugin_name`	Supprimer un plugin
`plugin use plugin_name`	Charger un plugin
`cargo install nu_plugin_formats`	Installer le plugin formats
`cargo install nu_plugin_query`	Installer le plugin query
`cargo install nu_plugin_gstat`	Installer le plugin git status

Bonnes pratiques

Utiliser les données structurées — Nushell excelle lorsque vous travaillez avec des tables et des enregistrements plutôt que des chaînes brutes. Utilisez select, where et sort-by au lieu de grep et awk.
Typer les paramètres des fonctions — Ajoutez des annotations de type aux commandes personnalisées (name: string, count: int) pour détecter les erreurs tôt et améliorer l’autocomplétion.
Préférer les variables immuables — Utilisez let par défaut et n’utilisez mut que lorsque vous avez vraiment besoin de mutation. Cela évite les changements d’état accidentels dans les scripts.
Utiliser l’historique SQLite — Définissez $env.config.history.file_format = "sqlite" pour des recherches plus rapides, une meilleure résistance à la corruption et des métadonnées plus riches.
Tirer parti de par-each pour la performance — Lors du traitement de nombreux éléments indépendants, par-each s’exécute en threads parallèles et peut être significativement plus rapide que each.
Utiliser les modules pour le code réutilisable — Organisez les commandes personnalisées en fichiers de modules .nu et utilisez use plutôt que source. Les modules ont un espace de noms et des exports appropriés.
Utiliser into pour les conversions de types — Utilisez toujours la conversion de type explicite (into int, into string, etc.) plutôt que de compter sur la coercition implicite pour des scripts fiables.
Configurer les complétions — Activez les complétions externes et carapace pour la prise en charge de l’autocomplétion shell pour tous les outils CLI.
Utiliser l’interpolation de chaînes — Préférez $"Hello, ($name)!" à la concaténation de chaînes avec + pour un code plus propre et plus lisible.
Gérer les erreurs avec try/catch — Encapsulez les opérations qui peuvent échouer (accès fichier, HTTP, analyse) dans des blocs try { } catch { } pour des scripts robustes.
Tester avec describe — Utilisez expression | describe pour inspecter le type de n’importe quelle valeur pendant le développement et le débogage.
Utiliser les closures de manière cohérente — Les closures Nushell utilisent la syntaxe { |params| body }. Incluez toujours les caractères pipe même pour les paramètres uniques pour plus de clarté.