Notions de base la programmation de Shell
Il s'agit d'un simple aperçu des bases la programmation du shell Bourne. Le shell Bourne a été développé par Stephen Bourne chez Bell Labs et publié officiellement en 1977.
Le système d'exploitation Solaris (les versions 9 et 10) dispose d'un shell POSIX situé dans le répertoire: /usr/xpg4/bin/sh. Le shell par défaut ne prend pas en charge la norme POSIX.
De nombreux systèmes d'exploitation open source seront utiliser «Almquist shell» (ash), et les distributions de Debian Linux utilisent une variante appelée «Debian Almquist Shell» (dash). Cela inclut les distributions Ubuntu et Mint. Le shell Almquist devrait être conforme aux spécifications POSIX.
Autres distributions Linux peuvent utiliser un autre plus robuste appelé «Bourne Again Shell» (bash). Cela peut supporter la plupart des fonctionnalités de «POSIX Shell». Il ya aussi le «Korn Shell» (ksh) qui prend en charge POSIX et est plus robuste.
Sortie
Voici comment on peut sortir du texte à l'écran, ou en informatique STDOUT (sortie standard).
#!/bin/sh echo "Hello"
Variables
En informatique, les variables sont un nom symbolique associé à une valeur et dont la valeur associée peut être changé. En Bourne Shell, il n'y a pas de type de donnée pour les variable.
#!/bin/sh num=5 char=a string="This is a string" echo Number is $num echo Character is $char echo String is $string
Constantes
En la programmation, une constante est une valeur qui ne peut pas être modifiée pendant l'exécution d'un programme.
#!/bin/sh readonly PI=3.1415926 echo $PI
Arithmétique
Le shell POSIX supporte les opérations arithmétiques avec des nombres entiers: $(( expression mathématique ))
#!/bin/sh # integer arithmatic width=5; length=6 area=$(($length * $width)) echo "The area of a square (width=$width, length=$length) is $area" # boolean logic true=1; false=0 result=$(($true && $false || $true)) echo "The statement (true AND false OR true) is $result"
Pour l'arithmétique à virgule flottante, utilisez la commande bc.
#!/bin/sh readonly PI=3.1415927 # La valeur approximative de π radius=3 area=$(echo "$PI * $radius ^ 2" | bc) echo $area
Le résultat avec GNU bc (à partir de Cygwin 1.7.15 sur Windows NT 6.1) est: 28,2743343
Certaines fonctions mathématiques sont pris en charge par l'outil awk:
Certaines fonctions mathématiques sont pris en charge par l'outil awk:
#!/bin/sh readonly PI=3.1415927 # La valeur approximative de π echo the cosine of pi / 4 is: $(awk "BEGIN {print cos($PI/4)}")
La précision avec awk est de 6 chiffres, donc la réponse est 0,707107.
Tests
Le «test» commande est une external commande qui teste un nombre, une chaîne ou un fichier et de sortir avec 0 pour un succès ou un 1 pour un échec.
Notez que le shell POSIX et le shell Bourne n'ont pas de mécanisme interne pour évaluer ce type d'expression. Ainsi, il utilisera la commande externe «test» ou la commande externe «[».
Notez que le shell POSIX et le shell Bourne n'ont pas de mécanisme interne pour évaluer ce type d'expression. Ainsi, il utilisera la commande externe «test» ou la commande externe «[».
#!/bin/sh string1="wow" ; string2="wow" num1=15 ; num2=15 file1=/etc/passwd # test a string using test test "$string1" = "$string2" && echo Both strings are the same. # test a string using [˽...˽] [ "$string1" = "$string2" ] && echo Both strings are the same. # test a file [ -f $file1 ] && echo $file1 is a file # test an integer equality [ $num1 -eq $num2 ] && echo Both numbers are the same. # test with reverse logic [ ! $num1 -ne $num2 ] && echo Both numbers are not not equal. # test with boolean AND condition [ $num1 -gt 10 -a $num1 -lt 100 ] && echo num1 is between 10 and 100 # test with boolean OR condition [ $num1 -gt 10 -o $num2 -lt 10 ] && echo num1 and num2 are greater than 10
Entrée
C'est la façon d'obtenir la saisie au clavier, ou en informatique STDIN (entrée standard).
#!/bin/sh echo -n "Enter your name: " # print prompt read name # acquire input echo Hello $name # output result using variable
Choix
La branche est un point où un flux logiciel est modifié. Essentiellement, le logiciel choisit un chemin après l'évaluation d'un test.
Voici une section simple qui utilise «test» pour évaluer un certain nombre:
Voici une section simple qui utilise «test» pour évaluer un certain nombre:
#!/bin/sh echo -n "Input a number: "; read Number if [ $Number -gt 0 ]; then echo Number is greater than 0 elif [ $Number -lt 0 ]; then echo Number is less than 0 else echo Number is 0 fi
La construction de «case» permettra de comparer une chaîne à un motif. Si le motif trouve une correspondance, un bloc de code est exécuté.
Pour «case», l'environnement du shell gère les modèles appelés un modèle «glob». Cet modèle «glob» est une syntaxe qui représente par un ensemble de chaînes.
Pour «case», l'environnement du shell gère les modèles appelés un modèle «glob». Cet modèle «glob» est une syntaxe qui représente par un ensemble de chaînes.
#!/bin/sh echo -n "Input a character: " ; read Keypress # case construction case "$Keypress" in [[:lower:]] ) echo "Lowercase letter";; [[:upper:]] ) echo "Uppercase letter";; [[:digit:]] ) echo "Digit";; * ) echo "Punctuation, whitespace, or other";; esac
En utilisant la construction de «if», le test pour le motif de «case» peut être créé en utilisant cette méthode:
#!/bin/sh echo -n "Input a character: " ; read Keypress # if construction if [ -z $(echo $Keypress | tr -d "[:lower:]") ]; then echo "Lowercase letter" elif [ -z $(echo $Keypress | tr -d "[:upper:]") ]; then echo "Uppercase letter" elif [ -z $(echo $Keypress | tr -d "[:digit:]") ]; then echo "Digit" else echo "Punctuation, whitepace, or other" fi
Boucles
Une boucle est une séquence d'instructions qui est spécifié une fois mais qui peut être réalisée plusieurs fois de suite.
Il y a une boucle commandée par un compter. Cette boucle compte de 10 à 1.
Il y a une boucle commandée par un compter. Cette boucle compte de 10 à 1.
#!/bin/sh # while construction count=10 while [ $count -gt 0 ]; do echo "\$count is $count" count=$(( $count - 1 )) done
Il y a une boucle commandée par un état. L'utilisateur de déterminer l'état. Lorsque l'utilisateur tape "quit" la boucle se termine.
#!/bin/sh #until construction until [ "$answer" = "quit" ]; do echo -n "Enter your name (quit to exit) " read answer if [ $answer != "quit" ] ; then echo Hello $answer fi done
Il y a une boucle commandée par un ensemble d'éléments (collection). Cet exemple exécute un sous-shell pour exécuter une commande. La sortie de cette sous-shell sera divisé en éléments. Ces éléments peuvent alors être traitées dans chaque itération de la boucle.
#!/bin/sh #for...in construction for item in $(ls); do if [ -d $item ]; then echo "$item is a directory" else echo "$item is not a directory" fi done
Tableaux
Le shell Bourne ne prend pas en charge les tableaux. Cette fonctionnalité peut être émulé avec chaînes séparées par des espaces.
#!/bin/sh # created populated list using space-delimited string nicknames="bob ed steve ralph joe deb kate" # print length of list total=$(echo $nicknames | wc -w) echo "Total nicknames is (using wc): $total" # iterate through string with for/in/do..done construction echo "The names are: " for name in $nicknames; do echo " $name" done
#!/bin/sh # created populated list using space-delimited string nicknames="bob ed steve ralph joe deb kate" # print length of list total=$(echo $nicknames | awk '{ print NF }') echo "Total nicknames is (using awk): $total" # iterate through string with for/in/do..done construction echo "The names are: " for name in $nicknames; do echo " $name" done
Tableaux associatifs
Le shell Bourne ne prend pas en charge les tableaux associatif.
Fonction
Une fonction est une portion de code représentant un sous-programme qui effectue une tâche et qui renvoie une valeur. Dans l'environnement du shell, la fonction n'a pas vraiment retourner une valeur. Au lieu de cela, elle renvoie un code de sortie, qui est lu par le variable $?.
#!/bin/sh # create function show_date() { year=$(date +%Y) mon=$(date +%b) day=$(date +%d) echo "Today is $mon $day, $year" } # call the function show_date
Arguments (Paramètres positionnels)
Un système d'exploitation prend en charge la fonctionnalité pour envoyer des paramètres (appelés options ou «flags») à un programme. Ils sont également appelés arguments de la ligne de commande. L'environnement du shell utilise les paramètres positionnels pour traiter ces arguments en ligne de commande.
Un paramètre de position est représentée par une variable ordinale particulière comme $1, $2, $3, et ainsi de suite. Le nombre maximum d'arguments envoyés au script est représenté par $#. Le script lui-même est appelé $0.
Un paramètre de position est représentée par une variable ordinale particulière comme $1, $2, $3, et ainsi de suite. Le nombre maximum d'arguments envoyés au script est représenté par $#. Le script lui-même est appelé $0.
#!/bin/sh # test if user entered 2 values if [ $# -lt 2 ]; then # print message if less than two numbers echo "You need to enter two numbers: \"$0\" num1 num2" else # print summation of both arguments echo "The sum of $1 and $2 is: $(($1 + $2))" fi
Voici une méthode pour lister les arguments. La commande «shift» est utilisée pour changer la position des paramètres. Lorsque «shift» est utilisé, tous les paramètres seront décalées vers le haut. Ainsi, «$3» deviendra «$2», «$2» deviendra «$1» et «$1» sera effacé. Comme cela se produit, la variable «$#» décrémente.
#!/bin/sh count=1 # initialize counter echo "The arugments passed are:" while [ $# -ge 1 ]; do echo " item $count: $1" # output result count=$(( $count + 1 )) # increment counter shift done
Dans une autre méthode pour lister les arguments, nous pouvons utiliser explicitement un certain nombre. Pour cela, il faudra utiliser la commande «eval».
#!/bin/sh count=$# # initialize counter echo "The arguments passed are (reverse order):" while [ $count -ge 1 ]; do eval param=\$$count # store positional parameter echo " item $count: $param" # output result count=$(( $count - 1 )) # decrement counter done
Paramètres des fonctions
Dans l'environnement du shell, les paramètres positionnels sont utilisés pour contenir les paramètres passés à une fonction. Ils fonctionnent exactement de la même manière que les arguments de ligne de commande.
#!/bin/sh add() { sum=0 for num in "$@"; do sum=$(( $sum + $num )) done echo The summation is: $sum } add 5 2 4 3 6