Commit 3328cffb authored by Rémy Huet's avatar Rémy Huet 💻

Merge derniereminute into master

parents eafea152 1c6f0723
Pipeline #33876 passed with stages
in 1 minute and 1 second
24 janvier 2019
Rémy Huet (remy.huet@etu.utc.fr), Association Picasoft (picasoft@assos.utc.fr)
Rémy Huet (remy.huet@etu.utc.fr), Quentin Duchemin (quentinduchemin@tuta.io), Association
Picasoft (picasoft@assos.utc.fr)
La présentation et tous les fichiers qui composent ce dépôt sont sous licence
Creative Commons 4.0 Attribution - Partage dans les Mêmes Conditions 4.0
......
......@@ -14,8 +14,9 @@
\usepackage[]{ulem}
\usepackage{xcolor}
\usepackage{tikz}
\usepackage{upquote}
\hypersetup{
pdfauthor={Rémy Huet},
pdfauthor={Rémy Huet, Quentin Duchemin},
pdftitle={Api/casoft Init - Jour 3 partie 1 : Scripts shell}
pdfsubject={Formation shell},
pdfkeywords={scipts, linux, GNU/Linux, shell, posix},
......@@ -38,10 +39,10 @@ pdfproducer={Latex},
{}
}
\title[Api/casoft Init - Shell]{Api/casoft Init - Jour 3 partie 1 - scripts shell}
\title[Api/casoft Init - Shell]{Api/casoft Init - Jour 3 (matin) - Scripts shell}
\titlegraphic{\includegraphics[width=5em]{./imgs/picasoft_logo.png}\\ \href{https://creativecommons.org/licenses/by-sa/4.0/deed.fr}{\includegraphics[width=4em]{./imgs/licence.eps}}}
\author[R. Huet]{%
\phantom{x}\hfill Rémy {\sc Huet} \hfill\phantom{x}}
\author[R. Huet, Q. Duchemin]{%
\phantom{x}\hfill Rémy {\sc Huet} \hfill Quentin {\sc Duchemin} \hfill\phantom{x}}
\institute[Picasoft]{Association Picasoft}
\date[24/01/2019]{Mercredi 23 janvier 2018}
......
......@@ -17,17 +17,17 @@
\item Statique (le nombre d'exécutions est fixé et ne peut pas dépendre de paramètres extérieurs)
\end{itemize}
C'est pourquoi on utilise des \textbf{boucles}
C'est pourquoi on utilise des \textbf{boucles}.
\end{block}
\end{frame}
\begin{frame}{Les boucles en théorie}
\begin{block}{Définition}
Une boucle est une structure permettant de réaliser de manière répétée une action.
Une boucle est une structure permettant de répéter un ensemble d'instructions.
Elle est composée:
\begin{itemize}
\item D'un corps: c'est l'ensemble des instructions qui seront exécutées lors d'un passage dans la boucle.
\item D'une condition de réalisation: si celle-ci est vraie, un passage est effectué
\item D'une condition de réalisation: si celle-ci est vraie, une \textbf{itération} est effectuée.
\end{itemize}
\end{block}
\begin{alertblock}{N.B.}
......@@ -38,11 +38,11 @@
\end{alertblock}
\end{frame}
\subsection{La boucle tant que \ldots faire}
\subsection{La boucle tant que~\ldots faire}
\begin{frame}[fragile]{En théorie}
\begin{block}{Explications}
Elle est composée d'une condition \enquote{simple} \textit{comme celle des if} et d'un corps.
Elle est composée d'une condition et d'un corps.
Elle est de la forme :
\end{block}
\begin{Verbatim}
......@@ -57,11 +57,11 @@
\begin{block}{Concrètement}
Son fonctionnement est assez simple.
Tant que la condition est vérifiée, la boucle boucle.
Tant que la condition est vérifiée, la boucle s'exécute.
\end{block}
\end{frame}
\begin{frame}[fragile]{Et en bash?}
\begin{frame}[fragile]{Et en Bash?}
En bash, la syntaxe de cette boucle est la suivante :
\begin{Verbatim}
{\large while [ condition ]}
......@@ -78,16 +78,16 @@
\begin{Verbatim}
#!/bin/bash
while [ -z $reponse ] || [ $reponse != 'oui' ]\textcolor{red}{# ou juste [ ``$reponse'' != oui ]}
while [ -z $reponse ] || [ "$reponse" != 'oui' ]\textcolor{red}{ # ou juste [ "$reponse" != oui ]}
do
read -p 'Dites oui : ' reponse
read -p "Dites oui : " reponse
done
\end{Verbatim}
\end{beamercolorbox}
\begin{block}{}
Ce script demandera à l'utilisateur d'entrer du texte tant que l'utilisateur n'enverra pas \enquote{oui}
Ce script demandera à l'utilisateur d'entrer du texte tant que l'utilisateur n'enverra pas \enquote{oui}.
On notera que comme pour les if, on peut utiliser les opérateurs arithmétiques
On notera que comme pour les if, on peut utiliser les opérateurs logiques.
\end{block}
\end{frame}
......@@ -128,14 +128,15 @@ done
\begin{Verbatim}
#!/bin/bash
while [ "$reponse" != 'oui' ]
for file in *
do
read -p 'Dites oui : ' reponse
cat $file
done
\end{Verbatim}
\end{beamercolorbox}
\begin{block}{}
Ce script demandera une entrée à l'utilisateur tant que ça ne sera pas \enquote{oui}
Ce script affichera l'ensemble des fichiers du répertoire d'exécution du script. Notez que le joker \texttt{*}, comme dans le terminal, capture le contenu du répertoire courant.
\end{block}
\end{frame}
......@@ -143,10 +144,10 @@ done
\begin{alertblock}{Exercice: les années bissextiles}
Écrire un script qui:
\begin{itemize}
\item Demande deux années à l'utilisateur : celle de départ ou celle d'arrivée. Elles pourront être fournies en paramètre (dans cet ordre). La ou les valeurs manquantes seront demandées par le prompt lors de l'exécution du programme.
\item Demande deux années à l'utilisateur : celle de départ ou celle d'arrivée. Elles pourront être fournies en paramètres (dans cet ordre). La ou les valeurs manquantes seront demandées par le prompt lors de l'exécution du programme le cas échéant.
\item Affiche toutes les années bissextiles comprises entre celles données (incluses)
\end{itemize}
On utilisera uniquement des boucles \texttt{for} et pas de boucle \texttt{while}
On utilisera uniquement des boucles \texttt{for} (pas de boucle \texttt{while}) !
\end{alertblock}
\begin{exampleblock}{Rappel}
Une année est bissextile si elle est un multiple de 4. Exception : elle ne l'est pas si elle est un multiple de 100. Exception à l'exception : elle l'est si elle est un multiple de 400.
......@@ -156,13 +157,15 @@ done
\begin{frame}[fragile]{Indices}
\begin{block}{Indices}
\begin{itemize}
\item Pour générer les valeurs pour la boucle \texttt{for}, allez voir du côté de \sout{chez Swann} \texttt{seq}
\item La commande \texttt{let} ne renvoie pas directement la valeur du calcul. On utilisera une autre syntaxe pour faire les calculs dans les if: \texttt{\$((calcul))}
\item Pour générer les valeurs pour la boucle \texttt{for}, allez voir du côté de \sout{chez Swann} \texttt{seq}.
\item La commande \texttt{let} ne renvoie pas directement la valeur du calcul. On utilisera une autre syntaxe pour faire les calculs dans les if: \texttt{\$((calcul))}.
\end{itemize}
\end{block}
\end{frame}
\begin{frame}[fragile]{Solution}
Proposition de solution:
Proposition de solution :
\medskip
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
#!/bin/bash \Pause
......@@ -172,19 +175,19 @@ arrivee=$2 \Pause
if [ -z $2 ] \Pause
then \Pause
if [ -z $1 ] \Pause
then \Pause
read -p 'Année de départ ? ' depart \Pause
fi \Pause
read -p "Année d'arrivée ? " arrivee \Pause
if [ -z $1 ] \Pause
then \Pause
read -p "Année de départ ? " depart \Pause
fi \Pause
read -p "Année d'arrivée ? " arrivee \Pause
fi \Pause
for annee in `seq $depart $arrivee` \Pause
do \Pause
if [ $(($annee % 4)) -eq 0 ] && [ $(($annee % 100)) -ne 0 ] || [ $(($annee % 400)) -eq 0 ] \Pause
then \Pause
echo $annee \Pause
fi \Pause
if [ $(($annee % 4)) -eq 0 ] && [ $(($annee % 100)) -ne 0 ] || [ $(($annee % 400)) -eq 0 ] \Pause
then \Pause
echo $annee \Pause
fi \Pause
done
\end{Verbatim}
\end{beamercolorbox}
......@@ -195,17 +198,19 @@ done
Tout à l'heure, on a vu que les paramètres n'étaient accessibles que via 9 variables.
Mais il est bien possible d'avoir plus de 9 paramètres sur un script.
On utilisera alors la commande \texttt{shift} pour \enquote{décaler} les paramètres.
(\verb+$2 -> $1, $3 -> $2 ... [...] -> $9+)
(\verb+$2 $1, $3 → $2 [...]$9+).
\end{block}
Exemple : écrire un script qui liste tous les paramètres avec leur place: \Pause
Exemple : écrire un script qui liste tous les paramètres avec leur place : \Pause
\medskip
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
#!/bin/bash
for i in `seq 1 $#`
do
echo "Le paramètre $i vaut $1"
shift
echo "Le paramètre $i vaut $1"
shift
done
\end{Verbatim}
\end{beamercolorbox}
......
This diff is collapsed.
......@@ -6,9 +6,10 @@
Maintenant, comment faire si l'on veut pouvoir répéter une suite d'instructions plusieurs fois, à des endroits différents du programme ? Comment mieux organiser son code pour le rendre plus lisible, en créant des blocs réalisant une fonctionnalité particulière ?
\end{block}
\medskip
\begin{alertblock}{Définition}
Une fonction, c’est un ensemble d’instructions, permettant d'effectuer une tâche spécifique, en fonction de paramètres d'entrée.
Une fonction, c’est un ensemble d’instructions réutilisable permettant d'effectuer une tâche spécifique. Les fonctions peuvent prendre des \textbf{paramètres} en entrée, ce qui leur permet d'être \textbf{dynamiques}.
\end{alertblock}
\end{frame}
......@@ -16,18 +17,20 @@
\begin{frame}[fragile]{Déclarer une fonction}
Pour déclarer une fonction, on peut utiliser deux syntaxes différentes :
\medskip
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
ma_fonction ()
ma_fonction()
\{
instructions
instructions
\}
//OU
# OU
function ma_fonction
\{
instructions
instructions
\}
\end{Verbatim}
\end{beamercolorbox}
......@@ -41,12 +44,12 @@ function ma_fonction
\begin{block}{Paramètres}
Une fonction se comporte comme un mini script local. On peut lui passer des paramètres et les récupérer avec la même syntaxe que pour le programme principal.
\end{block}
Le script ci-dessous affichera \enquote{toto}
Exemple : le script ci-dessous affichera \enquote{toto} :
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
afficheParam ()
afficheParam()
\{
echo $1
echo $1
\}
afficheParam toto
......@@ -61,15 +64,14 @@ afficheParam toto
Par défaut, toutes les variables ont une portée \textbf{globale}, c'est à dire qu'elles sont accessibles depuis n'importe quelle partie du script.
\end{block}
\begin{block}{Portée locale}
Pour faciliter le déboggage et la lisibilité d'un programme, il est conseillé d'utiliser le moins possible des variables globales.
On essaiera donc d'utiliser le plus possibles des variables \textbf{locales} à l'intérieur de nos fonctions.
Pour faciliter le déboggage et la lisibilité d'un programme, il est conseillé d'utiliser le plus possibles de variables \textbf{locales} à l'intérieur de nos fonctions, grâce au mot-clé \texttt{local}.
\end{block}
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\vspace{-10pt}
\begin{Verbatim}
ma_fonction ()
ma_fonction()
\{
local var_locale=``C'est une variable locale''
local var_locale="C'est une variable locale"
\}
ma_fonction
......@@ -83,24 +85,43 @@ echo $var_locale
\begin{frame}[fragile]{Retour de fonctions}
\begin{block}{Contexte}
En bash, on ne peut pas comme dans la plupart des autres langages renvoyer n'importe quoi depuis une fonction via un \texttt{return}.
En Bash, on ne peut pas comme dans la plupart des autres langages renvoyer n'importe quoi depuis une fonction via un \texttt{return}.
Cette directive ne permet en effet de renvoyer que des entiers (en général des codes d'erreur).
\end{block}
\begin{block}{Comment faire ?}
Pour utiliser des valeurs de retour dans une fonction, on utilisera alors de la substitution de commande.
Rappelez vous, c'est la syntaxe avec les backquotes qui permet de signaler que le contenu est une commande !
Pour récupérer la sortie d'une fonction, ou d'un programme, on utilisera la \textbf{substitution} de commande.
Rappelez vous, c'est la syntaxe avec les backquotes qui permet de capturer la sortie d'une commande dans une variable !
En revanche, pour récupérer la valeur de retour d'une fonction, ou d'un programme, on utilisera la variable spéciale \verb+$?+.
\end{block}
\end{frame}
\begin{frame}[fragile]{Retour de fonctions}
\framesubtitle{Exemple}
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\vspace{-10pt}
\begin{Verbatim}
#!/bin/bash
fonction ()
fonction()
\{
echo 'Salut !'
echo 'Salut !'
return 0
\}
var=`fonction`
echo $?
echo $var
\end{Verbatim}
\end{beamercolorbox}
\medskip
L'exécution affichera le résultat suivant. Comprenez-vous pourquoi ?
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
0
Salut !
\end{Verbatim}
\end{beamercolorbox}
\begin{alertblock}{Valeur du code de retour}
Par convention, un code de retour de $0$ indique le \textbf{succès} de la fonction ou du programme. C'est notamment ce qui est utilisé par Bash pour vérifier qu'une commande a réussi.
\end{alertblock}
\end{frame}
......@@ -3,7 +3,7 @@
\begin{itemize}
\item Un shell est un {\bf interpréteur de commande}.
\item C'est le programme qui gère l'{\bf invite de commande}.
\item C'est donc lui qui a executé toutes les commandes que vous avez pu taper les derniers jours.
\item C'est donc lui qui a executé toutes les commandes que vous avez pu taper ces derniers jours.
\end{itemize}
\end{frame}
......@@ -12,13 +12,13 @@
\framesubtitle{Présentation}
\begin{block}{sh}
{\bf sh} ou {\it Bourne Shell} est le plux vieux de tous les shells. Il est sur tous les OS basés sur UNIX, mais est le plus pauvre en termes de fonctionnalités.
{\bf sh} ou {\it Bourne Shell} est un des shells les plus anciens (1977). Il est sur tous les OS basés sur UNIX, mais est le plus pauvre en terme de fonctionnalités. Il a notamment introduit les \textit{pipes}.
\end{block}
\begin{block}{Bash}
{\bf Bash} ou {\it Bourne Again Shell} est une amélioration du sh. Il est le shell par défaut de la plupart des distributions Linux et des terminaux Mac OS
{\bf Bash} ou {\it Bourne Again Shell} est une amélioration de sh. Il est le shell par défaut de la plupart des distributions Linux et des terminaux Mac OS.
\end{block}
\begin{block}{Mais aussi}
Il existe d'autres shells dérivant de sh : csh, tcsh, ksh, zsh.
Il existe d'autres shells dérivant de sh : csh, tcsh, ksh, zsh\ldots
\end{block}
\end{frame}
......@@ -47,9 +47,10 @@
\vfill
On peut connaître son shell par défaut grâce à la variable d'environnement \$SHELL. On l'affiche donc avec \verb+echo $SHELL+.
On peut aussi voir la liste des shells installés : ils sont généralement dans \verb+/bin+
On peut connaître son shell par défaut grâce à la variable d'environnement \verb+$SHELL+. On l'affiche donc avec \verb+echo $SHELL+.
\medskip
On peut aussi voir la liste des shells installés : ils sont généralement dans le répertoire \verb+/bin+.
\vfill
......@@ -58,25 +59,40 @@
\end{beamercolorbox}
\end{frame}
\begin{frame}[fragile]
\frametitle{Shell et script}
\framesubtitle{Ou l'art de ne plus taper les commandes 10 fois d'affilé}
\begin{block}{Qu'est ce qu'un script ?}
Un script est tout simplement un \textbf{programme écrit dans le langage du shell}. Il peut contenir une suite de commandes, mais aussi des \og{} structures de contrôle \fg{} (conditions, boucles\ldots).
\end{block}
\medskip
On stocke les scripts dans des fichiers, ce qui permet :
\begin{itemize}
\item D'automatiser des tâches, sans avoir à ré-écrire les commandes à chaque fois
\item D'écrire des instructions sur plusieurs lignes de manière lisible
\item D'éviter de se perdre dans l'historique pour retrouver comment on a fait telle ou telle chose
\end{itemize}
\end{frame}
\begin{frame}[fragile]
\frametitle{Un tout premier script !}
\framesubtitle{Hello World !}
Pour nos scripts, on utilisera bash, qui est un bon compromis entre puissance et compatibilité.
Pour nos scripts, on utilisera Bash, qui est un bon compromis entre puissance et compatibilité.
On crée donc un fichier :
On commence par créer un fichier :
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
remy@hp-remy:~$ mkdir scripts \Pause
remy@hp-remy:~$ cd scripts \Pause
remy@hp-remy:~$ mkdir scripts && cd scripts\Pause
remy@hp-remy:~/scripts$ nano helloWorld.sh \Pause
\end{Verbatim}
\end{beamercolorbox}
Par convention, on utilisera l'extension {\bf .sh} pour tous nos scripts. \Pause
On écrit donc dans le fichier :
On écrit ensuite dans le fichier :
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
......@@ -85,7 +101,7 @@ echo 'Hello World !'
\end{Verbatim}
\end{beamercolorbox} \Pause
On rend le fichier exécutable et on lance le script :
On rend enfin le fichier executable et on lance le script :
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
......@@ -101,11 +117,15 @@ Hello World !
\begin{beamercolorbox}[rounded=true]{orangebox}
\enquote{Attends, mais c'est quoi cette ligne ?}
\end{beamercolorbox}
\medskip
\begin{beamercolorbox}[rounded=true, shadow=true]{terminal}
\begin{Verbatim}
#!/bin/bash \textcolor{red}{<----------}
\end{Verbatim}
\end{beamercolorbox}
\medskip
\begin{block}{Le sha-bang}
Le \verb+#!+ est appelé {\bf sha-bang} (ou shebang).
Il est facultatif, mais permet de s'assurer que c'est bien le bon shell qui exécutera notre programme
......
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment