From 614b077aae70bf32872ade29edc404e476e90ca1 Mon Sep 17 00:00:00 2001
From: William Aboucaya <william.aboucaya@gmail.com>
Date: Wed, 26 Oct 2022 12:39:22 +0200
Subject: [PATCH] French translation for two chapters.

---
 ebook/fr/content/008-bash-arrays.md           | 111 +++++++++++
 .../009-bash-conditional-expressions.md       | 186 ++++++++++++++++++
 2 files changed, 297 insertions(+)
 create mode 100644 ebook/fr/content/008-bash-arrays.md
 create mode 100644 ebook/fr/content/009-bash-conditional-expressions.md

diff --git a/ebook/fr/content/008-bash-arrays.md b/ebook/fr/content/008-bash-arrays.md
new file mode 100644
index 0000000..1083e0a
--- /dev/null
+++ b/ebook/fr/content/008-bash-arrays.md
@@ -0,0 +1,111 @@
+# Les Arrays en Bash
+
+Si vous avez déjà fait de la programmation, vous savez probablement déjà ce qu'est un array. 
+
+Mais au cas où vous ne seriez pas un développeur, le plus important est que vous sachiez que, contrairement aux variables, les arrays peuvent contenir plusieurs valeurs sous un même nom.
+
+Vous pouvez initialiser un array en lui assignant des valeurs séparées par des espaces et contenues dans des parenthèses `()`. Par exemple:
+
+```bash
+mon_array=("valeur 1" "valeur 2" "valeur 3" "valeur 4")
+```
+
+Pour accéder aux éléments de l'array, vous devez les référencer en utilisant leur indice numérique.
+
+>{notice} retenez bien que vous devez utiliser des accolades `{}`.
+
+* Accéder à un seul élément, ce code affichera : `valeur 2`
+
+```bash
+echo ${mon_array[1]}
+```
+
+* Ce code renvoie le dernier élément: `valeur 4`
+
+```bash
+echo ${mon_array[-1]}
+```
+
+* Comme pour les arguments en ligne de commande, utiliser `@` renverra tous les éléments de l'array, comme suit : `valeur 1 valeur 2 valeur 3 valeur 4`
+
+```bash
+echo ${mon_array[@]}
+```
+
+* Précéder le nom de l'array avec un croisillon (`#`) renverra le nombre total d'éléments dans l'array, `4` dans notre cas:
+
+```bash
+echo ${#mon_array[@]}
+```
+
+Pensez bien à tester ce code et à vous entrainer avec différentes valeurs.
+
+## Les sous-chaînes de caractères (substrings) en Bash : Le découpage
+
+Regardons l'exemple suivant de découpage d'une chaîne de caractères (string) en Bash:
+
+```bash
+#!/bin/bash
+
+lettres=( "A""B""C""D""E" ) 
+echo ${lettres[@]}
+```
+
+Cette commande affichera tous les éléments de l'array.
+
+Sortie :
+
+```bash
+$ ABCDE
+```
+
+
+Regardons quelques exemples supplémentaires :
+
+- Exemple 1  
+
+```bash
+#!/bin/bash
+
+lettres=( "A""B""C""D""E" ) 
+b=${lettres:0:2}
+echo "${b}"
+```
+
+Cette commande affiche l'array depuis l'indice 0 (le premier de l'array) jusqu'à 2 non inclus.
+
+```bash
+$ AB
+```
+ 
+- Exemple 2
+
+```bash
+#!/bin/bash
+
+lettres=( "A""B""C""D""E" ) 
+b=${lettres::5}
+echo "${b}"
+```
+
+Cette commande affiche les éléments depuis l'indice 0 jusqu'à 5 non inclus, l'indice de départ est initialisé à 0 par défaut.
+
+```bash
+$ ABCDE
+```
+
+- Exemple 3
+
+```bash
+#!/bin/bash
+
+lettres=( "A""B""C""D""E" ) 
+b=${lettres:3}
+echo "${b}"
+```
+
+Cette commande affiche les éléments depuis l'indice 3 jusqu'à la fin de l'array incluse.
+
+ ```bash
+ $ DE
+ ```
diff --git a/ebook/fr/content/009-bash-conditional-expressions.md b/ebook/fr/content/009-bash-conditional-expressions.md
new file mode 100644
index 0000000..63a128f
--- /dev/null
+++ b/ebook/fr/content/009-bash-conditional-expressions.md
@@ -0,0 +1,186 @@
+# Les Expressions Conditionnelles en Bash
+
+En informatique, les affirmations conditionnelles, expressions conditionnelles et constructions conditionnelles sont des fonctionnalités d'un langage de programmation qui effectuent des opérations différentes en fonction de la valeur booléenne d'une condition spécifiée par le développeur, `true` (vrai) ou `false` (faux).
+
+En Bash, les expressions conditionnelles utilisent les commandes `[[` et `[` pour tester les attributs d'un fichier et effectuer des comparaisons arithmétiques ou à partir de strings. 
+
+Voici une liste des expressions conditionnelles Bash les plus populaires. Vous n'avez pas besoin de les retenir par coeur. Vous pouvez simplement vous référer à cette liste quand vous en avez besoin !
+
+## Expressions à partir d'un fichier
+
+* Vrai si le fichier existe.
+
+```bash
+[[ -a ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un fichier spécial en mode bloc (block special file).
+
+```bash
+[[ -b ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un fichier spécial en mode caractère (character special file).
+
+```bash
+[[ -c ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un dossier.
+
+```bash
+[[ -d ${fichier} ]]
+```
+
+* Vrai si le fichier existe.
+
+```bash
+[[ -e ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un fichier normal.
+
+```bash
+[[ -f ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un lien symbolique.
+
+```bash
+[[ -h ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est lisible.
+
+```bash
+[[ -r ${fichier} ]]
+```
+
+* Vrai si le fichier existe et a une taille supérieure à zéro.
+
+```bash
+[[ -s ${fichier} ]]
+```
+
+* Vrai si le fichier existe et peut recevoir des écritures.
+
+```bash
+[[ -w ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est exécutable.
+
+```bash
+[[ -x ${fichier} ]]
+```
+
+* Vrai si le fichier existe et est un lien symbolique.
+
+```bash
+[[ -L ${fichier} ]]
+```
+
+## Les expressions sur des strings
+
+* Vrai si la variable varname existe (on lui a assigné une valeur).
+
+```bash
+[[ -v ${varname} ]]
+```
+
+* Vrai si la string a une longueur égale à 0.
+
+```bash
+[[ -z ${string} ]]
+```
+
+* Vrai si la string a une longueur différente de 0.
+
+```bash
+[[ -n ${string} ]]
+```
+
+* Vrai si les strings sont égales. `=` doit être utilisé avec la commande `[` pour être conforme à la norme POSIX. Quand vous utilisez la commande `[[`, vous cherchez des correspondances de motifs entre les deux strings.
+
+```bash
+[[ ${string1} == ${string2} ]]
+```
+
+* Vrai si les strings sont différentes.
+
+```bash
+[[ ${string1} != ${string2} ]]
+```
+
+* Vrai si string1 précède string2 alphabétiquement.
+
+```bash
+[[ ${string1} < ${string2} ]]
+```
+
+* Vrai si string1 suit string2 alphabétiquement.
+
+```bash
+[[ ${string1} > ${string2} ]]
+```
+
+## Les opérateurs arithmétiques
+
+* Vrai si les nombres sont **égaux**.
+
+```bash
+[[ ${arg1} -eq ${arg2} ]]
+```
+
+* Vrai si les nombres ne sont **pas égaux**.
+
+```bash
+[[ ${arg1} -ne ${arg2} ]]
+```
+
+* Vrai si arg1 est **plus petit que** arg2.
+
+```bash
+[[ ${arg1} -lt ${arg2} ]]
+```
+
+* Vrai si arg1 est **plus petit ou égal à** arg2.
+
+```bash
+[[ ${arg1} -le ${arg2} ]]
+```
+
+* Vrai si arg1 est **plus grand que** arg2.
+
+```bash
+[[ ${arg1} -gt ${arg2} ]]
+```
+
+* Vrai si arg1 est **plus grand ou égal à** arg2.
+
+```bash
+[[ ${arg1} -ge ${arg2} ]]
+```
+
+Pour information, arg1 et arg2 peuvent être des entiers positifs ou négatifs.
+
+Comme avec d'autres langages de programmation, vous pouvez utiliser les conditions `AND` (et) & `OR` (ou) :
+
+```bash
+[[ test_case_1 ]] && [[ test_case_2 ]] # And
+[[ test_case_1 ]] || [[ test_case_2 ]] # Or
+```
+
+## Opérateurs sur le statut de fin d'une commande
+
+* Vrai si la commande a réussi et n'a pas rencontré d'erreur.
+
+```bash
+[[ $? -eq 0 ]]
+```
+
+* Vrai si la commande n'a pas réussi ou a rencontré une erreur.
+
+```bash
+[[ $? -gt 0 ]]
+```