mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 17:41:41 +00:00
318 lines
11 KiB
Markdown
318 lines
11 KiB
Markdown
---
|
||
contributors:
|
||
- ["Max Yankov", "https://github.com/golergka"]
|
||
- ["Darren Lin", "https://github.com/CogBear"]
|
||
- ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
|
||
- ["Denis Arh", "https://github.com/darh"]
|
||
- ["akirahirose", "https://twitter.com/akirahirose"]
|
||
- ["Anton Strömkvist", "http://lutic.org/"]
|
||
- ["Rahil Momin", "https://github.com/iamrahil"]
|
||
- ["Gregrory Kielian", "https://github.com/gskielian"]
|
||
translators:
|
||
- ["Baptiste Fontaine", "http://bfontaine.net"]
|
||
filename: LearnBash-fr.sh
|
||
---
|
||
|
||
Bash est le nom du shell UNIX, qui était aussi distribué avec le système
|
||
d’exploitation GNU et est le shell par défaut sur Linux et macOS.
|
||
|
||
Presque tous les exemples ci-dessous peuvent être écrits dans un script shell
|
||
ou exécutés directement dans le terminal.
|
||
|
||
[Plus d’informations ici.](http://www.gnu.org/software/bash/manual/bashref.html)
|
||
|
||
```bash
|
||
#!/bin/bash
|
||
# La première ligne du script s’appelle le « shebang », elle indique au système
|
||
# comment exécuter le script : http://fr.wikipedia.org/wiki/Shebang
|
||
# Comme vous pouvez le remarquer, les commentaires commencent par un « # ».
|
||
# Le shebang est donc aussi un commentaire
|
||
|
||
# Un exemple simple qui affiche « Hello world! » :
|
||
echo Hello world!
|
||
|
||
# Chaque commande commence sur une nouvelle ligne ou après un point-virgule :
|
||
echo 'Ceci est la première ligne'; echo 'Ceci est la seconde ligne'
|
||
|
||
# La déclaration d’une variable ressemble à ça :
|
||
VARIABLE="Du texte"
|
||
|
||
# Mais pas comme ça :
|
||
VARIABLE = "Du texte" # => renvoie une erreur : "Variable: command not found"
|
||
# Bash va penser que VARIABLE est une commande qu’il doit exécuter et va
|
||
# afficher une erreur parce qu’elle est introuvable.
|
||
|
||
# Ni comme ça :
|
||
VARIABLE= 'Some string' # => renvoie une erreur : "Du texte: command not found"
|
||
# Bash va penser que 'Di texte' est une commande qu’il doit exécuter et va
|
||
# afficher une erreur parce qu’elle est introuvable. (Dans ce cas, la partie
|
||
# 'VARIABLE=' est considérée comme une affectation de variable valable uniquement
|
||
# pour la portée de la commande 'Du texte').
|
||
|
||
# Utiliser une variable :
|
||
echo $VARIABLE # => Du texte
|
||
echo "$VARIABLE" # => Du texte
|
||
echo '$VARIABLE' # => $VARIABLE
|
||
# Quand vous utilisez la variable en elle-même – en lui assignant une valeur,
|
||
# en l’exportant ou autre – vous écrivez son nom sans $. Si vous voulez
|
||
# utiliser sa valeur, vous devez utiliser $.
|
||
# Notez qu’entourer une variable de deux guillemets simples (') empêche
|
||
# l’expansion des variables !
|
||
|
||
# Expansion des paramètres (Parameter expansion) ${ } :
|
||
echo ${VARIABLE} # => Du texte
|
||
# Ceci est une utilisation simple de l'expansion de paramètre.
|
||
# L'expansion de paramètre récupère la valeur d'une variable.
|
||
# Elle « déploie » ou imprime la valeur.
|
||
# Lors de l'expansion, la valeur ou le paramètre peut être modifié.
|
||
# Voici d'autres modifications qui s'ajoutent à cette expansion.
|
||
|
||
# Substitution de chaîne de caractères dans une variable
|
||
echo ${VARIABLE/Some/A}
|
||
# Ceci va remplacer la première occurrence de « Some » par « A »
|
||
|
||
# Sous-chaîne d’une variable
|
||
LONGUEUR=5
|
||
echo ${VARIABLE:0:LONGUEUR} # => Du te
|
||
# Ceci va retourner les 5 premiers caractères de la valeur
|
||
echo ${VARIABLE:LONGUEUR} # => xte
|
||
# Ceci va retourner la valeur sans les 5 premiers caractères
|
||
echo ${VARIABLE: -4} # => exte
|
||
# Ceci va retourner les 4 derniers caractères de la valeur
|
||
# (l'espace avant -4 est nécessaire)
|
||
|
||
# Longueur d'une chaîne
|
||
echo ${#VARIABLE} # => 8
|
||
|
||
# Expansion indirecte
|
||
AUTRE_VARIABLE="VARIABLE"
|
||
echo ${!AUTRE_VARIABLE} # => Du texte
|
||
# Cela va utiliser la valeur comme un nom de variable
|
||
|
||
# Valeur par défaut d’une variable
|
||
echo ${FOO:-"ValeurParDefaut"}
|
||
# Retourne 'ValeurParDefaut' si FOO n'a pas été déclarée, si
|
||
# FOO est null (FOO=) ou si FOO est une chaîne vide (FOO="").
|
||
# En revanche Zéro (FOO=0) retourne 0
|
||
|
||
# Les tableaux (array)
|
||
|
||
array0=(un deux trois quatre cinq six)
|
||
# Déclarer un tableau de 6 éléments
|
||
|
||
echo $array0 # => "un"
|
||
# Affiche le premier élément
|
||
|
||
echo ${array0[0]} # => "un"
|
||
# Affiche le premier élément
|
||
|
||
echo ${array0[@]} # => "un deux trois quatre cinq six"
|
||
# Affiche tous les éléments
|
||
|
||
echo ${#array0[@]} # => "6"
|
||
# Attiche le nombre d'éléments
|
||
|
||
echo ${#array0[2]} # => "5"
|
||
# Affiche le nombre de caractères du troisième élément
|
||
|
||
echo ${array0[@]:3:2} # => "quatre cinq"
|
||
# Affiche 2 element en à partir du quatrième
|
||
|
||
for i in "${array0[@]}"; do
|
||
echo "$i"
|
||
done
|
||
# Affiche tous éléments, chacun sur un nouvelle ligne
|
||
|
||
# Brace Expansion { }
|
||
# Permet de générer des tableau
|
||
echo {1..12} # => 1 2 3 4 5 6 7 8 9 10 11 12
|
||
echo {100..95} # => 100 99 98 97 96 95
|
||
echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
|
||
|
||
# Variables pré-remplies :
|
||
# Il y a quelques variables pré-remplies utiles, comme :
|
||
echo "La valeur de retour du dernier programme : $?"
|
||
echo "Le PID du script : $$"
|
||
echo "Nombre d’arguments : $#"
|
||
echo "Arguments du script : $@"
|
||
echo "Arguments du script séparés en plusieurs variables : $1 $2..."
|
||
|
||
# Maintenant que nous savons comment utiliser et afficher des variables,
|
||
# apprenons d'autres fonctionnalités basiques de bash !
|
||
|
||
# Notre répertoire courant est accessible par la commande `pwd`.
|
||
# `pwd` signifie « imprimer le répertoire de travail ».
|
||
# On peut aussi utiliser la variable intégrée `$PWD`.
|
||
# Observez que les commandes suivantes sont équivalentes :
|
||
echo "Je suis dans $(pwd)" # exécute `pwd` et interpole la sortie
|
||
echo "Je suis dans $PWD" # interprète la variable
|
||
|
||
# Si vous avez trop de données dans votre terminal, la commande
|
||
# `clear` efface votre écran
|
||
clear
|
||
# Ctrl-L fonctionne aussi pour effacer la sortie.
|
||
|
||
# Lire une valeur depuis l’entrée standard :
|
||
echo "Quel est votre nom ?"
|
||
read NAME # Notez que l’on n’a pas eu à déclarer une nouvelle variable
|
||
echo Bonjour, $NAME!
|
||
|
||
# Nous avons l’habituelle structure « if » :
|
||
# Utilisez 'man test' pour plus d’informations à propos des conditions
|
||
if [ $NAME != $USER ] # remarque : $USER est le nom l'utilisateur en cours.
|
||
then
|
||
echo "Votre nom n’est pas votre pseudo"
|
||
else
|
||
echo "Votre nom est votre pseudo"
|
||
fi
|
||
|
||
# Remarque : si $NAME est vide, bash verra la condition précédente comme :
|
||
if [ != $USER ]
|
||
# ce qui est syntaxiquement invalide
|
||
# la bonne façon d'utiliser une variable potentiellement vide en bash est :
|
||
if [ "$NAME" != $USER ]
|
||
# ce qui sera interprété par bash si $NAME est vide comme :
|
||
if [ "" != $USER ]
|
||
|
||
# Il y a aussi l’exécution conditionnelle
|
||
echo "Toujours exécuté" || echo "Exécuté si la première commande ne réussit pas"
|
||
# Toujours exécuté
|
||
echo "Toujours exécuté" && echo "Exécuté si la première commande réussit"
|
||
# Toujours exécuté
|
||
# Exécuté si la première commande réussit
|
||
|
||
# Pour utiliser && et || avec des commandes « if, » vous devez utiliser
|
||
# plusieurs paires de crochets :
|
||
if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
|
||
then
|
||
echo "Ceci sera exécuté si $NAME est Steve ET $AGE est 15."
|
||
fi
|
||
|
||
if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
|
||
then
|
||
echo "Ceci sera exécuté si $NAME est Daniya OU Zach."
|
||
fi
|
||
|
||
# Les expressions sont écrites dans le format suivant :
|
||
echo $(( 10 + 5 ))
|
||
|
||
# Contrairement aux autres langages de programmation, Bash est un shell — il
|
||
# est donc exécuté dans le contexte du répertoire courant. Vous pouvez lister
|
||
# les fichiers et dossiers dans le répertoire courant avec la commande `ls` :
|
||
ls
|
||
|
||
# Ces commandes ont des options qui contrôlent leur exécution :
|
||
ls -l # Liste tous les fichiers et répertoires sur des lignes séparées
|
||
|
||
# Les résultat de la commande précédente peuvent être passés à la commande
|
||
# suivante en entrée.
|
||
# La commande grep filtre l’entrée avec les motifs donnés. On peut ainsi lister
|
||
# les fichiers .txt dans le répertoire courant :
|
||
ls -l | grep "\.txt"
|
||
|
||
# Vous pouvez aussi rediriger l’entrée et les sorties standards et d’erreur
|
||
# d’une commande :
|
||
python2 hello.py < "entrée.in"
|
||
python2 hello.py > "sortie.out"
|
||
python2 hello.py 2> "erreur.err"
|
||
# Ceci va écraser le fichier s'il existe; si vous préférez écrire à la fin de
|
||
# celui-ci, utilisez >> à la place.
|
||
|
||
# Les commandes peuvent se substituer à l’intérieur d’autres commandes en
|
||
# utilisant $( ) :
|
||
# La commande ci-dessous affiche le nombre de fichiers et répertoires dans le
|
||
# répertoire courant :
|
||
echo "Il y a $(ls | wc -l) choses ici."
|
||
|
||
# On peut faire la même chose avec les accents graves `` mais on ne peut pas
|
||
# les imbriquer — la façon la plus courante est d’utiliser $( ).
|
||
echo "There are `ls | wc -l` items here."
|
||
|
||
# Bash a une commande case qui marche de façon similaire au switch de Java et
|
||
# C++ :
|
||
case "$VARIABLE" in
|
||
#List patterns for the conditions you want to meet
|
||
0) echo "There is a zero.";;
|
||
1) echo "There is a one.";;
|
||
*) echo "It is not null.";;
|
||
esac
|
||
|
||
# La boucle for itère autant de fois qu’elle a d’arguments :
|
||
# Le contenu de $VARIABLE est affiché trois fois.
|
||
for VARIABLE in {1..3}
|
||
do
|
||
echo "$VARIABLE"
|
||
done
|
||
|
||
# Ou écrivez-la de façon « traditionnelle » :
|
||
for ((a=1; a <= 3; a++))
|
||
do
|
||
echo $a
|
||
done
|
||
|
||
# Elles peuvent aussi être utilisées pour agir sur des fichiers :
|
||
# Cette boucle va exécuter la commande 'cat' sur fichier1 et fichier2
|
||
for VARIABLE in fichier1 fichier2
|
||
do
|
||
cat "$VARIABLE"
|
||
done
|
||
|
||
# …ou la sortie d’une commande :
|
||
# Ceci va afficher la sortie de ls.
|
||
for OUTPUT in $(ls)
|
||
do
|
||
cat "$OUTPUT"
|
||
done
|
||
|
||
# Boucle while :
|
||
while [ true ]
|
||
do
|
||
echo "corps de la boucle ..."
|
||
break
|
||
done
|
||
|
||
# Vous pouvez aussi définir des fonctions
|
||
# Définition :
|
||
function foo ()
|
||
{
|
||
echo "Les arguments fonctionnent comme les arguments de script : $@"
|
||
echo "Et : $1 $2..."
|
||
echo "Ceci est une fonction"
|
||
return 0
|
||
}
|
||
|
||
# Ou plus simplement :
|
||
bar ()
|
||
{
|
||
echo "Une autre façon de définir des fonctions !"
|
||
return 0
|
||
}
|
||
|
||
# Appeler votre fonction
|
||
foo "Mon nom est" $NAME
|
||
|
||
# Il y a plein de commandes utiles que vous devriez apprendre :
|
||
# affiche les 10 dernières lignes de fichier.txt
|
||
tail -n 10 fichier.txt
|
||
# affiche les 10 premières lignes de fichier.txt
|
||
head -n 10 fichier.txt
|
||
# trie les lignes de fichier.txt
|
||
sort fichier.txt
|
||
# montre ou omet les lignes répétées, avec -d pour les montrer
|
||
uniq -d fichier.txt
|
||
# affiche uniquement la première colonne avant le caractère « , »
|
||
cut -d ',' -f 1 fichier.txt
|
||
# remplace chaque occurrence de 'okay' par 'super' dans fichier.txt
|
||
# (compatible avec les expression rationnelles)
|
||
sed -i 's/okay/super/g' fichier.txt
|
||
# affiche toutes les lignes de fichier.txt qui correspondent à une expression
|
||
# rationnelle, dans cet exemple les lignes qui commencent par « foo » et
|
||
# finissent par « bar »
|
||
grep "^foo.*bar$" fichier.txt
|
||
# ajoutez l’option « -c » pour afficher le nombre de lignes concernées
|
||
grep -c "^foo.*bar$" fichier.txt
|
||
# Si vous voulez vraiment chercher une chaîne de caractères, et non
|
||
# l’expression rationnelle, utilisez fgrep (ou grep -F)
|
||
fgrep "^foo.*bar$" fichier.txt
|
||
```
|