tutoriel:script_shell [Wiki ubuntu-fr] (2023)

programmation,script,shell,console,tutoriel

Un script shell permet d'automatiser une série d'opérations. Il se présente sous la forme d'un fichier contenant une ou plusieurs commandes qui seront exécutées de manière séquentielle.

#!/bin/bash# This script will take an animated GIF and delete every other frame# Accepts two parameters: input file and output file# Usage: ./<scriptfilename> input.gif output.gif# Make a copy of the filecp "$1" "$2"# Get the number of framesnumframes=$(gifsicle --info "$1" \ | grep --perl-regexp --only-matching '\d+ images' \ | grep --perl-regexp --only-matching '\d+')# Deletionlet i=0while test $i -lt $numframesdo rem=$(( $i % 2 )) if test $rem -eq 0 then gifsicle "$2" --delete "#"$(($i/2)) -o "$2" fi let i=i+1 done

Pour faire qu'un script soit exécutable

Méthode graphique

Votre script est un simple fichier texte, par défaut il s'ouvre donc avec l'éditeur de texte défini par défaut (ex : Gedit dans une session Unity ou Gnome).
Pour qu'il soit autorisé à se lancer en tant que programme, il faut modifier ses propriétés.Pour cela faites un clic droit sur son icône, et dans l'onglet "Permissions" des "Propriétés", cocher la case "autoriser l'exécution du fichier comme un programme".

Par la suite, un double-clic sur l’icône vous laissera le choix entre afficher le fichier (dans un éditeur de texte) et le lancer (directement ou dans un terminal pour voir d'éventuels messages d'erreurs)

Par ailleurs Nautilus ne propose pas de lancer le script par simple clic avec les réglages de bases. Il faut aller dans Menu→ Édition → Préférences → Onglet comportement → fichier texte et exécutable et cocher pour fichiers exécutables Demander à chaque fois.

Problème connu

Sous Lubuntu, si cette méthode ne fonctionne pas, vous devez d'abord effectuer l'opération suivante :

  1. Dans le menu principal, allez sur Outils système et faites un clic droit → Propriétés sur le raccourci vers le terminal. Notez le contenu du champ Commande et annulez.

  2. Ouvrez votre gestionnaire de fichier PCManFM et allez dans le menu supérieur sur éditer → Préférences puis dans la fenêtre qui s'ouvre sélectionnez Avancé.

  3. Remplacez le contenu du champ Terminal emulator par le contenu du champ Commande que vous avez pris soin de noter à la première étape.

  4. Vous pouvez ensuite suivre la méthode graphique indiquée ci-dessus pour exécuter vos scripts shell.

Méthode dans un terminal

Il suffit de se placer dans le dossier où est le script, et de lancer :

bash nom_du_script

mais pas toujours bash ( dépend du langage du script )

ou si vous voulez l'exécuter par son nom , il faut le rendre exécutable avec chmod. Pour ceci tapez la commande qui suit :

chmod +x nom_du_script

Puis vous pouvez exécuter le script en faisant :

./nom_du_script

mais pourquoi le ./ ?

Le chemin ./

Il peut être intéressant d'ajouter un répertoire au "PATH" pour pouvoir exécuter ses scripts sans avoir à se placer dans le bon dossier.Je m'explique, quand vous tapez une commande ("ls" par exemple), le shell regarde dans le PATH qui lui indique où chercher le code de la commande.

Pour voir à quoi ressemble votre PATH, tapez dans votre console:

echo $PATH

Cette commande chez moi donnait initialement :

/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games

C'est à dire que le shell va aller voir si la définition de la commande tapée ("ls" pour continuer sur le même exemple) se trouve dans /usr/local/bin puis dans /usr/bin… jusqu'à ce qu'il la trouve.

Ajouter un répertoire au PATH peut donc être très pratique. Par convention, ce répertoire s'appelle bin et se place dans votre répertoire personnel. Si votre répertoire personnel est /home/toto, ce répertoire sera donc /home/toto/bin.Pour pouvoir utiliser vos scripts en tapant directement leur nom (sans le "./") depuis n'importe quel répertoire de votre ordinateur, il vous suffit d'indiquer au shell de chercher aussi dans ce nouveau dossier en l'ajoutant au PATH.Pour ceci, il suffit de faire :

export PATH=$PATH:$HOME/bin

La commande

echo $PATH

retourne maintenant

/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games:/home/toto/bin

et je peux lancer le script appelé "monScript" situé dans "/home/toto/bin" en tapant directement : monScript

Cette procédure est pour une modification temporaire du PATH et qui sera donc effacée à la fin de la session. Pour rendre la modification permanente, ajouter la commande dans le fichier texte caché .bashrc se trouvant dans votre dossier personnel ainsi que dans le dossier /root.

Dans les dernières versions de ubuntu (12.04 +) si le dossier $HOME/bin existe il est automatiquement ajouté au PATH. La commande est incluse dans le fichier ~/.profile lancé lors de toutes sessions (graphique ou console).

Les différents types de shells

Comme vous avez sûrement dû l'entendre, il existe différents types de shells ou en bon français, interpréteurs de commandes :

  • dash (Debian Almquist shell) : shell plus léger que bash, installé par défaut sur Ubuntu ;

  • bash (Bourne Again SHell) : conçu par le projet GNU, shell linux ; le shell par défaut sur Ubuntu ;

  • rbash : un shell restreint basé sur bash. Il existe de nombreuses variantes de bash ;

  • csh, tcsh : shells C, créés par Bill Joy de Berkeley ;

  • zsh, shell C écrit par Paul Falstad ;

  • ksh (⇔ ksh88 sur Solaris et équivaut à ksh93 sur les autres UNIX/Linux cf.Korn shell History): shells korn écrits par David Korn, pdksh (Public Domain Korn Shell ⇔ ksh88) ;

  • rc : shell C, lui aussi conçu par le projet GNU ;

  • tclsh : shell utilisant Tcl ;

  • wish : shell utilisant Tk .

Il existe bien entendu beaucoup d'autres types de shells.
Pour savoir quel type de shell est présent sur une machine, aller dans un terminal et taper la commande ps.

La commande sh est en fait un lien symbolique vers l'interpréteur de commandes par défaut : /bin/dash.

Les variables

Il faut savoir que en bash les variables sont toutes des chaînes de caractères.
Cela dépendra de son USAGE, pour une opération arithmétique prochaine voir : let ma_variable sinon pour conserver une valeur :il suffit de lui donner un nom et une valeur avec l'affectation égale :

ma_variable=unmot

Ici la valeur est affectée à la variable ma_variable .
Attention: pas d'espace ni avant ni après le signe "=" .
Autre exemple avec une commande avec arguments :

(Video) Bash Shell Scripting Tutorial for Beginners | Our First Script Using Bash on Linux | Ep#1 (Ubuntu)

nbre_lignes=$(wc -l < fichier.ext)

nbre_lignes contiendra le nombre de lignes contenu dans fichier.ext .

Pour voir le contenu d'une variable, on utilisera echo (par exemple) :

echo $ma_variable

renverra : unmot .

Pour gérer les espaces et autres caractères spéciaux du shell, on utilisera les guillemets ou bien une notation avec des apostrophes :

echo $ma_variable
echo "$ma_variable"
echo ${ma_variable}
echo "${ma_variable}"

renverront toutes la même réponse : unmot .

Et avec des chemins de répertoires :

chemin_de_base="/home/username/un repertoire avec espaces"chemin_complet="$chemin_de_base/repertoire"

Comme on le voit ci-dessus si on met une chaîne de caractères avec des espaces entre guillemets, la variable la prend bien mais attention à l'utiliser aussi avec des guillemets…

rsync -av "$chemin_complet"

sinon les espaces reprennent leurs rôles de séparateur!

Des variables système permettent d'accélérer la saisie et la compréhension.Pour voir les variables d'environnement de votre système tapez simplement :

env

Quelques variables d'environnement à connaître :HOME, USER, PATH, IFS,…

Pour appeler ou voir une variable, par exemple HOME, il suffit de mettre un $ devant, par exemple :

echo $HOME

Ce petit code va afficher la variable HOME à l'écran.

Il existe des variables un peu spéciales :

Nomfonction
$* contient tous les arguments passés à la fonction
$# contient le nombre d'arguments
$? contient le code de retour de la dernière opération
$0 contient le nom du script
$n contient l'argument n, n étant un nombre
$! contient le PID de la dernière commande lancée

Exemple : créer le fichier arg.sh avec le contenu qui suit :

#!/bin/bashecho "Nombre d'arguments ... : "$#echo "Les arguments sont ... : "$*echo "Le second argument est : "$2echo "Et le code de retour du dernier echo est : "$?

Lancez ce script avec un ou plusieurs arguments et vous aurez :

./arg.sh 1 2 3Nombre d'arguments ... : 3Les arguments sont ... : 1 2 3Le second argument est : 2Et le code de retour du dernier echo est : 0

Exemple: un sleep interactif pour illustrer $! (Cf. les fonctions).
Pour déclarer un tableau, plusieurs méthodes :première méthode (compatible bash, zsh, et ksh93 mais pas ksh88, ni avec dash, qui est lancé par "sh") :

tab=("John Smith" "Jane Doe")

ou bien :

tab[0]='John Smith'tab[1]='Jane Doe'

Pour compter le nombre d'éléments du tableau :

len=${#tab[*]} ou echo ${#tab[@]}

Pour afficher un élément :

echo ${tab[1]}

Pour afficher tous les éléments :

echo ${tab[@]}

ou bien (en bash ou en ksh93 mais pas en ksh88) :

for i in ${!tab[@]}; do echo ${tab[i]}; done

ou encore ( C style ) :

for (( i=0; i < ${#tab[@]}; i++ )); do echo ${tab[i]}; done

NB : toutes les variables sont des tableaux. Par défaut, c'est le premier élément qui est appelé :

echo ${tab[0]}

et :

echo ${tab}

renverront la même réponse.

NB2 : les tableaux sont séparés par un séparateur défini : l'IFS.Par défaut l'IFS est composé des trois caractères : $' \t\n' soit espace, tabulation, saut de ligne.Il peut être forcé sur un autre caractère.

IFS=$SEPARATEUR

$SEPARATEUR pourra être :

  • une lettre (pe : n, i,…)

  • une ponctuation (pe : ',', '.', '-'…)

  • un caractère spécial : ($'\t' : tabulation, $'\n' : saut de ligne,…)

Les arguments en ligne de commande

Pour passer des arguments en ligne de commande c'est encore une fois très simple. Chaque argument est numéroté et ensuite on l'appelle par son numéro :

 ./test.sh powa noplay

Voici notre test.sh

#!/bin/shecho $3echo $2

Notez que $0 est le nom du fichier.

shift est une commande très pratique lorsque vous traitez des arguments en ligne de commande. Elle permet de faire "défiler" les arguments ($0, $1, $2, …). C'est à dire que le contenu de $1 passe dans $0, celui de $2 dans $1 et ainsi de suite. Il est tout à fait possible de traiter les arguments avec for i in $*; do mais lorsque vous aurez des options du style –title "mon_titre" il sera très laborieux de récupérer la valeur "mon_titre".

Voici un exemple de script où vous devez vous souvenir de ce que vous avez écrit (un petit jeu de mémoire, quoi) :

#!/bin/shclear # Un peu facile si la commande reste au dessus :-)until [ $# = 0 ]do echo -n "Taper l'option suivante : " read Reslt if [ "$Reslt" = "$1" ]; then echo "Bien joué !" else echo "Non mais quand même !!! C'ÉTAIT $1 ET NON PAS $Reslt PETIT FRIPON !!!" sleep 3 # Juste pour le fun du script qui rage ;-p echo "Donc je te bannis de ubuntu-fr.org ! Et toc !! Tu ne peux rien contre moi !!!" exit 1 fi shift # On défiledoneecho "Vous avez réussi !"

L'arithmétique

(( variable = 2 + $autre_var * 5 ))

Exemple: besoin de définir des plages de valeurs (1 à 500 puis 501 à 1000 puis 1001 à 1500…)

id_per_step = 500for (( i=0; i<8; i++ )); do(( min_step_id = 1 + $i * $id_per_step ))(( max_step_id = (( $i + 1 )) * $id_per_step ))echo "$min_step_id to $max_step_id "done

Vocabulaire

La commande test

La commande test existe sous tous les Unix, elle permet de faire un test et de renvoyer 0 si tout s'est bien passé ou 1 en cas d'erreur.

En mode console, faites man test pour connaître tous les opérateurs, en voici quelques-uns :

Opérateurs de test sur fichiers

Syntaxe Fonction réalisée
-e fichier renvoie 0 si fichier existe.
-d fichier renvoie 0 si fichier existe et est un répertoire.
-f fichier renvoie 0 si fichier existe et est un fichier 'normal'.
-w fichier renvoie 0 si fichier existe et est en écriture.
-x fichier renvoie 0 si fichier existe et est exécutable.
f1 -nt f2 renvoie 0 si f1 est plus récent que f2.
f1 -ot f2 renvoie 0 si f1 est plus vieux que f2.

Opérateurs de comparaison numérique

Syntaxe Fonction réalisée
$A -lt 5 renvoie 0 si $A est strictement inférieur à 5
$A -le 5 renvoie 0 si $A est inférieur ou égal à 5
$A -gt 5 renvoie 0 si $A est strictement supérieur à 5
$A -ge 5 renvoie 0 si $A est supérieur ou égal à 5
$A -eq 5 renvoie 0 si $A est égal à 5
$A -ne 5 renvoie 0 si $A est différent de 5
(Video) Grabbing a Section of a Wikipedia Article on Linux with BASH Shell Script

Les crochets

On peut raccourcir la commande test par des crochets. Exemple :

test -f /etc/passwdecho $?0[ -f /etc/passwd ] echo $?0

Affichera la valeur 0 : ce fichier existe, 1 dans le cas où le fichier /etc/passwd n'existe pas. Sous Unix, le code de retour est par convention et en général 0 s'il n'y a aucune erreur et différent de 0 dans les autres cas.

La syntaxe la plus appropriée dans de la programmation shell moderne est le double crochet :

[[ -f /etc/passwd ]]

Cela gère bien mieux les problèmes d'espaces dans les noms de fichiers, les erreurs etc… C'est une structure propre à bash (ksh, ?) qui est le shell par défaut dans la plupart des distributions Linux, et de Ubuntu en particulier. On garde en général des simples crochets pour les scripts shell qui doivent être à tout prix POSIX ( utilisation sur des Unix sans installation préalable de bash, comme BSD, Solaris… ) .

Les opérateurs logiques

Il y a en 3 :

  • le et logique : -a

  • le ou logique : -o

  • le non logique : !

Exemple :

echo "renverra 0 si les deux expressions sont vraies"test expr1 -a expr2 [ expr1 -a expr2 ]
Table de vérité de « -a »
Comparaison Résultat Calcul
0 et 0 0 0 × 0 = 0
0 et 1 0 0 × 1 = 0
1 et 0 0 1 × 0 = 0
1 et 1 1 1 × 1 = 1

Les deux assertions doivent être vérifiées pour que la condition le soit aussi.

Table de vérité de « -o »
Comparaison Résultat Calcul
0 ou 0 0 0 + 0 = 0
0 ou 1 1 0 + 1 = 1
1 ou 0 1 1 + 0 = 1
1 ou 1 1 1 + 1 = 1

Dès que l'une des deux assertions est vérifiée, la condition globale l'est aussi.

Exemple plus complet :

#!/bin/shecho -n "Entrez un nom de fichier: "read fileif [ -e "$file" ]; then echo "Le fichier existe!"else echo "Le fichier n'existe pas, du moins n'est pas dans le répertoire d'exécution du script"fi

La seule chose qui prête à confusion est que l'on vérifie seulement si le fichier « file » est dans le répertoire où le script a été exécuté.

La structure : `if`

Avant de commencer à faire des scripts de 1000 lignes, il serait intéressantde voir comment se servir des variables, et des instructions if, then, elif, else, fi. Cela permet par exemple de faire réagir le script de manière différente, selon la réponse de l'utilisateur à une question.

En bash, les variables ne se déclarent généralement pas avant leur utilisation, on les utilise directement et elles sont créées lors de sa première mise en œuvre.

Pour pouvoir voir la valeur d'une variable il faut faire précéder son nom du caractère « $ ».

#!/bin/shecho -n "Voulez-vous voir la liste des fichiers Y/N : "read ouinonif [ "$ouinon" = "y" ] || [ "$ouinon" = "Y" ]; then echo "Liste des fichiers :" ls -laelif [ "$ouinon" = "n" ] || [ "$ouinon" = "N" ]; then echo "Ok, bye! "else echo "Il faut taper Y ou N!! Pas $ouinon"fi

Explication

Ce script peut paraître simple à première vue mais certaineschoses prêtent à confusion et ont besoin d'être expliquées en détail.

Tout abord, le `echo -n` permet de laisser le curseur sur la même ligne, cequi permet à l'utilisateur de taper la réponse après la question (questiond'esthétique).

L'instruction `read` permet d'affecter une valeur ou un caractère à une variable quelconque, en la demandant à l'utilisateur.

En bash, la variable est considérée comme une chaîne même si celle-ci contient une valeur numérique, et les majuscules sont considérées différentes des minuscules, $M ≠ $m.

Ensuite vient l'instruction conditionnelle `if`. Elle est suivie d'un « [ »pour délimiter la condition. La condition doit bien être séparée des crochets par un espace ! Attention, la variable est mise entre guillemetscar dans le cas où la variable est vide, le shell ne retourne pas d'erreur, mais en cas contraire, l'erreur produite ressemble à :

[: =: unaryoperator expected

L'opérateur `||` signifie exécuter la commande suivante si la commande précédente n'a pas renvoyé 0. Il existe aussi l'opérateur && qui exécute la commande suivante si la commande précédente a renvoyé 0, et enfin ; qui exécute l'opération suivante dans tous les cas.

Exemple :créer le répertoire toto s'il n' existe pas

[ ! -d /tmp/toto ] && mkdir /tmp/toto[ -d /tmp/toto ] || mkdir /tmp/tototest ! -d /tmp/toto && mkdir /tmp/totorm -rf /tmp/toto;mkdir /tmp/toto

Les « { » servent à bien délimiter le bloc d'instructions suivant le `then`, est une commande et donc si elle est sur la même ligne que le `if` les deux commandes doivent être séparées par un `;`

Ensuite, `elif` sert à exécuter une autre série d'instructions, si la condition décrite par `if` n'est pas respectée, et si celle fournie après ce `elif` l'est.

Enfin, `else` sert à exécuter un bloc si les conditions précédentes ne sont pas respectées (ah les jeunes, ils respectent plus rien de nos jours tutoriel:script_shell [Wiki ubuntu-fr] (1)).

`fi` indique la fin de notre bloc d'instructions `if`. Cela permet de voir où se termine la portion de code soumise à une condition.

Quelques petites commandes pratiques :

sh -n nom_du_fichier

ou

bash -x chemin_du_fichier

Cette commande vérifie la syntaxe de toutes les commandes du script, pratique quand on débute et pour les codes volumineux.

sh -u nom_du_fichier

Celle-ci sert à montrer les variables qui n'ont pas été utilisées pendant l'exécution du programme.

Voici le tableau des opérateurs de comparaison, ceux-ci peuvent s'avérer utiles pour diverses raisons, nous verrons un peu plus loin un exemple.

$A = $B # Vérifie si les deux chaînes sont égales.$A != $B # Vérifie si les deux chaînes sont différentes.-z $A # Vérifie si A n'existe pas (ne contient pas de chaîne).-n $A # Vérifie si A existe (contient une chaîne).

Les structures while et until

La commande while exécute ce qu'il y a dans son bloc tant que la conditionest respectée :

#!/bin/shcmpt=1cm=3echo -n "Mot de passe : "read mdpwhile [ "$mdp" != "ubuntu" ] && [ "$cmpt" != 4 ]do echo -n "Mauvais mot de passe, plus que "$cm" chance(s): " read mdp cmpt=$(($cmpt+1)) cm=$(($cm-1))doneecho "Non mais, le brute-force est interdit en France !!"

On retrouve des choses déjà abordées avec `if`.Le `&&` sert à symboliser un "et", cela implique que deux conditions sontà respecter. Le `do` sert à exécuter ce qui suit si la condition est respectée.Si elle ne l'est pas, cela saute tout le bloc (jusqu'à `done`).Vous allez dire :

Mais qu'est-ce que c'est ce truc avec cette syntaxe bizarre au milieu ?

Cette partie du code sert tout simplement à réaliserune opération arithmétique. A chaque passage,'cmpt = cmpt+1' et 'cm = cm-1'.

`while` permet de faire exécuter la portion de code un nombre indéterminé de fois.La commande `until` fait la même chose que la commande `while` mais en inversant.C'est-à-dire qu'elle exécute le bloc jusqu'à ce que la condition soit vraie, donc elles'emploie exactement comme la commande `while`.

Par exemple, si on a besoin d'attendre le démarrage de notre window manager pour exécuter des commandes dans notre Xsession il sera plus intéressant d'utiliser le `until`:

(Video) Ubuntu linux terminal, utilisation de grep [FRANÇAIS]

#!/bin/shuntil pidof wmaker do sleep 1donexmessage "Session loaded" -buttons "Continue":0,"That all":1;[ $? -eq 0 ] && xmessage "Load more..."

Mais on aurait pu aussi faire:

#!/bin/shwhile [ -z $(pidof wmaker) ]do sleep 1done #(...)

La structure case

Regardons la syntaxe de cette commande, qui n'est pas une des plus simples :

case variable in modèle [ | modèle] ...) instructions;; modèle [ | modèle] ...) instructions;; ...esac

Cela peut paraître complexe mais on s'y habitue quand on l'utilise.

Mais à quoi sert cette commande ?

Elle sert à comparer le contenu d'une variable à des modèles différents. Les ;; sont indipensables car il est possible de placer plusieurs instructions entre un modèle et lesuivant. Les ;; servent donc à identifier clairement la fin d'une instruction etle début du modèle suivant.

Exemple :

#!/bin/shecho -n "Êtes-vous fatigué ? "read oncase "$on" in oui | o | O | Oui | OUI ) echo "Allez faire du café !";; non | n | N | Non | NON ) echo "Programmez !";; * ) echo "Ah bon ?";;esac

La seule chose qui mérite vraiment d'être expliquée est sans doute `* )`.Cela indique tout simplement l'action à exécuter si la réponse donnée n'est aucune de celles données précédemment.

Il existe aussi plusieurs structures pour les modèles, telles que :

case "$truc....." in [nN] *) echo "Blablabla...";; n* | N* ) echo "Bla....";;

Et plein d'autres encore…

On mélange tout ça

Pour vous donner une idée précise de ce que peuvent réaliser toutes ces instructions,voici un petit script censé refaire un prompt avec quelques commandes basiques :

#!/bin/bashclearecho echo "#################### Script ############################"echo echo "#############################"echo -n "LOGIN: "read loginecho -n "Hôte: "read hoteecho "#############################"echoecho "### Pour l'aide tapez help ###"echo while [ 1 ]; do # permet une boucle infinieecho -n ""$login"@"$hote"$ " # qui s'arrête avec breakread repscase $reps in help | hlp ) echo "À propos de TS --> about" echo "ls --> liste les fichiers" echo "rm --> détruit un fichier (guidé)" echo "rmd --> efface un dossier (guidé)" echo "noyau --> version du noyau Linux" echo "connect --> savoir qui s'est connecté dernièrement";; ls ) ls -la;; rm ) echo -n "Quel fichier voulez-vous effacer : " read eff rm -f $eff;; rmd | rmdir ) echo -n "Quel répertoire voulez-vous effacer : " read eff rm -r $eff;; noyau | "uname -r" ) uname -r;; connect ) last;; about | --v | vers ) echo "Script simple pour l'initiation aux scripts shell";; quit | "exit" ) echo Au revoir!! break;; * ) echo "Commande inconnue";;esacdone

Remarque

Comme vous l'avez remarqué, l'indentation a une place importante dansce programme. En effet, celui-ci est plus lisible et cela évite aussi de fairedes erreurs. C'est pourquoi il est préférable de bien structurer le code que vousécrivez.

La structure for

L'instruction `for` exécute ce qui est dans son bloc un nombre de fois prédéfini. Sa syntaxe est la suivante :

for variable in valeurs; do instructionsdone

ou le classique:

for (( i=$min; i<=$max; i++ )); do instructions_avec_i # ou pasdone

Comme vous l'aurez sans doute remarqué, on assigne une valeur différente à variable à chaque itération. On peut aussi très facilement utiliser des fichiers comme "valeur".
Rien ne vaut un exemple :

#!/bin/shfor var in *.txt; do echo "$var"done 

On peut voir une syntaxe un peu particulière :

$(sort *.txt)

Ceci sert à indiquer que ce qui est entre les parenthèses est une commande à exécuter.

On peut aussi utiliser cette instruction simplement avec des nombres, cela permet de connaître le nombre d'itérations :

#!/bin/shfor var in 1 2 3 4 5 6 7 8 9; do echo $vardone 

On peut très bien aussi utiliser d'autres types de variables, comme par exemple des chaînes de caractères :

#!/bin/shfor var in Ubuntu Breezy 5.10; do echo $vardone 

Il faut quand même faire attention au fait que Ubuntu Breezy 5.10 est différent de "Ubuntu Breezy 5.10" dans ce cas. En effet, tous les mots placés entre "" sont considérés comme faisant partie de la même chaîne de caractères. Sans les "", sh considèrera qu'il y a une liste de trois chaînes de caractères.

Les fonctions

Les fonctions sont indispensables pour bien structurer un programme mais aussi pouvoir le simplifier, créer une tâche, la rappeler… Voici la syntaxe générale de 'déclaration' d'une fonction :

nom_fonction(){ instructions}

Cette partie ne fait rien en elle même, elle dit juste que quand on appellera nom_fonction, elle fera instruction. Pour appeler une fonction (qui ne possède pas d'argument, voir plus loin) rien de plus simple :

nom_fonction

Rien ne vaut un petit exemple :

#!/bin/sh#Definition de ma fonctionmafonction(){ echo 'La liste des fichiers de ce répertoire' ls -l}#fin de la définition de ma fonctionecho 'Vous allez voir la liste des fichiers de ce répertoire:'mafonction #appel de ma fonction

Comme vous l'avez sans doute remarqué, quand on appelle la fonction, on exécute simplement ce qu'on lui a défini au début, dans notre exemple, echo… et ls -l, on peut donc faire exécuter n'importe quoi à une fonction.

Les fonctions peuvent être définies n'importe où dans le code du moment qu'elles sont définies avant d'être utilisées. Même si en bash les variables sont globales, il est possible de les déclarer comme locales au sein d'une fonction en la précédant du mot clé local: local ma_fonction .

Exemple: un sleep interactif :

#!/bin/bashinfo(){ echo -e "$1\nBye" exit}test -z "$1" && info "requiert 1 argument pour le temps d'attente..." || PRINT=$(($1*500))test -z $(echo "$1" | grep -e "^[0-9]*$") && info "'$1' est un mauvais argument"test $1 -gt 0 || info "Je ne prends que les entiers > 0"print_until_sleep(){ local COUNT=0 while [ -d /proc/$1 ]; do test $(($COUNT%$2)) -eq 0 && echo -n "*" COUNT=$(($COUNT+1)) done}sleep $1 & print_until_sleep $! $PRINTecho -e "\nBye"

Extraire des sous-chaînes

Pour extraire une chaîne d'une chaîne on utilise : ${ chaîne : position : nombre de caractères } (n'oubliez pas le : qui sépare les "paramètres").

Dans la partie chaîne pour faire référence à une variable on ne met pas de $ ! Tandis que dans les autres options le $ est nécessaire (sauf si vous n'utilisez pas de variable). Il y a de quoi s’emmêler les pinceaux. Si vous n'avez pas compris (ce n'est pas étonnant), les exemples de cette partie vous aideront beaucoup.

Par exemple pour savoir ce que l'on aime manger en fonction de sa langue (vous êtes alors vraiment ultra geek tutoriel:script_shell [Wiki ubuntu-fr] (2) !) :

#!/bin/bash#favoritefoodif [ ${LANG:0:2} = "fr" ]; then echo "Vous aimez les moules frites !"elif [ ${LANG:0:2} = "en" ]; then echo "You love the... pudding !"elif [ ${LANG:0:2} = "es" ]; then echo "Te gusta el jamón !" else echo ":'-("fi#Noter que $LANG n'a pas le préfixe '$'. ${$LANG:0:2} ne fonctionne pas !

puis :

$ ./favoritefoodVous aimez les moules frites !$ env LANG=en ./favoritefoodYou love the... pudding !$ env LANG=es ./favoritefoodTe gusta el jamón !$ env LANG=it ./favoritefood:'-(

Ce code illustre un moyen de faire des scripts multilingues .

Une variante permet de tronquer uniquement le début de la chaîne. C'est ${ chaîne : nombre de caractères} .
Le tout peut s'illustrer par un (vraiment) petit exemple :

#!/bin/bash#truncbegin <chaîne> <nombre>echo ${1:$2}#Noter bien que echo ${1:2} tronquerait les 2 premiers caractères (et non le nombre indiqué par le 2e paramètre).

puis :

$ ./truncbegin "Hello world !" 5world !

La couleur

Qui n’a jamais voulu faire un script avec des couleurs pour pouvoir différencier les titres des paramètres et les paramètres de leur valeur par exemple…

Présentation de la syntaxe

Comme toute commande sous Linux, il faut utiliser une syntaxe par défaut et y passer quelques paramètres. Pour les couleurs au sein de scripts shell, c’est le même principe.

echo -e '\033[A;B;Cm toto \033[0m'

Dans la commande passée ci-dessus, nous pouvons constater qu’il y a 3 paramètres présents: A, B et C.
A : correspond à un effet affecté au texte affichéB : correspond à la couleur du texteC : identifie la couleur du fond du texte affiché

Et enfin on termine notre affichage avec « \033[0m », qui spécifie au terminal de revenir aux couleurs définies par défaut.

Présentation des différentes valeurs Effet

Nous allons commencer par les différents effets possibles :

CodeEffet
0Normal
1Gras
21Non-gras
2Sombre
22Non-sombre
3Italique
23Non-italique
4Souligné
24Non-souligné
5Clignotant
25Non-clignotant
7Inversé
27Non-inversé
8Invisible
28Non-invisible
9Barré
29Non-barré

Présentation des différentes valeurs des couleurs

Maintenant que nous avons présenté les différents effets possibles d’attribuer à du texte, nous allons nous attaquer aux couleurs.
Chaque couleur a 2 valeurs, la première utilisée pour la couleur du texte, et la seconde pour la couleur du fond.

(Video) Linux Command Line Full course: Beginners to Experts. Bash Command Line Tutorials

CouleurCouleur texteCouleur fond
Noir3040
Rouge3141
Vert3242
Jaune3343
Bleu3444
Magenta3545
Cyan3646
Blanc3747

Exemple

echo -e '\033[1;30;47m toto \033[0;32m est sur \033[1;33m un bateau \033[0m'

Exemples et exercices

Comme indiqué dans la section liens de cette page, de très bon exemples et exercices illustrent le cours disponible sur cette page :Guide avancé d'écriture des scripts Bash - Une exploration en profondeur de l'art de la programmation shell

Aux structures décrites ci-dessus, il est nécessaire, pour réaliser des scripts poussés, de connaître les commandes shell les plus usitées.
Vous en trouverez une présentation sur cette autre page du wiki : initiation_au_shell .

La programmation de script shell étant ouverte à tous, cela permet de bénéficier de nombreux scripts pour des applications très variées ; cependant, la plupart sont proposés sans aucune garantie.Vous pourrez trouver une liste de scripts pouvant servir d'exemples sur la page scripts utiles du wiki.

Une fois vos armes faites, proposez vos contributions sur le topic du forum [VOS SCRIPTS UTILES] et rajoutez un lien dans la page du wiki ci-dessus.

L'art d'écrire un script

  • Des vérifications approfondies doivent être effectuées sur TOUTES les commandes utilisées.

  • Des commentaires détaillés doivent apparaître lors de chaque étape. De même, chaque étape doit être suivie d'un "echo <voici ce que je fais>" (particulièrement utile notamment lors du débogage).

  • Lors d'une mise à jour, un fil de discussion doit être précisé pour tracer les bugs éventuels.

  • Avertir les utilisateurs des dégâts que peuvent causer les commandes utilisées. (Ces deux dernières remarques ne concernent bien sûr que les scripts que l'on souhaite diffuser.)

  • Commencer par :

    #!/bin/bash# Version du script
  • Créer des fonctions pour des actions précises :

    nom_de_la_fonction(){...}
  • Utiliser des chemins absolus pour les dossiers et des chemins relatifs pour les noms de fichiers :

    $CHEMIN_DU_DOSSIER/$NOM_DU_FICHIER
  • Utiliser les entrées de commandes pour les fonctions :

    nom_de_la_fonction $1 $2 $3 ....
  • Si votre script doit s'arrêter à cause d'une erreur, d'une variable qui ne correspond pas à vos attentes utiliser des numéros exit différents :

    exit 100;exit 101;exit 102;....

    Ça permettra d'identifier d'où vient l'erreur.

  • Utiliser le tableau ${PIPESTATUS[@]} pour récupérer les états des autres commandes.

  • On peut écrire une fonction d'erreur du type :

    erreur(){ tab=( ${PIPESTATUS[@]} ) for (( i=0; i < ${#tab[@]}; i++ )); do ((i+=i)); done if ((i > 0)); then zenity --error --title="Une erreur est survenue" --text="Une erreur est survenue " exit 100 fi}

    ainsi après chaque commande vous pouvez donner des codes d'exécutions différents.

Astuce : le plus important dans tout programme est l'algorithme utilisé.

Exemple :supposons que vous ayez une base de données, avec 3 catégories d'enregistrements possibles :éléphant bleu, éléphant blanc, éléphant rose ayant chacun 30 individus.Votre script doit compter le nombre d'éléphants bleus et blancs.Deux possibilités s'offrent à vous :

  • calculer le nombre d'éléphants bleus + éléphants blancs

ou

  • calculer le nombre total d'éléphants - nombre d'éléphants roses

Quel algorithme choisissez-vous ?

Résultat : le premier car dans le deuxième il faut d'abord calculer le nombre total d'éléphants, donc un calcul en plus tutoriel:script_shell [Wiki ubuntu-fr] (3) .

Liens

Contributeurs: Gapz, Gloubiboulga ,sparky et deax_one

FAQs

How do I run a script in Ubuntu? ›

Follow these steps to create and run a shell script of your own from your Ubuntu home directory:
  1. Create a directory to store your shell script.
  2. Create a file in your scripts folder with a . ...
  3. Add an execute permission to the file to avoid permission denied errors during execution.
14 Jan 2022

Why does Ubuntu use dash? ›

A major reason for using dash as rather than bash as /bin/sh is that it's significantly faster. This was especially important for Ubuntu, which has striven to keep boot times short since the beginning.

How do I run a bash command in Ubuntu? ›

There are four different methods of running a Bash script in Ubuntu 20.04, and we will discuss the following methods in detail:
  1. Method 01: By Making the File Executable. ...
  2. Method 2: By Using the “bash” Keyword. ...
  3. Method 3: By Using the “sh” Keyword. ...
  4. Method 4: By Using the GUI of Ubuntu 20.04.

Does Ubuntu use dash? ›

Starting with DebianSqueeze and Ubuntu 6.10, the default shell will be dash. The default system shell, /bin/sh, was changed to /bin/dash due to the following technical reasons: To speed up the system boot time.

What is .sh file in Ubuntu? ›

The . sh file is nothing but the shell script to install given application or to perform other tasks under Linux and UNIX like operating systems. The easiest way to run . sh shell script in Linux or UNIX is to type the following commands. Open the terminal (your shell prompt) and type the commands.

How do I run a file in Ubuntu? ›

This can be done by doing the following:
  1. Open a terminal.
  2. Browse to the folder where the executable file is stored.
  3. Type the following command: for any . bin file: sudo chmod +x filename.bin. for any .run file: sudo chmod +x filename.run.
  4. When asked for, type the required password and press Enter.

Is dash better than Bash? ›

The Dash shell is roughly 2-5 times more efficient than the Bash shell in terms of execution speed.

Does Ubuntu use Bash or sh? ›

The default shell on Ubuntu is the Bash shell (shorthand for Bourne Again SHell). This shell, which began life as an open source version of the Bourne shell, was developed for the GNU Project by Brian Fox and is based on features provided by both the Bourne shell and the C shell.

Is Linux a OS? ›

Linux® is an open source operating system (OS). An operating system is the software that directly manages a system's hardware and resources, like CPU, memory, and storage.

How do I run a file in bash? ›

Make a Bash Script Executable
  1. 1) Create a new text file with a . sh extension. ...
  2. 2) Add #!/bin/bash to the top of it. This is necessary for the “make it executable” part.
  3. 3) Add lines that you'd normally type at the command line. ...
  4. 4) At the command line, run chmod u+x YourScriptFileName.sh. ...
  5. 5) Run it whenever you need!

Is Ubuntu a bash? ›

Bash is the language that you will learn to love as much of everyday Ubuntu life is done/can be done using the Terminal. You will soon learn that most things can be done through both GUI (Graphical User Interface) and CLI (Command Line Interface), however some things are more easily achieved from one or the other.

How do I run a Bash script in Linux? ›

The procedure is as follows:
  1. Create a new file called demo.sh using a text editor such as nano or vi in Linux: nano demo.sh.
  2. Add the following code: #!/bin/bash echo "Hello World"
  3. Set the script executable permission by running chmod command in Linux: chmod +x demo.sh.
  4. Execute a shell script in Linux: ./demo.sh.
11 Aug 2022

Which is better bash or zsh? ›

Zsh is built on top of bash thus it has additional features. Zsh is the default shell for macOS and Kali Linux. Zsh provides the user with more flexibility by providing various features such as plug-in support, better customization, theme support, spelling correction, etc.

What is Linux dash? ›

dash is the standard command interpreter for the system. The current version of dash is in the process of being changed to conform with the POSIX 1003.2 and 1003.2a specifications for the shell.

What is my shell name Ubuntu? ›

Use the following Linux or Unix commands: ps -p $$ – Display your current shell name reliably. echo "$SHELL" – Print the shell for the current user but not necessarily the shell that is running at the movement.

How do I run a .sh script? ›

How to run SH file?
  1. Open the Linux terminal and go to the directory where the SH file is located.
  2. By Using chmod command, set execute permission on your script (if not set already).
  3. Run script using one of the following. ./filename.sh. sh filename.sh. bash script-name-here.sh.

How do I run a .sh file? ›

sh file, you need to make it executable:
  1. Right-click on the file.
  2. Select Properties.
  3. Select Permissions.
  4. Select Allow executing file as a program.

Is bash and sh the same? ›

bash and sh are two different shells of the Unix operating system. bash is sh, but with more features and better syntax. Bash is “Bourne Again SHell”, and is an improvement of the sh (original Bourne shell). Shell scripting is scripting in any shell, whereas Bash scripting is scripting specifically for Bash.

How do you run a .exe file on Linux? ›

How do I run .exe files on Linux? Navigate to the directory with the file, then open the file with Wine. In the terminal, navigate to the directory containing the file with the command cd <directory name> . Then, run the file with the command wine <filename>.exe .

Can we install EXE file in Ubuntu? ›

If the .exe file is a windows executeable, you can't run it directly in Ubuntu (or other Linux's). Either you should install Wine and run it through that, or find a utility in Ubuntu that does the same as the windows one.

Does Linux have exe files? ›

Linux supports many other different formats for executable files; in this way, it can run programs compiled for other operating systems, such as MS-DOS EXE programs or BSD Unix's COFF executables. A few executable formats, like Java or bash scripts, are platform-independent.

What is the fastest shell? ›

According to my tests, ksh is the winner and zsh is the runner-up. Both shells are 2–30 times faster than bash depending on the test.

Why does Debian use dash? ›

Debian uses Dash as the default non-interactive shell. It is not intended to be used interactively by a user, for example, in a terminal emulator, but rather focuses on speed and compatibility with standards.

Is dash compatible with bash? ›

Dash is not Bash compatible, but Bash tries to be mostly compatible with POSIX, and thus Dash. Dash shines in: Speed of execution. Roughly 4x times faster than Bash and others.

Is bash a Linux? ›

What is bash (Bourne Again Shell)? Bash (Bourne Again Shell) is the free and enhanced version of the Bourne shell distributed with Linux and GNU operating systems. Bash is similar to the original, but has added features such as command-line editing.

What is bash coding? ›

What is a Bash Script? A bash script is a series of commands written in a file. These are read and executed by the bash program. The program executes line by line. For example, you can navigate to a certain path, create a folder and spawn a process inside it using the command line.

What does .sh mean in Linux? ›

sh, also known as Bourne Shell, is a command programming language for UNIX-like systems, defined by the POSIX standards. sh can take input from either a keyboard or a file, commonly called a script file. On most Linux systems, it's implemented by programs like the original Bourne Shell, dash, and ksh.

Who uses Linux? ›

10 Top Companies That Are Powered By Linux Ad
  • Oracle. ​It's one of the biggest and most popular companies that offer informatics products and services, it uses Linux and also it has its own Linux distribution called “Oracle Linux”. ...
  • NOVELL. ...
  • RedHat. ...
  • Google. ...
  • IBM. ...
  • 6. Facebook. ...
  • Amazon. ...
  • DELL.

Why do people use Linux? ›

The Linux system is very stable and is not prone to crashes. The Linux OS runs exactly as fast as it did when first installed, even after several years. Most of us must have experienced how a freshly installed Windows system runs extremely fast and the same system becomes slow after around six months to one year.

What is the best Linux? ›

1. Ubuntu - Best overall Linux distro for laptops. Ubuntu is one of the most versatile Linux distributions with an active community and long-term supports. It is a favorite among newbies and intermediate users, especially due to the large number of software utilities available.

How do you execute a file? ›

To execute a file in Microsoft Windows, double-click the file. To execute a file in other GUI operating systems, a single or double-click will execute the file. To execute a file in MS-DOS and numerous other command line operating systems, type the name of the executable file and press Enter .

How do I run code in Terminal? ›

How to start VS Code from the terminal (command line)
  1. Open a terminal window. On windows, open a Command Prompt window, on MacOS, open a terminal window.
  2. Navigate to the folder or file you want to open (using cd) ...
  3. Type "code" [path to file]

How do I open a file in Ubuntu Terminal? ›

Answer: Use the less Command

You can use the less command if you simply want to open a file in terminal to view its content (not to edit). It will show the file contents from the top. You can scroll down and up to see the contents of a larger file; press the q key on the keyboard to exit and get back to terminal.

How does Ubuntu work with Windows? ›

A native Ubuntu shell built directly into the Windows desktop just makes it that much easier to write code using Visual Studio, vim, or emacs, and then push it to a cloud instance with git, scp, or rsync, and vice versa. Obviously, many of those cloud instances will be Azure Ubuntu instances."

How do I run Ubuntu shell on Windows? ›

Install Ubuntu on WSL2 on Windows 10
  1. Install WSL.
  2. Download Ubuntu.
  3. Configure Ubuntu.
  4. Install your first package.
  5. Customising your Terminal with Windows Terminal Preview.
  6. Enjoy Ubuntu on WSL!

How do I run a bash file in Terminal? ›

This method is quite easy to run a bash script, and all of them are quite simple. We just need to type in “source” before the file/script name with an extension. In a terminal, run the following code by replacing the filename with your bash script filename. The script will simply get executed after “sourcing” the file.

How do I edit a .sh file in Linux? ›

Using 'vim' to create and edit a file
  1. Log into your server via SSH.
  2. Navigate to the directory location you wish to create the file in or edit an existing file.
  3. Type in vim followed by the name of the file. ...
  4. Press the letter i on your keyboard to enter INSERT mode in vim. ...
  5. Start typing into the file.
13 Oct 2022

Why did Apple switch to zsh? ›

One of the primary reasons why Apple switched to zsh is because it is closer to the functionality of the standard bash. If you are familiar with the standard bash, you will be glad to know that there is an Apple ZSH prompts which looks similar to the one you will find in Microsoft Outlook.

Can I use zsh on Ubuntu? ›

Installing ZSH on Ubuntu

Note: You will need to enter your password for the user after running the command. Step 4: Now that we have set the zsh as our default shell, we have to configure it. So, we will run zsh in the terminal to execute it. This will show the Z shell configuration.

Why should I use zsh over bash? ›

Zsh is more interactive and customizable than Bash. Zsh has floating-point support that Bash does not possess. Hash data structures are supported in Zsh that are not present in Bash. The invocation features in Bash is better when comparing with Zsh.

What is Ash Linux? ›

Almquist shell (also known as A Shell, ash and sh) is a lightweight Unix shell originally written by Kenneth Almquist in the late 1980s. Initially a clone of the System V. 4 variant of the Bourne shell, it replaced the original Bourne shell in the BSD versions of Unix released in the early 1990s.

What are Linux flags? ›

Flags are a way to set options and pass in arguments to the commands you run. Commands you run will change their behavior based on what flags are set. You should read the documentation of each command to know what flags are available.

What is set in bash? ›

set allows you to change the values of shell options and set the positional parameters, or to display the names and values of shell variables.

What is $# $? $@ Etc in Linux shell script? ›

$* Stores all the arguments that were entered on the command line ($1 $2 ...). "$@" Stores all the arguments that were entered on the command line, individually quoted ("$1" "$2" ...). So basically, $# is a number of arguments given when your script was executed. $* is a string containing all arguments.

What is my current shell Linux? ›

Determine the Current Shell in Linux
  1. Overview. A shell is a program that provides a command-line interface to the operating system. ...
  2. Using the echo Command. ...
  3. Using the ps Command. ...
  4. Viewing the /etc/passwd File. ...
  5. Using the lsof Command. ...
  6. Using the readlink Command. ...
  7. Using /proc/$$/cmdline. ...
  8. Other Approaches.
10 Oct 2021

How do I list all shells in Linux? ›

Explanation: The list of all the shells which are currently installed in our Linux system is stored in the 'shells' file which is present in /etc folder of the system. It has read-only access by default and is modified automatically whenever we install a new shell in our system.

How do I run a file in Ubuntu terminal? ›

How to open a RUN file
  1. Open the Ubuntu terminal and move to the folder in which you've saved your RUN file.
  2. Use the command chmod +x yourfilename. run to make your RUN file executable.
  3. Use the command ./yourfilename. run to execute your RUN file.

How do I run a script from command line? ›

At the command prompt, type cscript //d followed by the name of the script, and then press ENTER.

How do I run a script? ›

Click the Start button, and then click Run. In the Open field, type the full path of the script, and then click OK. You can also type WScript followed by the full name and path of the script you want to run.

How do I run a shell script in Linux? ›

Steps to execute a shell script in Linux
  1. Create a new file called demo.sh using a text editor such as nano or vi in Linux: nano demo.sh.
  2. Add the following code: ...
  3. Set the script executable permission by running chmod command in Linux: chmod +x demo.sh.
  4. Execute a shell script in Linux: ./demo.sh.
11 Aug 2022

How do you run a .exe file on Linux? ›

How do I run .exe files on Linux? Navigate to the directory with the file, then open the file with Wine. In the terminal, navigate to the directory containing the file with the command cd <directory name> . Then, run the file with the command wine <filename>.exe .

How do I run a text file in Linux terminal? ›

Right click on the text file, select properties, select permission, mark the "Let this file be executed" text box. Now you can execute it just by double clicking on the file. You can also do it from the console like this: sh ec2-env-setup.

How do I run a file in Terminal? ›

VS Code tips — The Run active file in terminal command - YouTube

How do I run a bash script? ›

Make a Bash Script Executable
  1. 1) Create a new text file with a . sh extension. ...
  2. 2) Add #!/bin/bash to the top of it. This is necessary for the “make it executable” part.
  3. 3) Add lines that you'd normally type at the command line. ...
  4. 4) At the command line, run chmod u+x YourScriptFileName.sh. ...
  5. 5) Run it whenever you need!

How do I run a bash script in terminal? ›

This method is quite easy to run a bash script, and all of them are quite simple. We just need to type in “source” before the file/script name with an extension. In a terminal, run the following code by replacing the filename with your bash script filename. The script will simply get executed after “sourcing” the file.

What is an .sh file? ›

A shell script or sh-file is something between a single command and a (not necessarily) small programm. The basic idea is to chain a few shell commands together in a file for ease of use. So whenever you tell the shell to execute that file, it will execute all the specified commands in order.

How do I start a shell script? ›

Steps to write and execute a script
  1. Open the terminal. Go to the directory where you want to create your script.
  2. Create a file with . sh extension.
  3. Write the script in the file using an editor.
  4. Make the script executable with command chmod +x <fileName>.
  5. Run the script using ./<fileName>.

What is $# $? $@ Etc in Linux shell script? ›

$* Stores all the arguments that were entered on the command line ($1 $2 ...). "$@" Stores all the arguments that were entered on the command line, individually quoted ("$1" "$2" ...). So basically, $# is a number of arguments given when your script was executed. $* is a string containing all arguments.

How install install sh Ubuntu? ›

About This Article
  1. Download and extract the package.
  2. Open a terminal window.
  3. Go to the folder that contains the "install.sh" file.
  4. Use "chmod +x" to make "install.sh" executable.
  5. Type "bash install.sh" and press Enter.
  6. Enter the root password and follow the on-screen instructions.
7 Sept 2020

Is shell script a programming language? ›

A shell script is a computer program designed to be run by the Unix shell, a command-line interpreter. The various dialects of shell scripts are considered to be scripting languages. Typical operations performed by shell scripts include file manipulation, program execution, and printing text.

Videos

1. Unicorn steps on Fairy! Wear a Helmet!, The Pony Show, Gypsy Vanner horses
(The Pony Show)
2. LPIC 1 - Linux System Administrator Complete Course - NetShark
(NetShark)
3. Administration du pare-feu sous linux avec IPTABLES
(Linux Lovers)
4. What are bash shell builtin commands? | Linux Tutorial for Beginners
(FactorPad)
5. Linux : Rappels Scripts et voyons comment compiler un script bash !
(Adrien Linuxtricks)
6. Asterisk VOIP Server Setup On Ubuntu 20 | Making Calls via SIP Soft Phone | Rocket System
(Rocket Systems)
Top Articles
Latest Posts
Article information

Author: Gregorio Kreiger

Last Updated: 12/26/2022

Views: 5996

Rating: 4.7 / 5 (57 voted)

Reviews: 88% of readers found this page helpful

Author information

Name: Gregorio Kreiger

Birthday: 1994-12-18

Address: 89212 Tracey Ramp, Sunside, MT 08453-0951

Phone: +9014805370218

Job: Customer Designer

Hobby: Mountain biking, Orienteering, Hiking, Sewing, Backpacking, Mushroom hunting, Backpacking

Introduction: My name is Gregorio Kreiger, I am a tender, brainy, enthusiastic, combative, agreeable, gentle, gentle person who loves writing and wants to share my knowledge and understanding with you.