Script shell Unix avec ksh / bash – Serveur d’impression

Document du cours: (dernière mise à jour le 22 mars 2012)

Ces notes sont disponibles sur http://www.dartmouth.edu/~rc/classes/ksh. La version en ligne contient de nombreux liens vers des informations supplémentaires et peut être plus à jour que les notes imprimées.

Les objectifs de cette classe sont de vous permettre de:

• Découvrez quels types de problèmes conviennent aux scripts shell
• Passez en revue les commandes Unix les plus couramment utilisées et utiles dans les scripts de shell.
• Écrire des scripts shell simples en utilisant les shells Bourne, Korn ou Bash

Ces notes sont destinées à être utilisées dans un cours en deux parties, d’une durée totale de 3 heures.

Hypothèses:
On suppose que vous savez déjà comment:

• connectez-vous et obtenez une fenêtre de ligne de commande (n'importe quel shell)
• exécuter des commandes de base, naviguer dans les répertoires
• utiliser une redirection simple d'E / S et des tubes
• utiliser un éditeur de texte (n'importe lequel)
• recherche des détails sur l'utilisation des commandes dans les pages de manuel

Des exemples de commandes sont affichés comme ça. Beaucoup de commandes
sont affichés avec des liens vers leurs pages de manuel complètes
(sh)
La sortie des commandes est affichée comme ça;
les éléments optionnels sont [ in brackets ].

Certaines descriptions dans ces notes ont plus de détails disponibles,
et sont notés comme ceci:

Plus de détails sur cet article apparaissent ici. Les notes imprimées
inclure toutes les informations supplémentaires

La permission est donnée de télécharger et d’utiliser ces notes et exemples de scripts, à condition que
tous les avis de droits d'auteur sont conservés intacts. Certains exemples sont tirés de textes
ou des ressources en ligne qui ont autorisé la redistribution.

Ces notes sont mises à jour de temps en temps. Le développement"
ensemble de notes sont
 http://northstar-www.dartmouth.edu/~richard/classes/ksh
(Dartmouth seulement)

Richard Brittain, Services informatiques du Dartmouth College.

© 2003,2004,2010 Dartmouth College.

Commentaires et questions, contactez Richard.Brittain @ dartmouth.edu

Table des matières

(1)

• Un fichier texte contenant des commandes qui auraient pu être saisies directement dans le shell.
  

  Il n'y a pas de différence de syntaxe entre l'utilisation interactive de la ligne de commande et le placement des commandes
  dans un fichier. Certaines commandes ne sont utiles que lorsqu'elles sont utilisées de manière interactive (par exemple, rappel de l'historique en ligne de commande).
  et les autres commandes sont trop complexes pour pouvoir être utilisées de manière interactive.
  

• Le shell lui-même a des capacités limitées – le pouvoir provient de son utilisation comme "colle"
  langue pour combiner les utilitaires Unix standard et un logiciel personnalisé, pour produire un outil
  plus utile que les composants seuls.
• Tout shell peut être utilisé pour écrire un script shell. Pour permettre cela, la première ligne de chaque script
  est:
  #! / chemin / vers / shell (par exemple. #! / bin / ksh).

  le #! les caractères indiquent au système de localiser le chemin suivant, de le démarrer et de
  alimentez le reste du fichier en entrée.
  Tout programme capable de lire les commandes d’un fichier peut être démarré de cette manière, à condition que
  reconnaît le # convention de commentaires. Le programme est lancé, puis le fichier de script
  est donné comme argument. Pour cette raison, le script doit être lisible et exécutable.
  Les exemples sont perl, awk, tcl et python.
  

• Tout fichier peut être utilisé comme entrée dans un shell en utilisant la syntaxe suivante:
  ksh myscript
• Si le fichier est rendu exécutable avec chmod, cela devient une nouvelle commande
  et disponible pour utilisation (sujet à la recherche habituelle de $ PATH).
  chmod + x myscript

Un script shell peut être aussi simple qu'une séquence de commandes que vous tapez régulièrement. En mettant
les dans un script, vous les réduisez à une seule commande.

Exemple: ex0 affichage, texte

            1: #! / bin / sh
            2: rendez-vous amoureux
   3: pwd
            4: du -k

(2)

• Combinez des séquences de commandes longues et répétitives en une seule commande simple.
• Généraliser une séquence d'opérations sur un ensemble de données, en une procédure pouvant être
  appliqué à tout ensemble similaire de données.

  (par exemple.
  appliquer la même analyse à chaque fichier de données sur un CD, sans avoir à répéter les commandes)
  

• Créer de nouvelles commandes en utilisant des combinaisons d’utilitaires comme les auteurs originaux
  jamais pensé à.
• Des scripts shell simples peuvent être écrits sous la forme d'alias shell, mais le script peut être mis à la disposition de tous les utilisateurs.
  et tous les processus. Les alias de shell s'appliquent uniquement au shell actuel.
• Enveloppez les programmes sur lesquels vous n'avez aucun contrôle dans un environnement que vous pouvez contrôler.
  

  par exemple. définir des variables d'environnement, basculer vers un répertoire spécial, créer ou sélectionner un fichier de configuration,
  redirigez la sortie, enregistrez l’utilisation, puis exécutez le programme.
  

• Créez des jeux de données personnalisés à la volée et appelez des applications (par exemple, matlab, sas, idl, gnuplot) pour fonctionner
  sur eux, ou créer des commandes / procédures d’application personnalisées.
• Prototypage rapide (mais évitez de laisser les prototypes devenir production)

Utilisations typiques

• Scripts de démarrage du système (/etc/init.d)
• Administrateurs système, pour automatiser de nombreux aspects de la maintenance informatique, compte utilisateur
  création etc.
• Outils d'installation du package d'application
  

  D'autres outils peuvent créer des installateurs plus sophistiqués (par exemple, tcl / tk), mais ne peuvent pas être considérés comme déjà installés. Les scripts shell sont utilisés car ils sont très portables. Certains logiciels sont livrés avec une installation complète de l'outil qu'il veut utiliser
  (tcl / tk / python) pour être autonome, mais cela conduit à un gonflement logiciel.
  

• Scripts de démarrage d'application, en particulier
  applications sans surveillance (par exemple, à partir de cron ou à)
• Tout utilisateur ayant besoin d'automatiser le processus de configuration et d'exécution d'applications commerciales,
  ou leur propre code.

AUTOMATISER, AUTOMATISER, AUTOMATISER

(3)

sh

"Bourne", écrit par Steve Bourne chez AT & T Bell Labs pour Unix V7 (1979).
Petit, simple et (à l'origine) très peu de commandes internes, donc il a appelé des programmes externes pour même le plus simple
des tâches. Il est toujours disponible sur tout ce qui ressemble vaguement à Unix.

csh

La coquille "C". (Bill Joy, à Berkeley).
Beaucoup de choses en commun
avec le shell Bourne, mais de nombreuses améliorations pour améliorer l’utilisation interactive. L'interne
les commandes utilisées uniquement dans les scripts sont très différent de "sh", et
similaire (par conception) à la syntaxe du langage "C".

tcsh

Le shell "TC". Librement disponible et basé sur "csh".
Il comporte de nombreuses fonctionnalités supplémentaires pour rendre l'utilisation interactive plus pratique.

Nous l'utilisons comme shell interactif par défaut pour les nouveaux comptes sur tous nos systèmes publics.

Peu de gens écrivent des scripts dans
Voir la programmation de Csh considérée comme nuisible par
Tom Christiansen pour une discussion sur les problèmes de programmation des scripts csh.

ksh

Le "Korn" shell, écrit par David Korn de AT & T Bell Labs (maintenant AT & T Research).
Écrit comme une mise à niveau majeure vers "sh" et une compatibilité ascendante avec celui-ci, mais possède de nombreuses commandes internes pour le
fonctions les plus fréquemment utilisées. Il intègre également de nombreuses fonctionnalités de tcsh qui améliorent
utilisation interactive (rappel de l'historique de ligne de commande, etc.).

L’acceptation a été lente, car les versions précédentes étaient grevées de licences AT & T.
Ce shell est maintenant disponible gratuitement sur tous les systèmes, mais n'est parfois pas installé par défaut sur Unix "libre".
Il existe deux versions principales. ksh88 était la version intégrée à AT & T SVR4 Unix, et peut encore être installé
par certains des vendeurs Unix commerciaux. ksh93 a ajouté plus de fonctionnalités, principalement pour la programmation, et une meilleure conformité POSIX.

POSIX 1003.2 Standard Shell.

Les comités de normalisation ont travaillé sur le shell Bourne et ont ajouté de nombreuses fonctionnalités au shell Korn (ksh88).
C shell pour définir un ensemble standard de fonctionnalités que doivent posséder tous les shells conformes.

Sur la plupart des systèmes, / bin / sh est maintenant un shell compatible POSIX.
Korn shell et Bash sont compatibles POSIX, mais possèdent de nombreuses fonctionnalités qui vont au-delà de la norme.
Sous Solaris, les commandes POSIX / XPG4 qui diffèrent
légèrement dans le comportement des commandes SunOS traditionnelles se trouvent dans / usr / xpg4 / bin

frapper

La coquille "Bourne again". Ecrit dans le cadre de l’effort Open Source GNU / Linux et du shell par défaut pour Linux et
Mac OS X. C'est un clone fonctionnel de sh, avec des fonctionnalités supplémentaires pour améliorer l'utilisation interactive,
ajouter la conformité POSIX et la compatibilité partielle de ksh.

zsh

Un clone fonctionnel gratuit de sh, avec des éléments de ksh, bash et une conformité POSIX complète, et
nombreuses nouvelles fonctionnalités d'édition en ligne de commande interactives.
Il a été installé en tant que shell par défaut sur les anciens systèmes MacOSX.

(4)

Tous les shells énumérés ci-dessus partagent certaines caractéristiques communes et les différences majeures de syntaxe.
généralement, n'affectent que les scénaristes. Ce n'est pas inhabituel
utiliser un shell (par exemple, tcsh) pour une utilisation interactive, mais un autre (sh ou ksh)
pour écrire des scripts.

Principales similitudes (et récapitulation de l'utilisation de base de la ligne de commande)

Chacun de ces éléments est traité plus en détail ultérieurement.

• Analyser les lignes par des espaces, rechercher des commandes externes à l'aide de $ PATH.
• Peut exécuter un script shell en utilisant shellname scriptfile, ou exécuter un seul
      commande en utilisant shellname -c "commande"
• Transmettez les arguments de ligne de commande développés aux programmes; récupérer le statut de sortie.
• Passer des variables d'environnement aux programmes.
• Développez les jokers de nom de fichier en utilisant []*?. Chaque coquille a quelques autres
  métacaractères génériques, mais ceux-ci sont communs à tous les shells.
• Redirection I / O standard et tuyauterie avec <,>, >>, |
• Quelques fonctions internes (CD)
• Commandes d'arrière-plan avec Et
• Règles de cotation: les "guillemets" protègent la plupart des choses, mais permettent $ var interprétation;
  Les "guillemets simples" protègent tous les métacaractères de l'interprétation.
• Extension du répertoire personnel à l'aide de ~ utilisateur (à l'exception de sh)
• # commentaires
• Substitution de commande en utilisant `commande` (backtics)
• Développez les variables en utilisant $ varname syntaxe
• Exécution conditionnelle utilisant && et ||
• Suite de ligne avec ""

Principales différences

entre sh (+ dérivés) et csh (+ dérivés).

• Syntaxe de toutes les constructions de contrôle de flux et des tests conditionnels.
• Syntaxe de manipulation des chaînes dans les scripts
• Syntaxe pour la manipulation arithmétique à l'intérieur des scripts
• Syntaxe de définition des variables locales (utilisées uniquement dans le script) et des variables d’environnement
  passé aux processus enfants). setenv contre exportation
• Syntaxe de redirection des flux d'E / S autres que stdin / stdout
• Fichiers de démarrage de connexion (.cshrc et .s'identifier, contre .profil) et les options par défaut
• Lecture d’autres scripts shell dans le shell actuel (nom de fichier source, contre . nom de fichier)
• Traitement des signaux (interruptions)

(5)

Il existe de nombreux autres programmes qui lisent un fichier de commandes et exécutent
une séquence d'actions. le "#! / chemin / à / programme" convention
permet à n'importe lequel d'entre eux d'être utilisé comme langage de script pour créer de nouvelles commandes.
Certains sont hautement spécialisés, et certains sont beaucoup plus efficaces que leurs équivalents
scripts shell à certaines tâches. Il n'y a jamais qu'un seul moyen d'effectuer une fonction,
et souvent, le choix dépend de facteurs tels que:

• ce qui est déjà installé – beaucoup d'autres langages de script ne sont pas disponibles par défaut
• quel code similaire existe déjà
• ce que vous connaissez et pouvez utiliser de la manière la plus efficace.
  Votre temps est toujours plus coûteux que les cycles informatiques.

Certains des principaux acteurs (tous disponibles gratuitement) dans les langages de script à usage général sont:

• awk
  

  Un outil de correspondance de modèle et de manipulation de données (texte et numérique). Prédate perl. Installé sur
  tous les systèmes Unix. Souvent utilisé en combinaison avec des scripts shell.
  

• perl
  

  Le langage de script le plus utilisé pour les applications Web CGI et les tâches d'administration système. Perl
  est plus difficile à apprendre et est généralement installé par défaut maintenant.
  Il est plus efficace et dispose d’une énorme bibliothèque de fonctions. Vous pouvez utiliser Perl pour
  presque toutes les tâches de script, mais la syntaxe est très différente de la ligne de commande du shell
  

• python
  

  Un langage de script orienté objet. Communément installé par défaut sur les systèmes modernes.
  

• tcl/tk
  

  Langage de commande de l'outil. Un autre langage de script à usage général. Le composant "tk" est un
  interface scriptée vers les composants graphiques X-windows standard, la combinaison est donc souvent utilisée
  créer des interfaces utilisateur graphiques.
  

  Ksh93 peut être étendu en se connectant à des bibliothèques partagées fournissant des commandes internes supplémentaires. Un exemple
  d'une coquille étendue est
  tksh

  qui intègre Tcl / Tk avec ksh et permet la génération de
  scripts utilisant les deux langues. Il peut être utilisé pour le prototypage d'applications d'interface graphique.

(6)

Ksh et bash sont les deux super-ensembles de sh. Pour une portabilité maximale, même très ancienne
ordinateurs, vous devriez vous en tenir aux commandes trouvées dans sh. Si possible, fonctionnalités spécifiques à ksh ou bash
sera noté dans les pages suivantes. En général, les nouveaux obus courent un peu plus vite
et les scripts sont souvent plus lisibles, car la logique peut être exprimée plus proprement au plus récent
syntaxe. De nombreuses commandes et tests conditionnels sont maintenant internes.

La philosophie des outils Unix séparés effectuant chacun un seul
opération a été suivie de près par les concepteurs de la coque d'origine, de sorte qu'il
avait très peu de commandes internes et
utilisé des outils externes pour des opérations très triviales
(comme écho et [[[[). Ksh et bash en interne
effectue un grand nombre de manipulations numériques et de chaînes de base et de tests conditionnels. Problèmes occasionnels
se pose parce que les versions internes de certaines commandes comme écho ne sont pas entièrement compatibles avec
l'utilitaire externe ils ont remplacé.

L'action entreprise chaque fois qu'un shell doit exécuter un programme externe consiste à localiser le programme.
(via $ PATH), fourchette(), qui crée une deuxième copie du shell,
ajustez l'entrée / sortie standard pour le
programme externe, et exec (), qui remplace le second shell par le programme externe.
Ce processus est onéreux en termes de calcul (relativement), donc lorsque le script fait quelque chose de trivial
plusieurs fois dans une boucle, cela fait gagner beaucoup de temps si la fonction est gérée en interne.

Si vous suivez des manuels sur la programmation du shell Bourne, tous les conseils doivent être valables
lequel des coquillages dérivés de Bourne que vous utilisez. Malheureusement, de nombreux fournisseurs ont ajouté des fonctionnalités au fil des ans
et atteindre la portabilité complète peut être un défi. Écrire explicitement pour ksh (ou bash) et insister
sur ce shell en cours d'installation, peut souvent être plus simple.

Le sh et le ksh homme les pages utilisent le terme commande spéciale pour les commandes internes – gérées par le shell
lui-même.

(7)

Le script shell le plus élémentaire est une liste de commandes exactement telles qu’elles pourraient être.
dactylographié de manière interactive, préfacé par le #! en-tête magique.
Toutes les règles d'analyse, les caractères génériques de nom de fichier, les recherches $ PATH, etc., qui ont été résumés
ci-dessus, appliquer.

En outre:

# en tant que premier caractère non blanc sur une ligne

marque la ligne en tant que commentaire et le reste de la ligne est complètement ignoré. Utilisation
commente librement dans vos scripts, comme dans toutes les autres formes de programmation.

comme dernier caractère d'une ligne

provoque la jointure logique de la ligne suivante avant interprétation. Ceci permet
commandes très longues à saisir dans le script de manière plus lisible. Tu peux continuer
la ligne autant de fois que nécessaire.

Ceci est en fait juste un cas particulier de Être à échapperou supprimer
la signification spéciale de, le caractère suivant.

; comme séparateur entre les mots d'une ligne

est interprété comme une nouvelle ligne. Il vous permet de placer plusieurs commandes sur une seule ligne. Il y a
quelques occasions où vous doit faire cela, mais souvent il est utilisé pour améliorer la mise en page
des commandes composées.

Exemple: affichage ex1, texte

            1: #! / bin / ksh
            2: # Aux fins d’affichage, certaines parties du script ont 
            3: # été rendu en technicolor glorieux.
            4: ## Certains commentaires sont en gras pour signaler les sections spéciales
            5: 
            6: # Les numéros de ligne à gauche ne font pas partie du script.
            7: # Ils sont simplement ajoutés au HTML pour référence.
            8: 
            9: # Les commandes intégrées et les mots-clés (par exemple, print) sont en bleu
        dix: # Les substitutions de commandes sont violettes. Les variables sont noires
        11: impression "Résumé de l'utilisation du disque pour $ USER sur `rendez-vous amoureux`"
  12: 
        13: # Tout le reste est rouge - ce qui est principalement externe 
        14: # commandes et les arguments de toutes les commandes.
        15: impression Ce sont mes fichiers       # commentaire de fin de ligne pour impression
        16: # Liste les fichiers en colonnes
        17: ls -C
  18: # Résumer l'utilisation du disque
        19: impression
        20: impression Utilisation de l'espace disque
  21: du -k 
  22: sortie 0

Statut de sortie

Chaque commande (programme) a un valeur ou statut de sortie
qu'il retourne au programme appelant. Ce
est séparé de toute sortie générée. Le statut de sortie d'un script shell peut être défini explicitement à l'aide de
sortie Nou la valeur par défaut de la dernière commande exécutée.

Le statut de sortie est un entier compris entre 0 et 255. Conventionnellement 0 = succès et
toute autre valeur indique un problème. Pensez-y comme à un seul moyen pour que tout
travailler, mais de nombreuses façons d’échouer. Si la commande s'est terminée par un signal, la valeur est 128 plus
la valeur du signal.

(8)

Le shell interprète les caractères suivants comme des caractères génériques de nom de fichier, et
tout mot les contenant est remplacé par une liste triée de tous les fichiers correspondants.

Les caractères génériques peuvent être utilisés dans les parties de répertoire d'un chemin ainsi que dans la partie de nom de fichier.
Si aucun fichier ne correspond au caractère générique, celui-ci reste inchangé.
Les caractères génériques ne sont pas des expressions régulières complètes. Sed, grep, awk etc. fonctionnent avec plus de souplesse (et plus
complexes) opérateurs de correspondance de chaînes.

*

Correspond à zéro ou plusieurs caractères.

?

Correspondre à n'importe quel personnage

[...]

Faites correspondre n'importe quel caractère de l'ensemble entre crochets. Une plage de caractères peut être spécifiée
avec [ - ]

[!...]

Associez n'importe quel caractère non inclus dans l'ensemble entre crochets.

• Une initiale "." dans un nom de fichier ne correspond pas à un caractère générique, sauf si explicitement
  donné dans le motif. En ce sens, les noms de fichiers commençant par "." sont cachés.
  UNE "." ailleurs dans le nom de fichier n'est pas spécial.
• Les opérateurs de modèle peuvent être combinés

Exemple:
chapitre[1-5]. * pourrait correspondre chapitre1.tex, chapitre4.tex, chapitre5.tex.old.
Cela ne correspond pas chapitre10.tex ou chapitre 1

(9)

Les scripts ne sont pas très utiles si toutes les commandes, options et noms de fichiers sont explicitement
codé. En utilisant des variables, vous pouvez créer un script générique et l’appliquer à différents
des situations. Les noms de variables sont composés de lettres, de chiffres et de traits de soulignement
 ([a-zA-Z0-9_], ne peut pas commencer par un nombre, et sont des cas
sensible. Plusieurs variables spéciales (toujours des noms en majuscule) sont utilisées par le système – en les réinitialisant.
peut provoquer un comportement inattendu. Certaines variables spéciales peuvent être en lecture seule.
L'utilisation de noms minuscules pour vos propres variables est la plus sûre.

Définition et exportation de variables

srcfile = dataset1

Crée (si elle n’existait pas) une variable nommée "srcfile" et lui attribue la valeur "dataset1". Si la
La variable existait déjà, elle est écrasée. Les variables sont traitées comme des chaînes de texte, sauf si le contexte
implique une interprétation numérique. Vous pouvez faire en sorte qu'une variable soit toujours traitée comme un nombre. Notez ici
doit être sans espaces autour du "=".

ensemble

Afficher toutes les variables actuellement définies dans le shell

non fixé srcfile

Supprimer la variable "srcfile"

srcfile =

Donnez à la variable une valeur nulle (ce n'est pas la même chose que de la supprimer).

exportation srcfile

Ajout de srcfile à la liste des variables qui seront mises à la disposition du programme externe via
l'environnement. Si vous ne le faites pas, la variable est locale pour cette instance de shell.

exportation

Répertorie toutes les variables en cours d’exportation – c’est l’environnement qui sera transmis.
aux programmes externes.

En utilisant des variables

$ srcfile

Préfacer le nom de la variable avec $ provoque la valeur de la variable à
être substitué à la place du nom.

$ srcfile

Si la variable n'est pas entourée d'espaces (ou d'autres caractères qui ne peuvent pas être dans un nom),
le nom doit être entouré d'accolades ""
afin que le shell sache quels caractères vous voulez faire partie du nom.

Exemple:

fichier de données = recensement2000
# Essaie de trouver $ datafile_part1, qui n'existe pas
echo $ datafile_part1.sas
# C'est ce que nous voulions
echo $ datafile _part1.sas  

Modificateurs conditionnels

Il existe différentes manières d’utiliser conditionnellement une variable dans une commande.

$ datafile-default

Substituez la valeur de $ fichier de données, s’il a été défini, sinon utilisez la chaîne "default". C'est facile
moyen de permettre des variables optionnelles, et avoir des valeurs par défaut raisonnables si elles n’ont pas été définies. Si fichier de données était
indéfini, il en reste ainsi.

$ datafile = default

Similaire à ce qui précède, sauf si fichier de données n'a pas été défini, définissez-le sur la chaîne "default".

$ datafile + default

Si variable fichier de données a été défini, utilisez la chaîne "default", sinon utilisez null. Dans ce cas, le
valeur actuelle $ fichier de données N'est pas utilisé.

$ datafile? "message d'erreur"

Substituez la valeur de $ fichier de données, s'il a été défini, sinon affichez datafile: message d'erreur.
Ceci est utilisé pour les diagnostics lorsqu'une variable aurait dû être définie et qu'il n'y a pas de valeur par défaut raisonnable à utiliser.

Placer un colon (:) avant que le caractère opérateur dans ces constructions ait pour effet de compter un
nul valeur identique à une variable non définie. Les variables peuvent recevoir une valeur nulle en les définissant
en une chaîne vide, par exemple fichier de données = .

Exemple:
echo $ datafile: -mydata.dat
Écho de la valeur de variable fichier de données s'il a été défini et est non nul, sinon
echo "mydata.dat".

Préfixe de commande d'attribution de variable

Il est possible d’exporter une variable pour la durée d’une seule commande en utilisant le
syntaxe:

var = valeur commande args

(dix)

Le système utilise plusieurs variables spéciales. Vous pouvez les utiliser, mais vous ne pourrez peut-être pas
pour les changer.
Les variables spéciales utilisent des noms en majuscules ou des caractères de ponctuation.
Certaines variables sont définies par le processus de connexion et héritées par le shell (par exemple, $ USER),
tandis que d'autres ne sont utilisés que par le shell.
Essayez de courir ensemble ou env
Voici quelques-uns des plus couramment utilisés:

Environnement de connexion

$ USER, $ LOGNAME

Prédéfini sur le nom d'utilisateur actuellement connecté.

$ PATH

La liste des répertoires qui seront recherchés pour les commandes externes. Vous pouvez changer cela dans un script
pour vous assurer que vous obtenez les programmes que vous avez l'intention, et ne pas obtenir accidentellement d'autres versions qui pourraient avoir été
installée.

$ TERM

Le type de terminal dans lequel la session shell est en cours d'exécution. Habituellement, "xterm" ou "vt100". Beaucoup de programmes
Vous devez savoir cela pour savoir quelles séquences de caractères spéciaux envoyer pour obtenir des effets spéciaux.

$ PAGER

S'il est défini, il contient le nom du programme que l'utilisateur préfère utiliser pour afficher les fichiers texte. habituellement
régler sur "plus" ou "moins" ou quelque chose de similaire. De nombreux programmes devant présenter des informations sur plusieurs pages
l'utilisateur respectera ce paramètre (par exemple, homme). Ce n'est pas réellement utilisé par le shell lui-même, mais
Les scripts shell doivent l’honorer s’ils doivent émettre une page vers l’utilisateur.

$ EDITEUR

Si défini, ceci contient le nom du programme que l'utilisateur préfère utiliser pour l'édition de fichier texte. Un programme
qui doit obliger l’utilisateur à éditer manuellement un fichier peut choisir de démarrer ce programme au lieu de
par défaut intégré (par exemple "crontab -e". Ceci détermine également la modification de la ligne de commande par défaut.
comportement dans des coquilles interactives.

Paramètres internes du shell

$ PWD

Toujours définir le répertoire de travail actuel (en lecture seule)

$ OLDPWD

Le répertoire précédent (avant le plus récent CD commander). Cependant, changer de répertoire
dans un script est souvent dangereux.

$? (lecture seulement)

Définissez le statut de sortie de la dernière commande exécutée afin de pouvoir tester le succès ou l'échec. Chaque commande réinitialise cette
il faut donc le sauvegarder immédiatement si vous voulez l’utiliser plus tard.

$ -

Définissez les options actuellement définies.

$ IFS

Séparateurs de champs internes: ensemble de caractères (normalement des espaces et des tabulations) utilisés pour analyser
une ligne de commande en arguments séparés. Ceci peut être défini par l'utilisateur à des fins spéciales, mais
les choses deviennent très déroutantes si rien n'est changé.

Variables d'ID de processus

$$ (lecture seulement)

Défini sur l'ID de processus du shell actuel – utile pour créer des fichiers temporaires uniques, par exemple. /tmp/$0.$$

$ PPID (lecture seulement)

Défini sur l'ID de processus du processus parent de ce shell – utile pour découvrir comment le script a été appelé.

$! (lecture seulement)

Défini sur l'ID de processus de la dernière commande démarrée en arrière-plan – utile pour vérifier les processus en arrière-plan.

ksh / bash fonctionnalités supplémentaires

$ SECONDES (lecture seulement)

Nombre entier de secondes depuis le démarrage de ce shell. Peut être utilisé pour les commandes de chronométrage.

$ RANDOM

Chaque fois qu'il est valorisé, $ RANDOM renvoie un entier aléatoire compris entre 0 et 32k. AU HASARD

peut être réglé sur "semer" le générateur de nombres aléatoires.

$ LINENO (lecture seulement)

Evalue toujours le numéro de ligne actuel du script en cours d'exécution – utile pour le débogage.

(11)

Pour personnaliser le comportement d'un script au moment de l'exécution,
vous pouvez lui donner un nombre quelconque d'arguments sur la commande
ligne.

Ce sont souvent des noms de fichiers, mais peuvent être interprétés par le script de quelque manière que ce soit. Les options
sont souvent spécifiés en utilisant la convention "-flag" utilisée par la plupart des programmes Unix, et une commande ksh
getopts est disponible pour aider à les analyser.

Le shell développe les caractères génériques et rend variable et
substitutions de commandes comme d'habitude, puis analyse les mots obtenus par des espaces (en réalité
variable spéciale $ IFS) et place les chaînes de texte résultantes dans
variables de position
comme suit:

0 $, 1 $, 2 $, ... 9 $

Les 9 premiers arguments sont disponibles directement sous forme de $ 1-9 $. Pour accéder à plus de 9, utilisez
décalage, ou $ *, $ @. La variable 0 $ contient le nom du
script lui-même.

$ 10, $ 11, ...

Les arguments positionnels supérieurs à 9 sont définis par ksh et bash. N'oubliez pas d'utiliser des accolades pour vous y référer.

décalage

ignore $ 1 et renumérote toutes les autres variables. "décalage N"déplacera N arguments à la fois.

$ #

contient le nombre d'arguments définis (non compris $ 0).

$ *

contient tous les arguments dans une seule chaîne, avec un espace les séparant.

$ @

semblable à $ *, mais s'il est utilisé entre guillemets, il cite efficacement chaque argument et les maintient séparés.
Si un argument contient des espaces, la distinction est importante.

par exemple. si la liste d'arguments est: a1 a2 "a3 qui contient des espaces" a4
alors: $ 1 = a1, $ 2 = a2, $ 3 = a3 qui contient des espaces, $ 4 = a4
et: $ * = a1 a2 a3 qui contient des espaces a4
et: "$ @" = "a1" "a2" "a3 qui contient des espaces" "a4"

Utiliser uniquement le formulaire "$ @" préserve les arguments cités. Si les arguments sont passés du script
directement à un autre programme, cela peut faire une grande différence quant à la signification.

Exemple: affichage ex7, texte

            1: #! / bin / sh
            2: #
            3: # Vérifier la gestion des arguments de position
            4: écho "Nombre d'arguments: $ #"
   5: écho "0 $ = 0 $"
   6: 
            7: écho "Boucle sur $ *"
   8: pour un dans $ *; faire
            9:    écho  "$ a "
  dix: terminé
        11: 
        12: écho "Boucle sur " $ @ ""
  13: pour un dans "$ @"; faire
        14:    écho  "$ a "
  15: terminé

Définir de nouveaux arguments de position

le ensemble commande, suivie d'un ensemble d'arguments, crée un nouvel ensemble de
arguments de position. Ceci est souvent utilisé, en supposant que les arguments originaux ne sont plus nécessaires, pour analyser
un ensemble de mots (en utilisant éventuellement des séparateurs de champs différents). Les arguments peuvent être réinitialisés autant de fois que nécessaire.

Exemple: affichage ex2, texte

            1: #! / bin / sh
            2: # Trouver une entrée dans le fichier de mots de passe
            3: pwent =`grep '^ root:' / etc / passwd`
   4: # Turn off globbing - les lignes de mot de passe contiennent souvent '*'
            5: set -o noglob
   6: # Le "nom complet" et les autres commentaires sont en
            7: # champ 5, délimité par deux points. Obtenir ce champ en utilisant le fractionnement des mots de passe
            8: OIFS =$ IFS; IFS =:; ensemble $ pwent; IFS =$ OIFS
            9: écho 5 $

Exemple: affichage pickrandom, texte
Sélectionne un fichier aléatoire dans un répertoire.
Utilise la fonctionnalité ksh RANDOM.

            1: #! / bin / ksh
            2: 
            3: # Sélectionnez une image aléatoire dans la collection de logos en arrière-plan.
            4: # Ceci pourrait être utilisé pour configurer un économiseur d'écran, par exemple.
            5: #
            6: # Cela fonctionne même si les noms de fichiers contiennent des espaces.
            7: 
            8: # passer au répertoire des logos pour éviter les longs chemins
            9: logos =/ afs / northstar / commun / usr / lib / X11 / logos / arrière-plans
  dix: CD logos $
        11: 
        12: # '*' est un joker de nom de fichier qui correspond à tous les fichiers du répertoire en cours.
        13: ensemble *
  14: 
        15: # Utilisez la syntaxe pour les expressions arithmétiques. "%" est l'opérateur modulo
        16: # Décale les arguments d'un nombre aléatoire entre 0 et le nombre de fichiers
        17: décalage $ (($ RANDOM % $ #))
        18: 
        19: # Affiche le premier argument résultant
        20: écho "logos $/1 $"

(12)

Options de démarrage. ksh -options scriptname

-X

echo ligne stderr avant de l'exécuter

-n

lit les commandes et vérifie les erreurs de syntaxe, mais ne les exécute pas.

-une

toutes les variables sont automatiquement exportées

-F

désactiver l'expansion des noms de fichiers génériques (globbing)

set -x

Définir une option dans un script shell

$ -

contient les lettres d'option actuellement définies

Il y a beaucoup d'autres options, pas souvent nécessaires. Les options en ksh et bash peuvent aussi être
définir en utilisant des noms longs (par exemple -o noglob au lieu de -F). De nombreuses options
sont uniques à ksh ou bash.

(13)

syntaxe sh

`commande`

Une commande (plus des arguments optionnels) entourés de backticks est exécutée et la sortie standard
de cette commande est substitué. Si la commande produit une sortie multiligne, les nouvelles lignes sont conservées.
Si la chaîne résultante est affichée, sans guillemets, en utilisant écho, les nouvelles lignes et les espaces multiples seront supprimés.

syntaxe ksh / bash

$ (commande)

Cette syntaxe est fonctionnellement identique à celle des backticks, mais les commandes peuvent être plus facilement imbriquées.

$ (<fichier)

Ceci est équivalent à `cat file`, mais mis en œuvre en interne pour plus d'efficacité.

Exemple: affichage ex3, texte

            1: #! / bin / ksh
            2: 
            3: écho Aujourd'hui c'est `rendez-vous amoureux`
   4: 
            5: fichier =/ etc / hosts
   6: écho Le fichier fichier $ a $ (wc -l < fichier $) lignes
   7: 
            8: nom_hôte -s> nom_hôte
   9: écho Ce système a le nom d’hôte $ (<monhôte)

(14)

Toute commande simple (ou fonction shell, ou commande composée) peut avoir son entrée et sa sortie
redirigé à l'aide des opérateurs suivants. Ceci est effectué par le shell avant
la commande est exécutée.

Redirection de sortie

> nom de fichier

La sortie standard (descripteur de fichier 1) est redirigée vers le fichier nommé. Le fichier est écrasé
à moins que le noclobber l'option est définie. Le fichier est créé s'il n'existe pas.

Le fichier de périphérique spécial / dev / null peut être utilisé pour ignorer explicitement les sorties indésirables.
La lecture de / dev / null entraîne un statut de fin de fichier.

>> nom de fichier

La sortie standard est ajoutée au fichier nommé. Le fichier est créé s'il n'existe pas.

> | nom de fichier

Sortie redirection, et remplacer le noclobber option, si définie.

Redirection d'entrée

< nom de fichier

L'entrée standard (descripteur de fichier 0) est redirigée vers le fichier nommé. Le fichier doit déjà
exister.

Pipelines de commande

commande | commander [ | command ...]

Pipe plusieurs commandes ensemble. La sortie standard de la première commande devient la norme
entrée de la deuxième commande. Toutes les commandes sont exécutées simultanément et le transfert de données s'effectue via la mémoire.
des tampons. C'est l'une des constructions les plus puissantes d'Unix. Composé les commandes peuvent aussi être
utilisé avec des tuyaux. Les pipes jouent très bien avec les systèmes multiprocesseurs.

Un seul pipeline dans un pipeline doit être interactif (tentative de lecture depuis
le terminal). Cette construction est beaucoup plus efficace que l’utilisation de fichiers temporaires, et la plupart des
Les utilitaires Unix sont conçus pour fonctionner correctement dans les pipelines.

L'état de sortie d'un pipeline est l'état de sortie de la dernière commande. Dans les commandes composées, un pipeline
peut être utilisé n'importe où une simple commande pourrait être utilisée.

(15)

Les scripts shell peuvent générer directement des sorties ou lire des entrées dans des variables à l'aide des commandes suivantes:

Sortie de script

écho

Imprimez les arguments, séparés par des espaces, et terminés par une nouvelle ligne, sur stdout.
Utilisez des guillemets pour préserver l’espacement. Echo comprend également les conventions d’échappement de type C.

Attention ça
le shell peut traiter les barres obliques inverses avant écho les voit (peut avoir besoin de doubler la barre oblique inverse).
Interne dans la plupart des coquilles, mais était à l'origine externe.

b	retour arrière	c	ligne d'impression sans nouvelle ligne (certaines versions)
F	formulaire d'alimentation	n	nouvelle ligne
r	retour chariot	t	languette
v	onglet vertical	\	barre oblique inverse

0n où n est le caractère de 8 bits dont le code ASCII
      code est le nombre octal à 1, 2 ou 3 chiffres
      représentant ce personnage.

-n

supprimer newline

impression (ksh interne)

Imprimez les arguments, séparés par des espaces, et terminés par une nouvelle ligne, sur stdout.
Print observe les mêmes conventions d'échappement que l'écho.

-n

supprimer newline

-r

mode brut – ignore les conventions -escape

-R

mode brut – ignore les conventions et les options -escape sauf -n.

Entrée de script

lis var1 var2 reste

lit une ligne de stdin, analyse de $ IFS et place les mots dans les variables nommées.
Tous les mots restants entrent tous dans la dernière variable. Un '' comme dernier caractère d'une ligne
supprime l’importance de la nouvelle ligne et l’entrée continue avec la ligne suivante.

-r

mode brut – ignore les conventions -escape

Exemple: affichage ex4a, texte

            1: #! / bin / sh
            2: écho "Test de la saisie utilisateur interactive: saisissez quelques touches et appuyez sur la touche Retour"
   3: lis x plus
   4: écho "Le premier mot était "$ x ""
   5: écho "Le reste de la ligne (le cas échéant) était "$ plus ""

(16)

La plupart des opérateurs de contrôle de flux utiles impliquent de faire des tests conditionnels et
branchement sur le résultat (vrai / faux). Le test peut être soit le tester

commande, ou son alias, [[[[, ou le ksh / bash intégré [[[[[ ... ]]

commande, qui a des options légèrement différentes, ou il peut être toute commande qui retourne
un statut de sortie approprié. Zéro est considéré comme "vrai", tandis que toute valeur autre que zéro est "faux".
Notez que ceci est inversé par rapport à la convention du langage C.

Tests de fichiers

-e fichier

Vrai si fichier existe (peut être de tout type).

-F fichier

Vrai si fichier existe et est un fichier ordinaire.

-ré fichier

Vrai si fichier existe et est un répertoire.

-r fichier

Vrai si fichier existe et est lisible
De même, -w = accessible en écriture, -X = exécutable, -L = est un lien symbolique.

-s fichier

Vrai si fichier existe et a une taille supérieure à zéro

-t archiveur de notes

Vrai si l'ouvert archiveur de notes est associé à un terminal. Par exemple. c'est
utilisé pour déterminer si la sortie standard a été redirigée vers un fichier.

Tests de chaînes de caractères

-n "chaîne"

vrai si chaîne a une longueur non nulle

-z "chaîne"

vrai si chaîne a une longueur nulle

Avec [[[[, l'argument doit être cité, car s'il s'agit d'une variable
a une valeur nulle, l'expansion résultante ( [ -z ] ) est une erreur de syntaxe. Un
les extensions générant "" comptent comme une chaîne nulle.
Pour [[[[ seulement, un cité
la chaîne seule est équivalente au test -n, par ex. [ « $var » ]. Dans les coquilles plus anciennes pour lesquelles
[[[[ est un programme externe, le seul moyen de tester une chaîne nulle est:
si [ "X€var" = "X" ]
C'est rarement nécessaire maintenant, mais on le trouve encore souvent.

$ variable = texte

Vrai si $ variable allumettes texte.

$ variable < texte

Vrai si $ variable vient avant (lexicalement) texte
De même, > = vient après

(17)

Arithmetic tests

$variable -eq nombre

True if $variable, interpreted as a number, is equal to nombre.

$variable -ne nombre

True if $variable, interpreted as a number, is ne pas égal à nombre.
De même, -lt = less than, -le = less than or equal,
-gt = greater than, -ge = greater than or equal

Additional tests for [[…]](ksh and bash)

$variable = modèle

True if $variable allumettes modèle. Si modèle contains no wildcards,
then this is just an exact text match. The same wildcards as used for filename matching are used.

le modèle must not be quoted. Puisque [[…]]is internal to the shell, the pattern in this case is
treated differently and not filename-expanded as an external command would require.

file1 -nt file2

True if file1 is newer than file2.
De même -ot = older than

file1 -ef file2

true if file1 is effectively the same as file2, after following
symlinks and hard links.

Negating and Combining tests

Tests may be negated by prepending the ! operator, and combined with boolean
ET et OU operators using the syntax:

conditionnel -a conditionnel, conditionnel -o conditionnel

ET et OU syntax for tester et [[[[

conditionnel && conditionnel, conditionnel || conditionnel

ET et OU syntax for [[[[[ ... ]]

Parentheses may be inserted to resolve ambiguities or override the default operator precedence rules.

Exemples:

si [[  -x /usr/local/bin/lserve && 
       -w /var/logs/lserve.log ]]; puis
   /usr/local/bin/lserve >> /var/logs/lserve.log &
fi

pwent=`grep '^richard:' /etc/passwd`
si [ -z "$pwent" ]; puis
   echo richard not found
fi

(18)

UNE liste in these descriptions is a simple command, or a pipeline.
The value of the liste is the value of the last simple command run in it.

UNE liste can also be a set of simple commands or
pipelines separated by ";,&,&&,||,|&".
For the compound commands which branch on the success or failure
de certaines liste, it is usually [[[[ ou [[[[[[[[, but can be anything.

Conditional execution: if/else

liste && liste

Execute the first liste. If true (success), execute the second one.

liste || liste

Execute the first liste. If false (failure), execute the second one.

Exemple:

mkdir tempdir && cp workfile tempdir

sshd || echo "sshd failed to start"

You can use both forms together (with care) – they are processed left to right, and && must come first.

Exemple:

mkdir tempdir && cp workfile tempdir || 
 echo "Failed to create tempdir"

si liste; puis liste ; elif liste; puis liste; autre liste; fi

Execute the first liste, and if true (success), execute the "then" list, otherwise
execute the "else" list. The "elif" and "else" lists are optional.

Exemple:

si [ -r $myfile ]
puis
   cat $myfile
autre
   echo $myfile not readable
fi

Looping: 'while' and 'for' loops

tandis que liste; faire liste; terminé

jusqu'à ce que liste; faire liste; terminé

Execute the first liste and if true (success), execute the second liste. Repeat as
long as the first liste est vrai. le jusqu'à ce que form just negates the test.

Exemple: ex4 display, text

            1: #!/bin/ksh
            2: count=0
   3: max=dix
   4: tandis que [[[[[[[[$count -lt $max ]]
   5: faire 
            6:   écho $count
            7:   count=$((count + 1))
            8: terminé
            9: écho "Value of count after loop is: $count"

pour identifiant [in[in[in[inmots ]; do; liste; terminé

Ensemble identifiant in turn to each word in mots and execute the liste.
Omitting the "in mots" clause implies using [email protected], i.e. the identifiant est mis en
turn to each positional argument.

Exemple:

for file in *.dat
faire
    echo Processing $file
terminé

As with most programming languages, there are often several ways to express the same action.
Running a command and then explicitly examining $? can be used instead of some of the above.

Compound commands can be thought of as running in an implicit subshell. Ils
can have I/O redirection independant of the rest of the script. Setting of variables in a real subshell does not
leave them set in the parent script. Setting variables in implicit subshells varies in behaviour among shells.
Older sh could not set variables in an implicit subshell and then use them later,
but current ksh can do this (mostly).

Exemple: ex11 display, text
Reading a file line by line. The book by Randal Michael contains 12 example ways to read a file line by line,
which vary tremendously in efficiency. This example shows the simplest and fastest way.

            1: #!/bin/sh
            2: 
            3: # Demonstrate reading a file line-by-line, using I/O
            4: # redirection in a compound command
            5: # Also test variable setting inside an implicit subshell.
            6: # Test this under sh and ksh and compare the output.
            7: 
            8: line="TEST"
   9: save=
        10: 
        11: si [-z"[-z"[-z"[-z"$1" ]; puis
        12:    écho "Usage: 0 $ filename"
  13: autre
        14:    si [-r[-r[-r[-r$1 ]; puis
        15:       tandis que read line; faire
        16:          écho "$line"
  17:          save=$line
        18:       terminé < $1
        19:    fi
        20: fi
        21: écho "End value of $line est $line"
  22: écho "End value of $save est $save"

(19)

Case statement: pattern matching

Cas mot dans modèle) liste;; esac

Comparer mot avec chaque modèle) in turn, and executes the first liste
pour lequel le mot allumettes. le les patrons follow the same rules as for filename
wildcards.

(ksh and bash only)
A pattern-list is a list of one or more patterns separated
from each other with a |. Composite patterns can be formed
with one or more of the following:

?(pattern-list)

Optionally matches any one of the given patterns.

*(pattern-list)

Matches zero or more occurrences of the given patterns.

+(pattern-list)

Matches one or more occurrences of the given patterns.

@(pattern-list)

Matches exactly one of the given patterns.

!(pattern-list)

Matches anything, except one of the given patterns.

Exemple:

    
    
    
    case $filename in
    *.dat)
        echo Processing a .dat file
        ;;
    *.sas)
        echo Processing a .sas file
        ;;
    *)
        # catch anything else that doesn't match patterns
        echo "Don't know how to deal with $filename"
        ;;
    esac

Miscellaneous flow control and subshells

die()

   # Print an error message and exit with given status
   # call as: die status "message" ["message" ...]
   exitstat=$1; décalage
   for i in "[email protected]"; faire
      print -R "$i"
   terminé
   exit $exitstat

[ -w $filename ]    || 
  die 1 "$file not writeable" "check permissions"

vprint()

   # Print or not depending on global "$verbosity"
   # Change the verbosity with a single variable.
   # Arg. 1 is the level for this message.
   level=$1; décalage
   si [[ $level -le $verbosity ]]; puis
      print -R $*
   fi


verbosity=2
vprint 1 This message will appear
vprint 3 This only appears if verbosity is 3 or higher

echo "Error: program failed" >&2