diff --git a/.vuepress/config.js b/.vuepress/config.js index 5bd551dd1a1..dcfafe89084 100755 --- a/.vuepress/config.js +++ b/.vuepress/config.js @@ -15,12 +15,14 @@ import { navbarDe, navbarEn, navbarEs, + navbarFr, navbarJa, navbarPtBR, navbarRU, navbarZhCN, sidebarDe, sidebarEn, + sidebarFr, sidebarEs, sidebarJa, sidebarPtBR, @@ -61,6 +63,11 @@ export default defineUserConfig({ title: 'Nushell', description: 'Eine neue Art von Shell.', }, + '/fr/': { + lang: 'fr-FR', + title: 'Nushell', + description: 'Un nouveau type de shell.', + }, '/es/': { lang: 'es-ES', title: 'Nushell', @@ -129,6 +136,13 @@ export default defineUserConfig({ navbar: navbarEs, sidebar: sidebarEs, }, + '/fr/': { + selectText: 'Langues', + selectLanguageName: 'Français', + editLinkText: 'Modifier la page sur GitHub', + navbar: navbarFr, + sidebar: sidebarFr, + }, '/ja/': { selectText: '言語', selectLanguageName: '日本語', diff --git a/.vuepress/configs/navbar/fr.ts b/.vuepress/configs/navbar/fr.ts new file mode 100644 index 00000000000..03b4999c033 --- /dev/null +++ b/.vuepress/configs/navbar/fr.ts @@ -0,0 +1,10 @@ +import type { NavbarConfig } from '@vuepress/theme-default'; + +export const navbarFr: NavbarConfig = [ + { text: 'Installez Nu !', link: '/fr/book/installation' }, + { text: 'Prise en main', link: '/fr/book/getting_started' }, + { + text: 'Documentation', + children: [{ text: 'Le Livre Nushell', link: '/fr/book/' }], + }, +]; diff --git a/.vuepress/configs/navbar/index.ts b/.vuepress/configs/navbar/index.ts index 5703043d438..c58d1ccfe58 100644 --- a/.vuepress/configs/navbar/index.ts +++ b/.vuepress/configs/navbar/index.ts @@ -1,6 +1,7 @@ export * from './de.js'; export * from './en.js'; export * from './es.js'; +export * from './fr.js'; export * from './ja.js'; export * from './pt-BR.js'; export * from './ru.js'; diff --git a/.vuepress/configs/sidebar/fr.ts b/.vuepress/configs/sidebar/fr.ts new file mode 100644 index 00000000000..15fc1bbc9e0 --- /dev/null +++ b/.vuepress/configs/sidebar/fr.ts @@ -0,0 +1,29 @@ +import type { SidebarConfig } from '@vuepress/theme-default'; +import { commandCategories } from './command_categories'; + +export const sidebarFr: SidebarConfig = { + '/fr/book/': [ + { + text: 'Introduction', + link: '/fr/book/README.md', + collapsible: false, + }, + { + text: 'Installation', + link: '/fr/book/installation.md', + collapsible: false, + children: ['/fr/book/default_shell.md'], + }, + { + text: 'Prise en main', + link: '/fr/book/getting_started.md', + collapsible: false, + children: [ + '/fr/book/quick_tour.md', + '/fr/book/moving_around.md', + '/fr/book/thinking_in_nu.md', + '/fr/book/cheat_sheet.md', + ], + }, + ], +}; diff --git a/.vuepress/configs/sidebar/index.ts b/.vuepress/configs/sidebar/index.ts index 5703043d438..c58d1ccfe58 100644 --- a/.vuepress/configs/sidebar/index.ts +++ b/.vuepress/configs/sidebar/index.ts @@ -1,6 +1,7 @@ export * from './de.js'; export * from './en.js'; export * from './es.js'; +export * from './fr.js'; export * from './ja.js'; export * from './pt-BR.js'; export * from './ru.js'; diff --git a/book/default_shell.md b/book/default_shell.md index 35aa1f74552..9a5e78de366 100644 --- a/book/default_shell.md +++ b/book/default_shell.md @@ -5,8 +5,8 @@ | Terminal | Platform | Instructions | | :--------------: | ------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | | GNOME Terminal | Linux & BSDs | Open `Edit > Preferences`. In the right-hand panel, select the `Command` tab, tick `Run a custom command instead of my shell`, and set `Custom command` to the path to Nu. | -| GNOME Console | Linux & BSDs | Type the command `gsettings set org.gnome.Console shell "['/usr/bin/nu']"` (replace `/usr/bin/nu` with the path to Nu). Equivalently, use [dconf Editor](https://apps.gnome.org/DconfEditor/) to edit the `/org/gnome/Console/shell` key. | -| Kitty | Linux & BSDs | Press `Ctrl`+`Shift`+`F2` to open `kitty.conf`. Go to `shell` variable, uncomment the line and replace the `.` with the path to Nu. | +| GNOME Console | Linux & BSDs | Type the command `gsettings set org.gnome.Console shell "['/usr/bin/nu']"` (replace `/usr/bin/nu` with the path to Nu). Equivalently, use [dconf Editor](https://apps.gnome.org/DconfEditor/) to edit the `/org/gnome/Console/shell` key. | +| Kitty | Linux & BSDs | Press `Ctrl`+`Shift`+`F2` to open `kitty.conf`. Go to `shell` variable, uncomment the line and replace the `.` with the path to Nu. | | Konsole | Linux & BSDs | Open `Settings > Edit Current Profile`. Set `Command` to the path to Nu. | | XFCE Terminal | Linux & BSDs | Open `Edit > Preferences`. Check `Run a custom command instead of my shell`, and set `Custom command` to the path to Nu. | | Terminal.app | macOS | Open `Terminal > Preferences`. Ensure you are on the `Profiles` tab, which should be the default tab. In the right-hand panel, select the `Shell` tab. Tick `Run command`, put the path to Nu in the textbox, and untick `Run inside shell`. | diff --git a/book/moving_around.md b/book/moving_around.md index 7bae929e7c2..d8135684879 100644 --- a/book/moving_around.md +++ b/book/moving_around.md @@ -153,7 +153,7 @@ Nu also provides some basic [filesystem commands](/commands/categories/filesyste ::: tip NOTE Under Bash and many other shells, most filesystem commands (other than `cd`) are actually separate binaries in the system. For instance, on a Linux system, `cp` is the `/usr/bin/cp` binary. In Nushell, these commands are built-in. This has several advantages: -- They work consistently on platforms where a binary version may not be available (e.g., Windows). This allows the creation of cross-platform scripts, modules, and custom commands. +- They work consistently on platforms where a binary version may not be available (e.g. Windows). This allows the creation of cross-platform scripts, modules, and custom commands. - They are more tightly integrated with Nushell, allowing them to understand Nushell types and other constructs - As mentioned in the [Quick Tour](quick_tour.html), they are documented in the Nushell help system. Running `help ` or ` --help` will display the Nushell documentation for the command. diff --git a/fr/README.md b/fr/README.md new file mode 100644 index 00000000000..4c73e17b214 --- /dev/null +++ b/fr/README.md @@ -0,0 +1,61 @@ +--- +home: true +heroImage: null +heroText: Nushell +tagline: Un nouveau type de shell +actionText: Prise en main → +actionLink: /fr/book/ +features: + - title: Les pipelines pour contrôler n'importe quel OS + details: Nu fonctionne sur Linux, macOS, BSD, et Windows. Apprennez-le une fois, utilisez le partout après. + - title: Tout est donnée + details: Les pipelines Nu utilisent des données structurées, ce qui vous permet de sélectionner, filtrer et trier de la même manière à chaque fois. Arrêtez de parser des chaînes de caractères et commencez à résoudre des problèmes. + - title: Des plugins puissants + details: Il est aisé d'étendre Nu en utilisant un système de plugin puissant. +--- + +Capture montrant l'utilisation de la commande ls + +### Nu fonctionne avec les données existantes + +Nu parle [JSON, YAML, SQLite, Excel, et plus](/book/loading_data.html), prêt à l'emploi. Il est facile d'injecter des données dans un pipeline Nu, qu'elles proviennent d'un fichier, d'une base de donnée, ou d'une API web : + +Capture montrant un fetch avec une API web + +### Nu a d'excellents messages d'erreur + +Nu opère sur des données typées, il détecte donc des bugs que les autres shells ne détectent pas. Et quand les choses plantent, Nu indique éxactement où et pourquoi : + +Capture montrant Nu détectant une erreur de type + +## Obtenir Nu + +Nushell est disponible sous forme de [binaires téléchargeables](https://github.com/nushell/nushell/releases), [via votre package manager préféré](https://repology.org/project/nushell/versions), dans [une GitHub Action](https://github.com/marketplace/actions/setup-nu), ou en [code source](https://github.com/nushell/nushell). Lisez [les instructions d'installation détaillées](/fr/book/installation.html) ou lancez-vous directement : + +#### macOS / Linux : + +##### Homebrew + +```shell +$ brew install nushell +``` + +##### Profil Nix + +```shell +$ nix profile install nixpkgs#nushell +``` + +#### Windows : + +```shell +$ winget install nushell +``` + +Après l'installation, lancez Nu en tapant `nu`. + +## Communauté + +Rejoingnez-nous [sur Discord](https://discord.gg/NtAbbGn) si vous avez une question à propos de Nu ! + +Vous pouvez contribuer à améliorer ce site en [nous donnant des retours](https://github.com/nushell/nushell.github.io/issues) ou en [créant une PR](https://github.com/nushell/nushell.github.io/pulls). diff --git a/fr/book/README.md b/fr/book/README.md new file mode 100644 index 00000000000..2d743d2d064 --- /dev/null +++ b/fr/book/README.md @@ -0,0 +1,64 @@ +# Introduction + +Bonjour, et bienvenue dans le projet Nushell. +L'objectif de ce projet est d'appliquer la philosophie Unix des shells, où les pipelines connectent de simples commandes entre elles, et de l'adapter au style de développement moderne. +Ainsi, plutôt que d'être simplement un shell ou un langage de programmation, Nushell réunit les deux en intégrant un langage de programmation riche et un shell complet dans un seul package. + +Nu s'inspire de nombreux domaines familiers : des shells traditionnels comme bash, des shells orientés objets comme PowerShell, des langages à typage graduel comme TypeScript, de la programmation fonctionnelle, de la programmation système, et plus encore. Cependant, plutôt que de chercher à tout faire, Nu concentre son énergie à bien faire certaines choses : + +- Être un shell flexible et multiplateforme avec une approche moderne +- Résoudre les problèmes comme un langage de programmation moderne qui travaille avec la structure de vos données +- Fournir des messages d'erreur clairs et un support IDE propre + +## Ce livre + +Le livre est divisé en chapitres qui sont eux-mêmes subdivisés en sections. +Vous pouvez cliquer sur les en-têtes des chapitres pour obtenir plus d'informations à leur sujet. + +- [Installation](/fr/book/installation.md), sans surprise, vous aide à installer Nushell sur votre système. +- [Prise en main](/fr/book/getting_started.md) vous guide dans vos débuts. Il explique également certains des principes de conception où Nushell diffère des shells typiques comme Bash. +- [Fondamentaux de Nu](/book/nu_fundamentals.md) explique les concepts de base du langage Nushell. +- [Programmer en Nu](/book/programming_in_nu.md) explore plus en profondeur les fonctionnalités du langage et montre plusieurs façons d'organiser et structurer votre code. +- [Nu en tant que Shell](/book/nu_as_a_shell.md) se concentre sur les fonctionnalités du shell, notamment la configuration et l'environnement. +- [Passer à Nu](/book/coming_to_nu.md) a pour but d'offrir un démarrage rapide aux utilisateurs venant d'autres shells ou langages. +- [Notes de Conception](/book/design_notes.md) fournit une explication approfondie de certains des choix de conception de Nushell. +- [Avancé (ou pas)](/book/advanced.md) aborde des sujets plus avancés (ils ne sont pas _si_ avancés que ça, n'hésitez pas à les consulter aussi !). + +## Les Nombreux Morceaux de Nushell + +Le projet Nushell se compose de plusieurs dépôts et sous-projets. +Vous pouvez tous les trouver sous [notre organisation sur GitHub](https://github.com/nushell). + +- Le dépôt principal de Nushell se trouve [ici](https://github.com/nushell/nushell). Il est divisé en plusieurs crates qui peuvent être utilisés comme des bibliothèques indépendantes dans votre propre projet, si vous le souhaitez. +- Le dépôt de notre page [nushell.sh](https://www.nushell.sh), y compris ce livre, se trouve [ici](https://github.com/nushell/nushell.github.io). +- Nushell dispose de son propre éditeur de ligne, qui [a son propre dépôt](https://github.com/nushell/reedline) +- [`nu_scripts`](https://github.com/nushell/nu_scripts) est un endroit pour partager des scripts et des modules avec d'autres utilisateurs, en attendant que nous ayons un gestionnaire de packages. +- [Nana](https://github.com/nushell/nana) est un effort expérimental pour explorer une interface utilisateur graphique pour Nushell. +- [Awesome Nu](https://github.com/nushell/awesome-nu) contient une liste d'outils qui fonctionnent avec l'écosystème Nushell : des plugins, des scripts, des extensions pour éditeurs, des intégrations tierces, etc. +- [Nu Showcase](https://github.com/nushell/showcase) est un espace pour partager des travaux autour de Nushell, que ce soit des blogs, des œuvres d'art ou autre chose. +- [Request for Comment (RFC)](https://github.com/nushell/rfcs) sert d'endroit pour proposer et discuter des changements de conception majeurs. Bien qu'il soit actuellement sous-utilisé, nous prévoyons de l'utiliser davantage à mesure que nous nous rapprochons de la version 1.0 et au-delà. + +## Contribuer + +Nous accueillons volontiers les contributions ! +[Comme vous pouvez le voir](#les-nombreux-morceaux-de-nushell), il y a de nombreux endroits où contribuer. +La plupart des dépôts contiennent un fichier `CONTRIBUTING.md` avec des conseils et des détails qui devraient vous aider à démarrer (sinon, réfléchissez à contribuer une correction !). + +Nushell lui-même est écrit en [Rust](https://www.rust-lang.org). +Cependant, vous n'avez pas besoin d'être un programmeur en Rust pour aider. +Si vous connaissez un peu le développement web, vous pouvez contribuer à l'amélioration de ce site web ou du projet Nana. +[Les Dataframes](dataframes.md) peuvent bénéficier de votre expertise en traitement de données. + +Si vous avez écrit un script sympa, un plugin, ou intégré Nushell quelque part, nous serions heureux de voir votre contribution à `nu_scripts` ou à Awesome Nu. +Découvrir des bugs avec des étapes pour les reproduire et les signaler sur GitHub est également une aide précieuse ! +Vous pouvez contribuer à Nushell simplement en utilisant Nushell ! + +Étant donné que Nushell évolue rapidement, ce livre a constamment besoin d'être mis à jour. +Contribuer à ce livre ne nécessite pas de compétences particulières, à part une familiarité de base avec le Markdown. +En outre, vous pouvez envisager de traduire des parties dans votre langue. + +## Communauté + +L'endroit principal pour discuter de quoi que ce soit qui concerne Nushell est notre [Discord](https://discord.com/invite/NtAbbGn). +Vous pouvez également nous suivre sur [Twitter](https://twitter.com/nu_shell) pour des news et des mises à jour. +Enfin, vous pouvez utiliser les discussions ou ouvrir des issues sur GitHub. diff --git a/fr/book/cheat_sheet.md b/fr/book/cheat_sheet.md new file mode 100644 index 00000000000..30840c543ea --- /dev/null +++ b/fr/book/cheat_sheet.md @@ -0,0 +1,522 @@ +# Cheat Sheet Nushell + +## Types de donnée + +convertir une string en un integer : + +```nu +"12" | into int +``` + +convertir la date actuelle en un fuseau horaire donné : + +```nu +date now | date to-timezone "Europe/London" +``` + +mettre à jour le language d'un record et si none est spécifié, insérer le language donné : + +```nu +{'name': 'nu', 'stars': 5, 'language': 'Python'} | upsert language 'Rust' +``` + +convertir une liste de strings en yaml : + +```nu +[one two three] | to yaml +``` + +afficher un tableau de données : + +```nu +[[framework, language]; [Django, Python] [Laravel, PHP]] +``` + +sélectionner deux colonnes nommées du tableau et afficher leurs valeurs : + +```nu +[{name: 'Robert' age: 34 position: 'Designer'} + {name: 'Margaret' age: 30 position: 'Software Developer'} + {name: 'Natalie' age: 50 position: 'Accountant'} +] | select name position +``` + +## Strings + +interpoler du texte : + +```nu +> let name = "Alice" +> $"greetings, ($name)!" +greetings, Alice! +``` + +découper le texte à chaque virgule et stocker la liste dans la variable `string_list` : + +```nu +> let string_list = "one,two,three" | split row "," +> $string_list +╭───┬───────╮ +│ 0 │ one │ +│ 1 │ two │ +│ 2 │ three │ +╰───┴───────╯ +``` + +vérifier si une string contient une sous-string : + +```nu +> "Hello, world!" | str contains "o, w" +true +``` + +concaténer plusieurs strings avec un délimiteur : + +```nu +> let str_list = [zero one two] +> $str_list | str join ',' +zero,one,two +``` + +découper le texte selon des indices : + +```nu +> 'Hello World!' | str substring 4..8 +o Wor +``` + +parser une string en des colonnes nommées : + +```nu +> 'Nushell 0.80' | parse '{shell} {version}' +╭───┬─────────┬─────────╮ +│ # │ shell │ version │ +├───┼─────────┼─────────┤ +│ 0 │ Nushell │ 0.80 │ +╰───┴─────────┴─────────╯ +``` + +parser des valeurs au format csv : + +```nu +> "acronym,long\nAPL,A Programming Language" | from csv +╭───┬─────────┬────────────────────────╮ +│ # │ acronym │ long │ +├───┼─────────┼────────────────────────┤ +│ 0 │ APL │ A Programming Language │ +╰───┴─────────┴────────────────────────╯ +``` + +appliquer une couleur à un texte dans un terminal de commande : + +```nu +> $'(ansi purple_bold)This text is a bold purple!(ansi reset)' +This text is a bold purple! +``` + +## Listes + +insérer une valeur à un index dans une list : + +```nu +> [foo bar baz] | insert 1 'beeze' +╭───┬───────╮ +│ 0 │ foo │ +│ 1 │ beeze │ +│ 2 │ bar │ +│ 3 │ baz │ +╰───┴───────╯ +``` + +mettre à jour une liste par index : + +```nu +> [1, 2, 3, 4] | update 1 10 +╭───┬────╮ +│ 0 │ 1 │ +│ 1 │ 10 │ +│ 2 │ 3 │ +│ 3 │ 4 │ +╰───┴────╯ +``` + +ajouter une valeur au début d'une liste : + +```nu +> let numbers = [1, 2, 3] +> $numbers | prepend 0 +╭───┬───╮ +│ 0 │ 0 │ +│ 1 │ 1 │ +│ 2 │ 2 │ +│ 3 │ 3 │ +╰───┴───╯ +``` + +ajouter une valeur à la fin d'une liste : + +```nu +> let numbers = [1, 2, 3] +> $numbers | append 4 +╭───┬───╮ +│ 0 │ 1 │ +│ 1 │ 2 │ +│ 2 │ 3 │ +│ 3 │ 4 │ +╰───┴───╯ +``` + +découper les premières valeurs d'une liste : + +```nu +> [cammomile marigold rose forget-me-not] | first 2 +╭───┬───────────╮ +│ 0 │ cammomile │ +│ 1 │ marigold │ +╰───┴───────────╯ +``` + +itérer sur une liste ; `elt` est la valeur actuelle de la liste : + +```nu +> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +> $planets | each { |elt| $"($elt) is a planet of the solar system" } +╭───┬─────────────────────────────────────────╮ +│ 0 │ Mercury is a planet of the solar system │ +│ 1 │ Venus is a planet of the solar system │ +│ 2 │ Earth is a planet of the solar system │ +│ 3 │ Mars is a planet of the solar system │ +│ 4 │ Jupiter is a planet of the solar system │ +│ 5 │ Saturn is a planet of the solar system │ +│ 6 │ Uranus is a planet of the solar system │ +│ 7 │ Neptune is a planet of the solar system │ +╰───┴─────────────────────────────────────────╯ +``` + +itérer sur une liste avec un index et une valeur : + +```nu +> $planets | enumerate | each { |elt| $"($elt.index + 1) - ($elt.item)" } +╭───┬─────────────╮ +│ 0 │ 1 - Mercury │ +│ 1 │ 2 - Venus │ +│ 2 │ 3 - Earth │ +│ 3 │ 4 - Mars │ +│ 4 │ 5 - Jupiter │ +│ 5 │ 6 - Saturn │ +│ 6 │ 7 - Uranus │ +│ 7 │ 8 - Neptune │ +╰───┴─────────────╯ +``` + +réduire la liste à une unique valeur ; `reduce` donne accès à un accumulateur qui est appliqué à chaque élément de la liste : + +```nu +> let scores = [3 8 4] +> $"total = ($scores | reduce { |elt, acc| $acc + $elt })" +total = 15 +``` + +réduire avec une valeur initiale (`--fold`) : + +```nu +> let scores = [3 8 4] +> $"total = ($scores | reduce --fold 1 { |elt, acc| $acc * $elt })" +total = 96 +``` + +donner accès au 3ème élément de la liste : + +```nu +> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +> $planets.2 +Earth +``` + +vérifier si une string dans la liste commence par `E` : + +```nu +> let planets = [Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune] +> $planets | any {|elt| $elt | str starts-with "E" } +true +``` + +découper les éléments qui satisfont la condition donnée : + +```nu +> let cond = {|x| $x < 0 }; [-1 -2 9 1] | take while $cond +╭───┬────╮ +│ 0 │ -1 │ +│ 1 │ -2 │ +╰───┴────╯ +``` + +## Tablaux + +trier un tableau : + +```nu +ls | sort-by size +``` + +trier un tableau, obtenir les premières lignes : + +```nu +ls | sort-by size | first 5 +``` + +concaténer deux tableaux avec les mêmes colonnes : + +```nu +> let $a = [[first_column second_column third_column]; [foo bar snooze]] +> let $b = [[first_column second_column third_column]; [hex seeze feeze]] +> $a | append $b + +╭───┬──────────────┬───────────────┬──────────────╮ +│ # │ first_column │ second_column │ third_column │ +├───┼──────────────┼───────────────┼──────────────┤ +│ 0 │ foo │ bar │ snooze │ +│ 1 │ hex │ seeze │ feeze │ +╰───┴──────────────┴───────────────┴──────────────╯ +``` + +retirer la dernière colonne d'un tableau : + +```nu +> let teams_scores = [[team score plays]; ['Boston Celtics' 311 3] ['Golden State Warriors', 245 2]] +> $teams_scores | drop column + +╭───┬───────────────────────┬───────╮ +│ # │ team │ score │ +├───┼───────────────────────┼───────┤ +│ 0 │ Boston Celtics │ 311 │ +│ 1 │ Golden State Warriors │ 245 │ +╰───┴───────────────────────┴───────╯ +``` + +## Fichiers et système de fichier + +ouvrir un fichier texte avec l'éditeur par défaut : + +```nu +start file.txt +``` + +sauvegarder une string dans un fichier texte : + +```nu +'lorem ipsum ' | save file.txt +``` + +ajouter une string à la fin d'un fichier texte : + +```nu +'dolor sit amet' | save --append file.txt +``` + +sauvegarder un record dans file.json : + +```nu +{ a: 1, b: 2 } | save file.json +``` + +rechercher des fichiers par nom de fichier de manière récursive : + +```nu +glob **/*.{rs,toml} --depth 2 +``` + +observer un fichier, exécuter une commande lorsqu'il change : + +```nu +watch . --glob=**/*.rs {|| cargo test } +``` + +## Commandes personnalisées + +commande personnalisée avec un paramètre de type string : + +```nu +> def greet [name: string] { + $"hello ($name)" +} +``` + +commande personnalisée avec un paramètre par défaut fixé à nushell : + +```nu +> def greet [name = "nushell"] { + $"hello ($name)" +} +``` + +passer un paramètre nommé en définissant un flag pour une commande personnalisée : + +```nu +> def greet [ + name: string + --age: int +] { + [$name $age] +} + +> greet world --age 10 +``` + +utiliser le flag comme un switch avec un racourcis (-a) pour l'âge : + +```nu +> def greet [ + name: string + --age (-a): int + --twice +] { + if $twice { + [$name $age $name $age] + } else { + [$name $age] + } +} +> greet -a 10 --twice hello +``` + +commande personnalisée qui prend un nombre quelconque d'arguments positionnels en utilisant des paramètres restants : + +```nu +> def greet [...name: string] { + print "hello all:" + for $n in $name { + print $n + } +} +> greet earth mars jupiter venus +hello all: +earth +mars +jupiter +venus +``` + +## Variables + +une variable immuable ne peut pas changer de valeur après déclaration : + +```nu +> let val = 42 +> print $val +42 +``` + +le shadowing d'une variable (déclaration d'une variable avec le même nom dans un autre scope) : + +```nu +> let val = 42 +> do { let val = 101; $val } +101 +> $val +42 +``` + +déclarer une variable mutable avec le mot-clé mut : + +```nu +> mut val = 42 +> $val += 27 +> $val +69 +``` + +les closures et définitions imbriquées ne peuvent pas capturer des variables mutables de leur environnement (erreurs) : + +```nu +> mut x = 0 +> [1 2 3] | each { $x += 1 } +Error: nu::parser::expected_keyword + + × Capture of mutable variable. + ╭─[entry #83:1:18] + 1 │ [1 2 3] | each { $x += 1 } + · ─┬ + · ╰── capture of mutable variable + ╰──── +``` + +une variable constante est immuable et est entièrement évaluée au moment du parsing : + +```nu +> const file = 'path/to/file.nu' +> source $file +``` + +utiliser l'opérateur point d'interrogation `?` pour retourner null au lieu d'une erreur si le chemin fourni est incorrect : + +```nu +> let files = (ls) +> $files.name?.0? +``` + +assigner le résultat d'un pipeline à une variable : + +```nu +> let big_files = (ls | where size > 10kb) +> $big_files +``` + +## Modules + +utiliser un module inline : + +```nu +> module greetings { + export def hello [name: string] { + $"hello ($name)!" + } + + export def hi [where: string] { + $"hi ($where)!" + } +} +> use greetings hello +> hello "world" +``` + +importer un module depuis un fichier et utiliser son environnement dans le scope actuel : + +```nu +# greetings.nu +export-env { + $env.MYNAME = "Arthur, King of the Britons" +} +export def hello [] { + $"hello ($env.MYNAME)" +} + +> use greetings.nu +> $env.MYNAME +Arthur, King of the Britons +> greetings hello +hello Arthur, King of the Britons! +``` + +utiliser la commande main dans un module : + +```nu +# greetings.nu +export def hello [name: string] { + $"hello ($name)!" +} + +export def hi [where: string] { + $"hi ($where)!" +} + +export def main [] { + "greetings and salutations!" +} + +> use greetings.nu +> greetings +greetings and salutations! +> greetings hello world +hello world! +``` diff --git a/fr/book/default_shell.md b/fr/book/default_shell.md new file mode 100644 index 00000000000..f8ac75f7c60 --- /dev/null +++ b/fr/book/default_shell.md @@ -0,0 +1,31 @@ +# Shell par défaut + +## Définir Nu comme shell par défaut sur votre terminal + +| Terminal | Plateforme | Instructions | +| :--------------: | ------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | +| GNOME Terminal | Linux & BSDs | Ouvrez `Édition > Préférences`. Dans le panneau de droite, sélectionnez l'onglet `Commande`, cochez `Exécuter une commande personnalisée à la place de mon shell`, et définissez `Commande personnalisée` par le chemin vers Nu. | +| GNOME Console | Linux & BSDs | Tapez la commande `gsettings set org.gnome.Console shell "['/usr/bin/nu']"` (remplacez `/usr/bin/nu` par le chemin vers Nu). De manière équivalente, vous pouvez utiliser [dconf Editor](https://apps.gnome.org/DconfEditor/) pour modifier la clé `/org/gnome/Console/shell`. | +| Kitty | Linux & BSDs | Appuyez sur `Ctrl`+`Shift`+`F2` pour ouvrir `kitty.conf`. Allez à la variable `shell`, décommentez la ligne et remplacez le `.` par le chemin vers Nu. | +| Konsole | Linux & BSDs | Ouvrez `Paramètres > Modifier le profil actuel`. Définissez `Commande` sur le chemin vers Nu. | +| XFCE Terminal | Linux & BSDs | Ouvrez `Édition > Préférences`. Cochez `Exécuter une commande personnalisée à la place de mon shell`, et définissez `Commande personnalisée` sur le chemin vers Nu. | +| Terminal.app | macOS | Ouvrez `Terminal > Préférences`. Assurez-vous d'être sur l'onglet `Profils`, qui devrait être l'onglet par défaut. Dans le panneau de droite, sélectionnez l'onglet `Shell`. Cochez `Exécuter une commande`, insérez le chemin vers Nu dans la zone de texte, et décochez `Exécuter dans le shell`. | +| iTerm2 | macOS | Ouvrez `iTerm > Préférences`. Sélectionnez l'onglet `Profils`. Dans le panneau de droite sous `Commande`, changez la valeur du menu déroulant de `Shell de connexion` à `Shell personnalisé`, et insérez le chemin vers Nu dans la zone de texte. | +| Windows Terminal | Windows | Appuyez sur `Ctrl`+`,` pour ouvrir `Paramètres`. Allez à `Ajouter un nouveau profil > Nouveau profil vide`. Remplissez le 'Nom' et entrez le chemin vers Nu dans la zone de texte 'Ligne de commande'. Allez à l'option `Démarrage` et sélectionnez Nu comme 'Profil par défaut'. Appuyez sur `Enregistrer`. | + +## Définir Nu comme shell de connexion (Linux, BSD & macOS) + +::: warning +Nu est encore en développement et n'est pas destiné à être compatible POSIX. +Soyez conscient que certains programmes sur votre système peuvent supposer que votre shell de connexion est compatible [POSIX](https://fr.wikipedia.org/wiki/POSIX). +Briser cette supposition peut entraîner des problèmes inattendus. +::: + +Pour définir le shell de connexion, vous pouvez utiliser la commande [`chsh`](https://linux.die.net/man/1/chsh). +Certaines distributions Linux ont une liste de shells valides située dans `/etc/shells` et empêcheront le changement de shell jusqu'à ce que Nu figure sur la liste blanche. +Vous pourriez voir une erreur similaire à celle ci-dessous si vous n'avez pas mis à jour le fichier `shells` : + +@[code](@snippets/installation/chsh_invalid_shell_error.sh) + +Vous pouvez ajouter Nu à la liste des shells autorisés en ajoutant le binaire de Nu au fichier `shells`. +Le chemin à ajouter peut être trouvé avec la commande `which nu`, généralement il s'agit de `$HOME/.cargo/bin/nu`. diff --git a/fr/book/getting_started.md b/fr/book/getting_started.md new file mode 100644 index 00000000000..52bc17515cb --- /dev/null +++ b/fr/book/getting_started.md @@ -0,0 +1,7 @@ +# Prise en main + +Commençons ! :elephant: + +Les sections suivantes vous donneront un [un tour d'horizon rapide de Nushell avec des examples](quick_tour.md) (y compris comment obtenir de l'aide depuis Nushell) et vous montreront comment [naviguer dans votre système de fichiers](moving_around.md). + +Ensuite, comme Nushell adopte des choix de conception qui diffèrent assez des shells typiques ou des langages de scripting dynamiques, assurez-vous de consulter [Penser en Nu](thinking_in_nu.md) où nous expliquons certains de ces concepts. diff --git a/fr/book/installation.md b/fr/book/installation.md new file mode 100644 index 00000000000..427d49919d2 --- /dev/null +++ b/fr/book/installation.md @@ -0,0 +1,99 @@ +# Installer Nu + +Il existe de nombreuses façons de démarrer avec Nu. Vous pouvez télécharger des binaires précompilés depuis notre [page de release](https://github.com/nushell/nushell/releases), [utiliser votre gestionnaire de paquets préféré](https://repology.org/project/nushell/versions), ou compiler à partir des sources. + +Le binaire principal de Nushell est nommé `nu` (ou `nu.exe` sous Windows). Après installation, vous pouvez le lancer en tapant `nu`. + +@[code](@snippets/installation/run_nu.sh) + +## Binaires précompilés + +Les binaires de Nu sont publiés pour Linux, macOS et Windows [avec chaque release sur GitHub](https://github.com/nushell/nushell/releases). Il vous suffit de les télécharger, d'extraire les binaires, puis de les copier à un emplacement sur votre PATH. + +## Gestionnaires de paquets + +Nu est disponible via plusieurs gestionnaires de paquets : + +[![Statut du packaging](https://repology.org/badge/vertical-allrepos/nushell.svg)](https://repology.org/project/nushell/versions) + +Pour macOS et Linux, [Homebrew](https://brew.sh/) est un choix populaire (`brew install nushell`). + +Pour Windows : + +- [Winget](https://docs.microsoft.com/fr-fr/windows/package-manager/winget/) (`winget install nushell`) +- [Chocolatey](https://chocolatey.org/) (`choco install nushell`) +- [Scoop](https://scoop.sh/) (`scoop install nu`) + +Installation multiplateforme : + +- [npm](https://www.npmjs.com/) (`npm install -g nushell` Notez que les plugins Nu ne sont pas inclus si vous installez de cette manière) + +## Compiler à partir des sources + +Vous pouvez également compiler Nu à partir des sources. Tout d'abord, vous devrez configurer la toolchain Rust et ses dépendances. + +### Installation d'une suite de compilateurs + +Pour que Rust fonctionne correctement, vous devrez avoir une suite de compilateurs compatible installée sur votre système. Les suites de compilateurs recommandées sont : + +- Linux : GCC ou Clang +- macOS : Clang (installez Xcode) +- Windows : MSVC (installez [Visual Studio](https://visualstudio.microsoft.com/vs/community/) ou les [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022)) + - Assurez-vous d'installer le workload "Desktop development with C++" + - Toute édition de Visual Studio fonctionnera (Community est gratuite) + +### Installation de Rust + +Si vous n'avez pas encore Rust sur votre système, la meilleure façon de l'installer est via [rustup](https://rustup.rs/). Rustup est un outil de gestion des installations de Rust, y compris la gestion de l'utilisation de différentes versions de Rust. + +Nu nécessite actuellement la **dernière version stable (1.66.1 ou plus récente)** de Rust. Le mieux est de laisser `rustup` trouver la version correcte pour vous. Lorsque vous ouvrez `rustup` pour la première fois, il vous demandera quelle version de Rust vous souhaitez installer : + +@[code](@snippets/installation/rustup_choose_rust_version.sh) + +Une fois prêt, appuyez sur 1 puis sur Entrée. + +Si vous préférez ne pas installer Rust via `rustup`, vous pouvez également l'installer via d'autres méthodes (par exemple, depuis un paquet dans une distro Linux). Assurez-vous simplement d'installer une version de Rust qui soit 1.66.1 ou plus récente. + +### Dépendances + +#### Debian/Ubuntu + +Vous devrez installer les paquets "pkg-config", "build-essential" et "libssl-dev" : + +@[code](@snippets/installation/install_pkg_config_libssl_dev.sh) + +#### Distros basées sur RHEL + +Vous devrez installer "libxcb", "openssl-devel" et "libX11-devel" : + +@[code](@snippets/installation/install_rhel_dependencies.sh) + +#### macOS + +En utilisant [Homebrew](https://brew.sh/), vous devrez installer "openssl" et "cmake" en utilisant : + +@[code](@snippets/installation/macos_deps.sh) + +### Compiler en utilisant [crates.io](https://crates.io) + +Les releases de Nu sont publiées sur le populaire gestionnaire de paquet de Rust [crates.io](https://crates.io/). Cela facilite la compilation et l'installation de la dernière release de Nu avec `cargo`: + +@[code](@snippets/installation/cargo_install_nu.sh) + +C'est tout ! L'outil `cargo` se chargera de télécharger les sources de Nu et de ses dépendances, de les compiler, et d'installer Nu à l'emplacement des binaires de cargo. + +### Compiler à partir du dépôt GitHub + +Vous pouvez également compiler Nu à partir des dernières sources sur GitHub. Cela vous donne un accès immédiat aux dernières fonctionnalités et corrections de bugs. Tout d'abord, clonez le dépôt : + +@[code](@snippets/installation/git_clone_nu.sh) + +Nous pouvons à présent compiler et exécuter Nu avec : + +@[code](@snippets/installation/build_nu_from_source.sh) + +Vous pouvez également compiler et exécuter Nu en mode release, ce qui active plus d'optimisations : + +@[code](@snippets/installation/build_nu_from_source_release.sh) + +Les personnes familières avec Rust pourraient se demander pourquoi nous faisons une étape de "build" et une étape de "run" séparément alors que "run" effectue une compilation par défaut. Cela permet de contourner une limitation de la nouvelle option `default-run` dans Cargo, et de s'assurer que tous les plugins sont bien compilés, bien que cela ne soit peut-être plus nécessaire à l'avenir. diff --git a/fr/book/moving_around.md b/fr/book/moving_around.md new file mode 100644 index 00000000000..dbee5d10e01 --- /dev/null +++ b/fr/book/moving_around.md @@ -0,0 +1,158 @@ +# Naviguer dans le Système + +Une caractéristique intrinsèque d'un shell est la capacité à naviguer et interagir avec le système de fichiers. Nushell ne fait évidemment pas exception. Voici quelques commandes courantes que vous pourriez utiliser pour interagir avec le système de fichiers : + +## Affichage du Contenu d'un Répertoire + +@[code](@snippets/moving_around/ls_example.sh) + +Comme vu dans d'autres chapitres, la commande [`ls`](/commands/docs/ls.md) retourne le contenu d'un répertoire. La commande `ls` de Nushell retourne les éléments sous forme de [tableau](/book/types_of_data.html#tables). + +La commande [`ls`](/commands/docs/ls.md) accepte également un argument optionnel pour spécifier ce que vous souhaitez afficher. Par exemple, nous pouvons lister les fichiers se terminant par « .md » : + +@[code](@snippets/moving_around/ls_shallow_glob_example.sh) + +## Patterns de Glob (wildcards) + +L'astérisque (`*`) dans l'argument optionnel `*.md` est parfois appelé caractère générique, wildcard, ou glob. Il nous permet de matcher n'importe quoi. Vous pouvez lire ce glob `*.md` comme _"match n'importe quel nom de fichier, du moment qu'il se termine par '.md'."_ + +Le glob le plus général est `*`, qui matchera tous les chemins. Vous verrez souvent ce pattern utilisé comme partie d'un autre pattern, par exemple `*.bak` et `temp*`. + +Nushell prend également en charge une double `*`, qui traversera les chemins imbriqués dans d'autres répertoires. Par exemple, `ls **/*` listera tous les chemins non cachés sous le répertoire courant. + +```nu + ls **/*.md +╭───┬───────────────────────────────┬──────┬──────────┬──────────────╮ +│ # │ name │ type │ size │ modified │ +├───┼───────────────────────────────┼──────┼──────────┼──────────────┤ +│ 0 │ CODE_OF_CONDUCT.md │ file │ 3.4 KiB │ 5 months ago │ +│ 1 │ CONTRIBUTING.md │ file │ 11.0 KiB │ a month ago │ +│ 2 │ README.md │ file │ 12.0 KiB │ a month ago │ +│ 3 │ SECURITY.md │ file │ 2.6 KiB │ 5 hours ago │ +│ 4 │ benches/README.md │ file │ 249 B │ 2 months ago │ +│ 5 │ crates/README.md │ file │ 795 B │ 5 months ago │ +│ 6 │ crates/nu-cli/README.md │ file │ 388 B │ 5 hours ago │ +│ 7 │ crates/nu-cmd-base/README.md │ file │ 262 B │ 5 hours ago │ +│ 8 │ crates/nu-cmd-extra/README.md │ file │ 669 B │ 2 months ago │ +│ 9 │ crates/nu-cmd-lang/README.md │ file │ 1.5 KiB │ a month ago │ +╰───┴───────────────────────────────┴──────┴──────────┴──────────────╯ +``` + +Ici, nous cherchons tout fichier se terminant par ".md". Les doubles astérisques spécifient en outre _"dans n'importe quel répertoire à partir d'ici"_. + +La syntaxe de globbing de Nushell prend non seulement en charge `*`, mais aussi les matching de [caractères uniques avec `?` et les groupes de caractères avec `[...]`](https://docs.rs/nu-glob/latest/nu_glob/struct.Pattern.html). + +Pour échapper les patterns `*`, `?`, et `[]`, on les entoure de guillemets simples, doubles ou [string raw](working_with_strings.md#raw-strings). Par exemple, pour afficher le contenu d'un répertoire nommé `[slug]`, utilisez `ls "[slug]"` ou `ls '[slug]'`. + +Cependant, les chaînes entre _backtick_ ne permettent pas d'échapper les globs. Comparez les scénarios suivants : + +1. Sans guillemets : pattern de Glob + + Une [chaîne contenant des simples mots](/book/working_with_strings.html#bare-word-strings) sans guillemets contenent des caractères glob est interprétée comme un pattern de glob. Par exemple, la commande suivante supprimera tous les fichiers dans le répertoire courant contenant `myfile` dans leur nom : + + ```nu + rm *myfile* + ``` + +2. Avec guillemets : chaine literal avec astérisques + + Avec des guillemets simples et ou doubles, ou en utilisant des [strings raw](/book/working_with_strings.html#raw-strings), une _string_ littérale, avec les astérisques (ou tout autre catactère de glob) échappés, est passée à la commande. Le résultat n'est pas un glob. La commande suivante va seulement supprimer un fichier littéralement nommé `*myfile*` (astérisques inclus). D'autres fichiers avec `myfile` dans leur nom ne seront pas affectés : + + ```nu + rm "*myfile*" + ``` + +3. Entre backticks : pattern de Glob + + Les astérisques (et autre patterns de glob) à l'intérieur d'une [string entre backticks](/book/working_with_strings.html#backtick-quoted-strings) sont interprétés comme pattern de glob. Notez que le comportement est le même que dans l'exemple d'une chaîne sans guillemets, #1 ci-dessus. + + La suivante, comme dans le premier exemple, supprime tous les fichiers contenant `myfile` dans leur nom dans le répertoire actuel . + + ```nu + rm `*myfile*` + ``` + +::: tip +Nushell inclue également une [commande `glob`](https://www.nushell.sh/commands/docs/glob.html) dédiée, qui prend en charge des scénarios de globbing plus complexes. +::: + +### Conversion de Chaînes en Globs + +Les techniques utilisant des guillemets ci-dessus sont utiles pour construire des globs littéraux, mais vous pourriez avoir besoin de construire des globs de mamière programmable. +Voici quelques techniques pour faire cela : + +1. `into glob` + + La [commande `into glob`](/commands/docs/into_glob.html) peut être utilisée pour convertir pour convertir une chaine (ou d'autres types) en glob. Par exemple : + + ```nu + # Find files whose name includes the current month in the form YYYY-mm + let current_month = (date now | format date '%Y-%m') + let glob_pattern = ($"*($current_month)*" | into glob) + ls $glob_pattern + ``` + +2. L'opérateur de propagation combiné avec la [commande `glob`](/commands/docs/glob.html) : + + La [commande `glob`](/commands/docs/glob.html) (note : différente de `into glob`) produit une [`liste`](/book/types_of_data.html#lists) de noms de fichiers qui matchent le pattern de glob. Cette liste peut être étendue et passée aux commandes du système de fichiers en utilisant [l'opérateur de propagation](/book/operators.html#spread-operator) : + + ```nu + # Find files whose name includes the current month in the form YYYY-mm + let current_month = (date now | format date '%Y-%m') + ls ...(glob $"*($current_month)*") + ``` + +3. Forcer le type de `glob` via des annotations : + + ```nu + # Find files whose name includes the current month in the form YYYY-mm + let current_month = (date now | format date '%Y-%m') + let glob_pattern: glob = ($"*($current_month)*") + ls $glob_pattern + ``` + +## Changer le Répertoire Courant + +@[code](@snippets/book/moving_around/cd_example.nu) + +Pour changer du répertoire courant vers un nouveau, utilisez la commande [`cd`](/commands/docs/cd.md). + +Changer le répertoire courant peut également être effectué si [`cd`](/commands/docs/cd.md) est ommis et seul un chemin est fourni : + +@[code](@snippets/book/moving_around/cd_without_command_example.nu) + +Exactement comme dans d'autres shells, vous pouvez utiliser le nom d'un répertoire, ou si vous voulez remonter d'un répertoire, vous pouvez utiliser le raccourcis `..`. + +Vous pouvez ajouter des points supplémentaires pour remonter de niveaux supplémentaires : + +@[code](@snippets/book/moving_around/multiple_cd_levels.nu) + +::: tip +Les raccourcis multi-points sont disponibles à la fois pour les commandes Nushelles, [les commandes du système de fichier](//commands/categories/filesystem.html) et les commandes externes. Par exemple, executer `^stat ....` sur un système Linux/Unix affichera que le chemin est étendu à `../../../..` +::: + +Vous pouvez aussi combiner des niveaux de répertoires relatifs avec des noms de répertoires : + +@[code](@snippets/book/moving_around/relative_cd_levels.nu) + +::: tip CONSEIL IMPORTANT +Changer le répertoire courant avec [`cd`](/commands/docs/cd.md) change aussi la variable d'environnement `PWD`. Cela signifie que le changement de répertoire est restreint au scope actuel (par ex. bloc ou closure). Une fois que vous êtes sortis de ce bloc, vous allez retourner au répertoire précédent. Vous pouvez en apprendre plus au chapitre [Environnement](/book/environment.md). +::: + +## Commandes de Système de Fichiers + +Nu met également à disposition des commandes basiques de [système de fichiers](/commands/categories/filesystem.html) qui fonctionnent sur toutes les plateformes, telles que : + +- [`mv`](/commands/docs/mv.md) pour renommer ou déplacer un fichier ou répertoire vers un nouvel emplacement +- [`cp`](/commands/docs/cp.md) pour copier un élément vers un nouvel emplacement +- [`rm`](/commands/docs/rm.md) pour supprimer des éléments du système de fichier +- [`mkdir`](/commands/docs/mkdir.md) pour créer un nouveau répertoire + +::: tip NOTE +Sous Bash et de nombreux autres shells, la plupart des commandes de système de fichiers (excepté `cd`) sont en fait des binaires séparés dans le système. Par exemple, sur un système Linux, `cp` est le binaire `/usr/bin/cp`. Dans Nushell, ces commandes sont intégrées. Cela a plusieurs avantages : + +- Elles fonctionnent de manière cohérente sur les platefoems où une version binaire n'est peut-être pas disponible (par ex. Windows). Cela permet la création de scripts, modules ou commandes personnalisées cross-platform. +- Elles sont intégrées plus étroitement avec Nushell, leur donnant la possibilité de comprendres les types et constructions de Nushell +- Comme mentionné dans le [Rapide Tour d'Horizon](quick_tour.html), elles sont documentées dans le système d'aide de Nushell. Executer `help ` ou ` --help` affichera la documentation Nushell pour ces commandes. + +Bien que l'utilisation des versions intégrées à Nushell soit typiquement recommandé, il est possible d'accéder aux binaires Linux. Lisez [S'échapper vers le système](/book/escaping.html#escaping-to-the-system) pour les détails. diff --git a/fr/book/quick_tour.md b/fr/book/quick_tour.md new file mode 100644 index 00000000000..10974a67a40 --- /dev/null +++ b/fr/book/quick_tour.md @@ -0,0 +1,53 @@ +# 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`](/commands/docs/ls.md) est qu'au lieu de recevoir un bloc de texte, vous obtenez un tableau structuré. + +@[code](@snippets/introduction/ls_example.sh) + +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`](/commands/docs/ls.md) et l'injecter à une commande qui peut trier les tableaux en fonction du contenu d'une colonne. + +@[code](@snippets/introduction/ls_sort_by_reverse_example.sh) + +Vous pouvez voir que pour arriver à faire cela, nous n'avons pas passé d'arguments en ligne de commande à [`ls`](/commands/docs/ls.md). À la place, nous avons utilisé la commande [`sort-by`](/commands/docs/sort-by.md) fournit par Nu pour trier la sortie de la commande [`ls`](/commands/docs/ls.md). Pour afficher les fichiers les plus volumineux en haut, nous avons également utilisé [`reverse`](/commands/docs/reverse.md). + +Nu fournit de nombreuses commandes qui peuvent fonctionner sur des tableaux. Par exemple, nous pourrions utiliser la commande [`where`](/commands/docs/where.md) pour filtrer le contenu du tableau [`ls`](/commands/docs/ls.md) afin qu'il n'affiche que les fichiers de plus de 1 kilo-octet : + +@[code](@snippets/introduction/ls_where_example.sh) + +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 : + +@[code](@snippets/introduction/ps_example.sh) + +Vous connaissez peut-être la commande [`ps`](/commands/docs/ps.md) 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`](/commands/docs/ls.md), nous pouvons également travailler avec le tableau que la commande [`ps`](/commands/docs/ps.md) nous renvoie : + +@[code](@snippets/introduction/ps_where_example.sh) + +Jusqu'à présent, nous avons utilisé [`ls`](/commands/docs/ls.md) et [`ps`](/commands/docs/ps.md) 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`](/commands/docs/help_commands.md). + +Exécuter [`help commands`](/commands/docs/help_commands.md) 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`. + +@[code](@snippets/introduction/help_commands_each_example.nu) + +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](/book/types_of_data.html#records), 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`](/commands/docs/get.md) : + +@[code](@snippets/introduction/help_commands_get_example.nu) + +La commande [`get`](/commands/docs/get.md) 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. + +@[code](@snippets/introduction/help_commands_get_nested_example.nu) + +Ces colonnes imbriquées sont appelées [chemins de cellules](/book/types_of_data.html#cell-paths). 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 : + +@[code](@snippets/introduction/help_commands_get_cell_path_example.nu) + +### 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`](/commands/docs/help.md) ou en passant l'option `--help` à une commande. Vous pouvez également rechercher un sujet en faisant `help -f `. + +@[code](@snippets/introduction/help_example.sh) diff --git a/fr/book/thinking_in_nu.md b/fr/book/thinking_in_nu.md new file mode 100644 index 00000000000..96674799859 --- /dev/null +++ b/fr/book/thinking_in_nu.md @@ -0,0 +1,94 @@ +# Penser en Nu + +Pour vous aider à comprendre Nushell et à en tirer le meilleur, nous avons écrit cette section sur "penser en Nushell". En apprenant à penser en Nushell et à utiliser les patterns que Nushell propose, vous rencontrerez moins de problèmes au démarrage et vous serez mieux préparé pour réussir. + +Alors, que signifie penser en Nushell ? Voici quelques sujets courants qui reviennent chez les nouveaux utilisateurs de Nushell. + +## Nushell n'est pas bash + +Nushell est à la fois un langage de programmation et un shell. Pour cette raison, Nushell possède sa propre manière de fonctionner avec les fichiers, les dossiers, les sites web, et plus encore. Nous l'avons conçu pour fonctionner en étroite collaboration avec ce que vous connaissez peut-être d'autres shells. Les pipelines fonctionnent en reliant deux commandes ensemble : + +```nu +> ls | length +``` + +Nushell, par exemple, prend également en charge d'autres fonctionnalités courantes comme la récupération du code de sortie des commandes précédemment exécutées. + +Bien que Nushell dispose de ces commodités, Nushell n'est pas bash. La manière de travailler avec bash, et le style POSIX en général, ne sont pas pris en charge par Nushell. Par exemple, dans bash, vous pourriez utiliser : + +```sh +> echo "hello" > output.txt +``` + +En Nushell, nous utilisons `>` comme l'opérateur supérieur à. Cela s'accorde mieux avec l'aspect langage de Nushell. Au lieu de cela, vous redirigez vers une commande qui a pour tâche de sauvegarder le contenu : + +```nu +> "hello" | save output.txt +``` + +**Penser en Nushell :** La manière dont Nushell voit les données est que celles-ci circulent à travers le pipeline jusqu'à atteindre l'utilisateur ou être traitées par une commande finale. Vous pouvez simplement taper des données, des chaînes de caractères aux listes et records en style JSON, et les suivre par `|` pour les envoyer dans le pipeline. Nushell utilise des commandes pour effectuer des tâches et produire plus de données. Apprendre ces commandes et savoir quand les utiliser vous aidera à composer de nombreux types de pipelines. + +## Pensez à Nushell comme un langage compilé + +Une part importante du design de Nushell, et en particulier là où il diffère de nombreux langages dynamiques, est que Nushell convertit les sources que vous lui donnez en quelque chose à exécuter, puis exécute le résultat. Il n'a pas de fonctionnalité `eval` qui vous permet de continuer à injecter de nouvelles sources pendant l'exécution. Cela signifie que les tâches comme l'inclusion de fichiers dans votre projet doivent être des chemins connus, un peu comme les includes dans les langages compilés tels que C++ ou Rust. + +Par exemple, ce qui suit n'a pas de sens dans Nushell, et échouera à s'exécuter si on l'exécute en tant que script : + +```nu +"def abc [] { 1 + 2 }" | save output.nu +source "output.nu" +abc +``` + +La commande [`source`](/commands/docs/source.md) va augmenter les sources qui vont être compilées, mais la commande [`save`](/commands/docs/save.md) de la ligne précédente n'aura pas eu la possibilité de s'exécuter. Nushell exécute l'ensemble du bloc comme s'il s'agissait d'un seul fichier, plutôt que d'exécuter ligne par ligne. Dans cet exemple, puisque le fichier output.nu n'est pas créé avant la fin de l'étape de "compilation", il est impossible pour la commande [`source`](/commands/docs/source.md) de lire les définitions depuis ce fichier pendant le parsing. + +Un autre problème courant est d'essayer de créer dynamiquement le nom du fichier à inclure : + +```nu +> source $"($my_path)/common.nu" +``` + +Cela ne fonctionne pas si `my_path` est une variable déclarée au runtime avec `let`. Cela nécessiterait que l'évaluateur exécute et évalue la chaîne de caractères, mais malheureusement, Nushell a besoin de cette information au moment de la compilation. + +Cependant, si `my_path` est une [constante](/book/variables#constant-variables), cela fonctionnera, car la chaîne de caractères peut être évaluée au moment de la compilation : + +```nu +> const my_path = ([$nu.home-path nushell] | path join) +> source $"($my_path)/common.nu" # sources /home/user/nushell/common.nu +``` + +**Penser en Nushell :** Nushell est conçu pour utiliser une unique étape de compilation pour toutes les sources que vous lui envoyez, et cela est distinct de l'évaluation. Cela permettra un support solide pour les IDEs, des messages d'erreur précis, un langage plus facile à utiliser pour les outils tiers, et à l'avenir, même des possibilités plus sophistiquées comme la possibilité de compiler Nushell directement en un fichier binaire. + +Pour des explications plus approfondies, consultez [Comment le code Nushell est executé](/book/how_nushell_code_gets_run.md). + +## Les variables sont immuables par défaut + +Une autre surprise fréquente pour les personnes venant d'autres langages est que les variables de Nushell sont immuables par défaut. En arrivant sur Nushell, vous voudrez passer un peu de temps à vous familiariser avec le travail dans un style plus fonctionnel, car cela a tendance à aider à écrire de code qui fonctionne mieux avec des variables immuables. + +**Penser en Nushell :** Si vous êtes habitué à utiliser des variables mutables pour différentes tâches, il vous faudra du temps pour apprendre comment faire chaque tâche dans un style plus fonctionnel. Nushell dispose d'un ensemble de fonctionnalités intégrées pour aider avec bon nombre de ces patterns, et les apprendre vous aidera à écrire du code dans un style plus Nushell. +L'avantage supplémentaire d'accélérer vos scripts en exécutant des parties de votre code en parallèle est un bonus appréciable. + +Consultez [Variables Immuables](/book/variables.html#immutable-variables) et [Choisir entre variables mutables et immuables](/book/variables.html#choosing-between-mutable-and-immutable-variables) pour plus d'informations. + +## L'environnement de Nushell est scopé + +Nushell s'inspire de nombreux principes des langages compilés. L'un de ces principes est que les langages devraient éviter l'état global mutable. Les shells utilisent souvent la mutation globale pour mettre à jour l'environnement, mais Nushell évite cette approche. + +Dans Nushell, les blocs contrôlent leur propre environnement. Les modifications apportées à l'environnement sont limitées au bloc où elles se produisent. + +En pratique, cela vous permet d'écrire du code concis pour travailler avec des sous-répertoires. Par exemple, si vous vouliez compiler chaque sous-projet dans le répertoire courant, vous pourriez exécuter : + +```nu +> ls | each { |row| + cd $row.name + make +} +``` + +La commande [`cd`](/commands/docs/cd.md) modifie les variables d'environnement `PWD`, et ce changement ne sort pas du bloc, ce qui permet à chaque itération de commencer à partir du répertoire courant et d'entrer dans le sous-répertoire suivant. + +Le fait d'avoir l'environnement scopé de cette manière rend les commandes plus prévisibles, plus faciles à lire, et, le moment venu, plus faciles à déboguer. Nushell propose également des commandes utilitaires comme [`def --env`](/commands/docs/def.md) ou [`load-env`](/commands/docs/load-env.md), qui sont des moyens pratiques pour effectuer des groupes de mises à jour de l'environnement. + +Il y a une exception ici, [`def --env`](/commands/docs/def.md) vous permet de créer une commande qui participe à l'environnement de l'appelant. + +**Penser en Nushell :** La bonne pratique de codage consistant à éviter les variables globales mutables s'étend à l'environnement. L'utilisation des commandes utilitaires intégrées vous permettra de travailler plus facilement avec l'environnement dans Nushell. Profiter du fait que les environnements sont encapsulés dans les blocs peut également vous aider à écrire des scripts plus concis et à interagir avec des commandes externes sans ajouter des éléments dans un environnement global dont vous n'avez pas besoin. diff --git a/tools/i18n-meta.json b/tools/i18n-meta.json index 544b53296fd..0bc38df95ba 100644 --- a/tools/i18n-meta.json +++ b/tools/i18n-meta.json @@ -3,6 +3,7 @@ "name": "3rdpartyprompts.md", "en": "Completed", "zh-CN": "f5987a82d@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -14,6 +15,7 @@ "name": "README.md", "en": "Completed", "zh-CN": "fa90895307@hustcer", + "fr": "4a47be5a@Loic Riegel", "de": "-", "tr": "-", "ja": "cfc7b0d@YukiOnodera", @@ -25,6 +27,7 @@ "name": "advanced.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -36,6 +39,7 @@ "name": "aliases.md", "en": "Completed", "zh-CN": "51522d5591@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -47,6 +51,7 @@ "name": "background_task.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "f08ae29d@petrisch", "tr": "-", "ja": "-", @@ -58,6 +63,7 @@ "name": "cheat_sheet.md", "en": "In progress", "zh-CN": "-", + "fr": "4a47be5a@Loic Riegel", "de": "-", "tr": "-", "ja": "-", @@ -69,6 +75,7 @@ "name": "coloring_and_theming.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "-", "de": "93859d14ea@petrisch", "tr": "-", "ja": "-", @@ -80,6 +87,7 @@ "name": "coming_from_bash.md", "en": "Completed", "zh-CN": "d6efb9a35a@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -91,6 +99,7 @@ "name": "coming_from_cmd.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -102,6 +111,7 @@ "name": "coming_to_nu.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -113,6 +123,7 @@ "name": "command_signature.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "696cb4fe@petrisch", "tr": "-", "ja": "-", @@ -124,6 +135,7 @@ "name": "configuration.md", "en": "Completed", "zh-CN": "d6efb9a35a@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -135,6 +147,7 @@ "name": "control_flow.md", "en": "Completed", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -146,6 +159,7 @@ "name": "creating_errors.md", "en": "Completed", "zh-CN": "ae23eeba3@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -157,6 +171,7 @@ "name": "custom_commands.md", "en": "Completed", "zh-CN": "d6efb9a35a@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -168,6 +183,7 @@ "name": "custom_completions.md", "en": "Completed", "zh-CN": "f5987a82d@hustcer", + "fr": "-", "de": "5993a92b@petrisch", "tr": "-", "ja": "-", @@ -179,6 +195,7 @@ "name": "dataframes.md", "en": "Completed", "zh-CN": "129cc2ddea@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -190,6 +207,7 @@ "name": "default_shell.md", "en": "In progress", "zh-CN": "-", + "fr": "4a47be5a@Loic Riegel", "de": "-", "tr": "-", "ja": "-", @@ -201,6 +219,7 @@ "name": "design_notes.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -212,6 +231,7 @@ "name": "environment.md", "en": "Completed", "zh-CN": "d6efb9a35a@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -223,6 +243,7 @@ "name": "escaping.md", "en": "Completed", "zh-CN": "f5987a82d@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -234,6 +255,7 @@ "name": "explore.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -245,6 +267,7 @@ "name": "externs.md", "en": "Completed", "zh-CN": "b6c91cabfa@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -256,6 +279,7 @@ "name": "getting_started.md", "en": "In progress", "zh-CN": "-", + "fr": "4a47be5a@Loic Riegel", "de": "c39efa00@petrisch", "tr": "-", "ja": "cfc7b0d@YukiOnodera", @@ -267,6 +291,7 @@ "name": "hooks.md", "en": "In progress", "zh-CN": "562cad2fb5@hustcer", + "fr": "-", "de": "13ed3117@petrisch", "tr": "-", "ja": "-", @@ -278,6 +303,7 @@ "name": "how_nushell_code_gets_run.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -289,6 +315,7 @@ "name": "installation.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "4a47be5a@Loic Riegel", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -300,6 +327,7 @@ "name": "line_editor.md", "en": "Completed", "zh-CN": "b6c91cabfa@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -311,6 +339,7 @@ "name": "loading_data.md", "en": "Completed", "zh-CN": "fa90895307@hustcer", + "fr": "-", "de": "0c788acfec@petrisch", "tr": "-", "ja": "-", @@ -322,6 +351,7 @@ "name": "metadata.md", "en": "Completed", "zh-CN": "ae23eeba3@hustcer", + "fr": "-", "de": " 83d74f9af2@Roshanjossey", "tr": "-", "ja": "-", @@ -333,6 +363,7 @@ "name": "modules.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -344,6 +375,7 @@ "name": "moving_around.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "4a47be5a@Loic Riegel", "de": "cfba017793@petrisch", "tr": "-", "ja": "-", @@ -355,6 +387,7 @@ "name": "nu_as_a_shell.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -366,6 +399,7 @@ "name": "nu_fundamentals.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -377,6 +411,7 @@ "name": "nushell_map.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -388,6 +423,7 @@ "name": "nushell_map_functional.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -399,6 +435,7 @@ "name": "nushell_map_imperative.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -410,6 +447,7 @@ "name": "nushell_operator_map.md", "en": "Completed", "zh-CN": "ae23eeba3@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -421,6 +459,7 @@ "name": "operators.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -432,6 +471,7 @@ "name": "overlays.md", "en": "In progress", "zh-CN": "51522d5591@hustcer", + "fr": "-", "de": "2a917adc@petrisch", "tr": "-", "ja": "-", @@ -443,6 +483,7 @@ "name": "parallelism.md", "en": "Completed", "zh-CN": "ae23eeba3@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -454,6 +495,7 @@ "name": "pipelines.md", "en": "Completed", "zh-CN": "6f61fadb69@hustcer", + "fr": "-", "de": "931d7240e2@petrisch", "tr": "-", "ja": "-", @@ -465,6 +507,7 @@ "name": "plugins.md", "en": "Completed", "zh-CN": "ae23eeba3@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -476,6 +519,7 @@ "name": "programming_in_nu.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -487,6 +531,7 @@ "name": "quick_tour.md", "en": "In progress", "zh-CN": "-", + "fr": "4a47be5a@Loic Riegel", "de": "-", "tr": "-", "ja": "fcf0d7c8@yukitomoda", @@ -498,6 +543,7 @@ "name": "regular_expressions.md", "en": "Completed", "zh-CN": "b6c91cabfa@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -509,6 +555,7 @@ "name": "scripts.md", "en": "Completed", "zh-CN": "fa90895307@hustcer", + "fr": "-", "de": "931d7240e2@petrisch", "tr": "-", "ja": "-", @@ -520,6 +567,7 @@ "name": "shells_in_shells.md", "en": "Completed", "zh-CN": "f5987a82d@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -531,6 +579,7 @@ "name": "standard_library.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -542,6 +591,7 @@ "name": "stdout_stderr_exit_codes.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -553,6 +603,7 @@ "name": "style_guide.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -564,6 +615,7 @@ "name": "table_of_contents.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -575,6 +627,7 @@ "name": "testing.md", "en": "In progress", "zh-CN": "-", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -586,6 +639,7 @@ "name": "thinking_in_nu.md", "en": "Completed", "zh-CN": "fa90895307@hustcer", + "fr": "4a47be5a@Loic Riegel", "de": "c39efa00@petrisch", "tr": "-", "ja": "-", @@ -597,6 +651,7 @@ "name": "types_of_data.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "-", "tr": "-", "ja": "-", @@ -608,6 +663,7 @@ "name": "variables.md", "en": "Completed", "zh-CN": "1b7d01ac3b@hustcer", + "fr": "-", "de": "translated by @sebastian-xyz", "tr": "-", "ja": "-", @@ -619,6 +675,7 @@ "name": "working_with_lists.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "ad03c8d55c@petrisch", "tr": "-", "ja": "-", @@ -630,6 +687,7 @@ "name": "working_with_strings.md", "en": "Completed", "zh-CN": "5d093e293d@hustcer", + "fr": "-", "de": "0c788acfec@petrisch", "tr": "-", "ja": "-", @@ -641,6 +699,7 @@ "name": "working_with_tables.md", "en": "Completed", "zh-CN": "73ef7f3153@hustcer", + "fr": "-", "de": "ad03c8d55c@petrisch", "tr": "-", "ja": "-", @@ -648,4 +707,4 @@ "pt-BR": "-", "ru": "-" } -] \ No newline at end of file +] diff --git a/typos.toml b/typos.toml index ded18aaa681..653f1474701 100644 --- a/typos.toml +++ b/typos.toml @@ -1,5 +1,5 @@ [files] -extend-exclude = ["pt-BR", "de", "ja", "es", "blog/202[0-3]*", "commands/"] +extend-exclude = ["pt-BR", "de", "ja", "es", "blog/202[0-3]*", "commands/", "fr"] [default.extend-words] ons = "ons" # false positive in commands/docs/str_replace.md