Redirection des flux d'entrée/sortie standards. Chaînes et flux de programmes, redirection

Vous connaissez déjà deux méthodes pour travailler avec la sortie des scripts de ligne de commande :

  • Affichage des données de sortie à l'écran.
  • Rediriger la sortie vers un fichier.
Parfois, vous devez afficher quelque chose à l'écran et écrire quelque chose dans un fichier. Vous devez donc comprendre comment Linux gère les entrées et les sorties, ce qui signifie apprendre à envoyer les résultats des scripts là où vous en avez besoin. Commençons par parler des descripteurs de fichiers standards.

Descripteurs de fichiers standards

Sous Linux, tout est constitué de fichiers, y compris les entrées et les sorties. Le système d'exploitation identifie les fichiers à l'aide de descripteurs de fichiers.

Chaque processus peut avoir jusqu'à neuf descripteurs de fichiers ouverts. Le shell bash réserve les trois premiers handles avec les ID 0, 1 et 2. Voici ce qu'ils signifient.

  • 0 , STDIN - flux d'entrée standard.
  • 1, STDOUT - flux de sortie standard.
  • 2, STDERR - flux d'erreurs standard.
Ces trois poignées spéciales gèrent les entrées et les sorties du script.
Vous devez vraiment comprendre les flux standard. Ils peuvent être comparés au fondement sur lequel repose l’interaction des scripts avec monde extérieur. Regardons les détails à leur sujet.

STDIN

STDIN est le flux d'entrée standard du shell. Pour un terminal, l'entrée standard est le clavier. Lorsque les scripts utilisent le caractère de redirection d'entrée -< , Linux заменяет дескриптор файла стандартного ввода на тот, который указан в команде. Система читает файл и обрабатывает данные так, будто они введены с клавиатуры.

De nombreuses commandes bash acceptent les entrées de STDIN à moins que la ligne de commande ne spécifie un fichier à partir duquel extraire les données. Par exemple, cela est vrai pour la commande cat.

Lorsque vous entrez la commande cat sur la ligne de commande sans spécifier aucun paramètre, elle accepte les entrées de STDIN. Après avoir entré la ligne suivante, cat l'affiche simplement à l'écran.

SORTIE STD

STDOUT est le flux de sortie standard du shell. Par défaut, c'est l'écran. La plupart des commandes bash génèrent des données vers STDOUT, ce qui les fait apparaître dans la console. Les données peuvent être redirigées vers un fichier en les ajoutant à son contenu à l'aide de la commande >>.

Nous avons donc un fichier de données auquel nous pouvons ajouter plus de données en utilisant cette commande :

Pwd >> mon fichier
Les sorties pwd seront ajoutées au fichier myfile , mais les données déjà contenues n'iront nulle part.

Redirection de la sortie de la commande vers un fichier

Jusqu'ici tout va bien, mais que se passe-t-il si vous essayez de faire quelque chose comme ce qui suit en accédant à un fichier xfile inexistant, tout conçu pour provoquer l'envoi d'un message d'erreur à mon fichier.

Ls –l xfile > monfichier
Après avoir exécuté cette commande, nous verrons des messages d'erreur à l'écran.


Tentative d'accès à un fichier inexistant

Une erreur est générée lors de la tentative d'accès à un fichier inexistant, mais le shell n'a pas redirigé les messages d'erreur vers le fichier en les imprimant à l'écran. Mais nous voulions que les messages d'erreur soient inclus dans le fichier. Ce qu'il faut faire? La réponse est simple : utilisez le troisième descripteur standard.

STDERR

STDERR est le flux d'erreurs standard du shell. Par défaut, ce handle pointe vers la même chose que STDOUT, c'est pourquoi nous voyons un message à l'écran lorsqu'une erreur se produit.

Supposons donc que nous souhaitions rediriger les messages d'erreur vers, par exemple, un fichier journal ou ailleurs, au lieu de les imprimer à l'écran.

▍Redirection du flux d'erreurs

Comme vous le savez déjà, le handle de fichier STDERR est 2. Nous pouvons rediriger les erreurs en plaçant ce handle avant la commande de redirection :

Ls -l xfile 2>monfichier cat ./monfichier
Le message d'erreur ira maintenant dans mon fichier.


Redirection d'un message d'erreur vers un fichier

▍Redirection des erreurs et des flux de sortie

Lors de l'écriture de scripts de ligne de commande, il peut arriver que vous deviez rediriger à la fois les messages d'erreur et la sortie standard. Pour y parvenir, vous devez utiliser des commandes de redirection pour les descripteurs appropriés, en spécifiant les fichiers où doivent se trouver les erreurs et la sortie standard :

Ls –l monfichier xfile autrefichier 2> contenu d'erreur 1> contenu correct

Erreurs de redirection et sortie standard

Le shell redirigera ce que la commande ls enverrait normalement à STDOUT vers le fichier de contenu correct grâce à la construction 1>. Les messages d'erreur qui seraient envoyés à STDERR se retrouveraient dans le fichier errorcontent en raison de la commande de redirection 2>.

Si nécessaire, STDERR et STDOUT peuvent être redirigés vers le même fichier à l'aide de la commande &> :


Redirection de STDERR et STDOUT vers le même fichier

Une fois la commande exécutée, ce qui est destiné à STDERR et STDOUT se retrouve dans le fichier de contenu.

Redirection de la sortie dans les scripts

Il existe deux méthodes pour rediriger la sortie dans les scripts de ligne de commande :
  • Redirection temporaire ou redirection de sortie sur une seule ligne.
  • Redirection permanente, ou redirection de tout ou partie de la sortie d'un script.

▍Redirection de sortie temporaire

Dans un script, vous pouvez rediriger la sortie d'une seule ligne vers STDERR. Pour ce faire, il suffit d'utiliser la commande de redirection, en spécifiant le descripteur STDERR, et de faire précéder le numéro du descripteur d'une esperluette (&) :

#!/bin/bash echo "Ceci est une erreur" >&2 echo "Ceci est une sortie normale"
Si vous exécutez le script, les deux lignes apparaîtront à l'écran car, comme vous le savez déjà, par défaut, les erreurs sont affichées au même endroit que les données normales.


Redirection temporaire

Exécutons le script pour que la sortie STDERR soit envoyée dans un fichier.

./monscript 2> monfichier
Comme vous pouvez le voir, la sortie normale est désormais envoyée à la console et les messages d'erreur sont envoyés dans un fichier.


Les messages d'erreur sont écrits dans un fichier

▍Redirection de sortie permanente

Si votre script doit rediriger une grande partie du résultat vers l'écran, il n'est pas pratique d'ajouter la commande appropriée à chaque appel d'écho. Au lieu de cela, vous pouvez définir la sortie pour qu'elle soit redirigée vers un handle spécifique pendant la durée du script à l'aide de la commande exec :

#!/bin/bash exec 1>outfile echo "Il s'agit d'un test de redirection de toutes les sorties" echo "d'un script shell vers un autre fichier." echo "sans avoir à rediriger chaque ligne"
Exécutons le script.


Redirection de toutes les sorties vers un fichier

Si vous regardez le fichier spécifié dans la commande de redirection de sortie, vous constaterez que tout ce qui a été généré par les commandes echo s'est retrouvé dans ce fichier.

La commande exec peut être utilisée non seulement au début du script, mais également à d'autres endroits :

#!/bin/bash exec 2>myerror echo "C'est le début du script" echo "redirige maintenant toutes les sorties vers un autre emplacement" exec 1>myfile echo "Cela devrait aller dans le fichier myfile" echo "et cela devrait aller au fichier myerror" >&2
C'est ce que vous obtenez après avoir exécuté le script et examiné les fichiers vers lesquels nous avons redirigé la sortie.


Redirection de la sortie vers différents fichiers

La commande exec redirige d'abord la sortie de STDERR vers le fichier myerror . La sortie de plusieurs commandes d'écho est ensuite envoyée à STDOUT et imprimée à l'écran. La commande exec provoque ensuite l'envoi de tout ce qui se retrouve dans STDOUT dans le fichier myfile , et enfin nous utilisons la commande redirect vers STDERR dans la commande echo, ce qui provoque l'écriture de la ligne correspondante dans le fichier myerror.

Une fois que vous maîtriserez cela, vous serez en mesure de rediriger la sortie là où vous le souhaitez. Parlons maintenant de la redirection des entrées.

Redirection des entrées dans les scripts

Pour rediriger l'entrée, vous pouvez utiliser la même technique que celle que nous avons utilisée pour rediriger la sortie. Par exemple, la commande exec permet de faire d'un fichier la source des données pour STDIN :

Exécuteur 0< myfile
Cette commande indique au shell que la source d'entrée doit être myfile plutôt que le STDIN normal. Voyons la redirection d'entrée en action :

#!/bin/bash exécutable 0< testfile count=1 while read line do echo "Line #$count: $line" count=$(($count + 1)) done
C'est ce qui apparaîtra à l'écran après l'exécution du script.


Redirection d'entrée

Dans un article précédent, vous avez appris à utiliser la commande read pour lire les entrées utilisateur à partir du clavier. Si vous redirigez l'entrée en transformant la source de données en fichier, la commande read, lorsque vous essayez de lire des données depuis STDIN, les lira à partir du fichier et non à partir du clavier.

Certains administrateurs Linux utilisent cette approche pour lire puis traiter les fichiers journaux.

Créer votre propre redirection de sortie

En redirigeant les entrées et les sorties dans des scripts, vous n'êtes pas limité aux trois descripteurs de fichiers standards. Comme mentionné, vous pouvez avoir jusqu'à neuf poignées ouvertes. Les six autres, numérotés de 3 à 8, peuvent être utilisés pour rediriger les entrées ou les sorties. N'importe lequel d'entre eux peut être affecté à un fichier et utilisé dans le code de script.

Vous pouvez attribuer un handle aux données de sortie à l'aide de la commande exec :

#!/bin/bash exec 3>myfile echo "Ceci devrait s'afficher à l'écran" echo "et cela devrait être stocké dans le fichier" >&3 echo "Et cela devrait être de retour à l'écran"
Après avoir exécuté le script, une partie de la sortie apparaîtra à l'écran, une partie dans un fichier avec le descripteur 3.


Redirection de la sortie à l'aide de son propre handle

Création de descripteurs de fichiers pour la saisie de données

Vous pouvez rediriger les entrées dans un script de la même manière que vous redirigez la sortie. Stockez STDIN dans un autre handle avant de rediriger l’entrée.

Après avoir fini de lire le fichier, vous pouvez restaurer STDIN et l'utiliser comme d'habitude :

#!/bin/bash exécutable 6<&0 exec 0< myfile count=1 while read line do echo "Line #$count: $line" count=$(($count + 1)) done exec 0<&6 read -p "Are you done now? " answer case $answer in y) echo "Goodbye";; n) echo "Sorry, this is the end.";; esac
Essayons le scénario.


Redirection d'entrée

Dans cet exemple, le descripteur de fichier 6 a été utilisé pour stocker une référence à STDIN. Ensuite, la redirection des entrées a été effectuée, le fichier est devenu la source de données pour STDIN. L'entrée de la commande de lecture provenait alors du STDIN redirigé, c'est-à-dire du fichier.

Après avoir lu le fichier, nous réinitialisons STDIN en le redirigeant vers le handle 6. Désormais, afin de vérifier que tout fonctionne correctement, le script pose une question à l'utilisateur, attend la saisie au clavier et traite ce qui est saisi.

Fermeture des descripteurs de fichiers

Le shell ferme automatiquement les descripteurs de fichiers une fois le script terminé. Cependant, dans certains cas, il est nécessaire de fermer les handles manuellement avant la fin de l'exécution du script. Afin de fermer un handle, il doit être redirigé vers &- . Cela ressemble à ceci :

#!/bin/bash exec 3> myfile echo "Ceci est une ligne de données de test" >&3 exec 3>&- echo "Cela ne fonctionnera pas" >&3
Après avoir exécuté le script, nous recevrons un message d'erreur.


Tentative d'accès à un descripteur de fichier fermé

Le fait est que nous avons essayé d'accéder à un descripteur inexistant.

Soyez prudent lorsque vous fermez les descripteurs de fichiers dans les scripts. Si vous avez envoyé des données vers un fichier, puis fermé le handle, puis l'avez rouvert, le shell remplacera le fichier existant par un nouveau. Autrement dit, tout ce qui a été précédemment écrit dans ce fichier sera perdu.

Obtenir des informations sur les handles ouverts

Pour obtenir une liste de tous les handles ouverts sous Linux, vous pouvez utiliser la commande lsof. Sur de nombreuses distributions, comme Fedora, l'utilitaire lsof se trouve dans /usr/sbin. Cette commande est très utile car elle affiche des informations sur chaque handle ouvert sur le système. Cela inclut ce qui est ouvert par les processus exécutés en arrière-plan et ce qui est ouvert par les utilisateurs connectés.

Cette commande possède de nombreuses touches, regardons les plus importantes.

  • -p Vous permet de spécifier l'ID du processus.
  • -d Permet de préciser le numéro du descripteur sur lequel vous souhaitez obtenir des informations.
Afin de connaître le PID du processus en cours, vous pouvez utiliser une variable d'environnement spéciale $$, dans laquelle le shell écrit le PID actuel.

Le commutateur -a est utilisé pour effectuer une opération ET logique sur les résultats renvoyés en utilisant les deux autres commutateurs :

Lsof -a -p $$ -d 0,1,2

Affichage des informations sur les handles ouverts

Le type de fichiers associés à STDIN, STDOUT et STDERR est CHR (mode caractère). Puisqu'ils pointent tous vers un terminal, le nom du fichier correspond au nom du périphérique attribué au terminal. Tous les trois fichier standard disponible pour la lecture et l'écriture.

Regardons l'appel de la commande lsof à partir d'un script dans lequel, en plus des descripteurs standards, d'autres descripteurs sont ouverts :

#!/bin/bash exec 3> monfichier1 exec 6> monfichier2 exec 7< myfile3 lsof -a -p $$ -d 0,1,2,3,6,7
C'est ce qui se passe si vous exécutez ce script.


Afficher les descripteurs de fichiers ouverts par un script

Le script a ouvert deux handles pour la sortie (3 et 6) et un pour l'entrée (7). Les chemins d'accès aux fichiers utilisés pour configurer les descripteurs sont également affichés.

Suppression de sortie

Parfois, vous devez vous assurer que les commandes d'un script, qui, par exemple, peuvent être exécutées comme processus en arrière-plan, rien ne s'affichait à l'écran. Pour ce faire, vous pouvez rediriger la sortie vers /dev/null . C'est quelque chose comme un « trou noir ».

Voici un exemple de suppression des messages d'erreur :

Ls -al badfile autre fichier 2> /dev/null
La même approche est utilisée si, par exemple, vous devez effacer un fichier sans le supprimer :

Cat /dev/null > monfichier

Résultats

Aujourd'hui, vous avez découvert le fonctionnement des entrées et des sorties dans les scripts de ligne de commande. Vous savez maintenant comment gérer les descripteurs de fichiers, les créer, les afficher et les fermer, et savoir comment rediriger les flux d'entrée, de sortie et d'erreur. Tout cela est très important dans le développement de scripts bash.

La prochaine fois, nous parlerons des signaux Linux, de la façon de les gérer dans les scripts, de l'exécution des tâches planifiées et des tâches en arrière-plan.

Chers lecteurs! Ce matériel fournit les bases du travail avec les flux d’entrée, de sortie et d’erreurs. Nous sommes sûrs qu'il y a parmi vous des professionnels qui peuvent vous parler de tout cela, ce qui ne vient qu'avec l'expérience. Si tel est le cas, nous vous passons la parole.

Bon moment, mes lecteurs !
Dans cet article je souhaite systématiser mes connaissances selon les principes de base exploitation de flux et de chaînes de programmes dans l'interpréteur et en général dans le système d'exploitation Linux, ainsi que sur les possibilités redirections données ruisseaux.
Au tout début, je voudrais souligner que l'interprète fonctionne avec trois flux standards :

  1. sortie standard Ce sortie standard, qui fournit le résultat de la commande. Le descripteur de flux est 1.
  2. stderr Ce flux d'erreur standard, qui imprime les erreurs de commande. Son descripteur est 2.
  3. entrée standard Ce entrée standard, qui fournit une entrée aux commandes. Son descripteur est 0.

Maintenant en mots simples Décrivons ce que signifient ces trois points :

sortie standard- flux de sortie standard. Ceci dit dans un langage simple, les informations que nous voyons dans l'interpréteur lors de l'exécution des commandes. C'est-à-dire tous les messages (sans messages d'erreur) que la commande exécutée dans l'interpréteur rapporte et affiche sur le terminal (lire : écran). (la sortie à l'écran est définie par défaut, mais vous pouvez également spécifier la sortie, par exemple vers un fichier ou rediriger vers une autre commande ; je vais vous expliquer comment cela se fait ci-dessous)

stderr- flux d'erreurs. Ce sont des erreurs lors de l'exécution de commandes dans bash, qui sont sorties par défaut sur stdout, c'est-à-dire sur le terminal (encore une fois, à moins que la sortie vers un autre emplacement ne soit spécifiée)

entrée standard- flux d'entrée. C'est, en termes simples, ce que nous saisissons depuis le clavier dans l'interpréteur pour exécuter la commande.

Ces flux sont très bien représentés dans la figure tirée de http://rus-linux.net/ :

Dans cette image : Stdin, affiché en vert, a la poignée 0
Stdout, représenté en rouge, a la poignée 1
Stderr, représenté en bleu, a la poignée 2

Ensuite, je vais vous expliquer comment ces flux peuvent être redirigés vers/depuis un fichier. C'est-à-dire lors de l'exécution d'une commande, afin que les messages ou les erreurs ne soient pas affichés à l'écran, mais soient écrits dans un fichier. Pourquoi est-ce? Eh bien, par exemple, vous exécutez une commande dont le résultat ne rentre pas dans la fenêtre du terminal. Vous lui dites d'enregistrer la sortie standard dans un fichier et l'erreur standard dans un autre. Ainsi, toutes les erreurs et si une sortie standard est nécessaire peuvent être visualisées en détail en ouvrant les fichiers enregistrés.

Ainsi, la redirection des threads se fait comme ceci :

$ commande n>fichier

Cette ligne affiche : exécution de la commande commande et la redirection du flux (où n= handle de flux) dans un fichier déposer. Lors de l'exécution de cette redirection, si fichier final existe, ce sera écrasé. Dans ce cas, si n n’est pas spécifié, alors la sortie standard est supposée.

$ commande n>>fichier

Cette commande a une syntaxe similaire, mais ici le symbole ">>" est spécifié. Avec cette redirection, si le fichier de destination existe, la sortie de la commande sera ajoutée aux données existantes.

$commande< file

V dans cet exempleéquipe commande est exécuté et utilise le fichier comme source d'entrée déposer, au lieu de la saisie au clavier

Il est parfois nécessaire de combiner le flux d'erreurs standard avec le flux de sortie standard afin que les erreurs et la sortie normale du programme puissent être traitées ensemble. A ces fins, une combinaison avec le symbole est utilisée : &. Un exemple de cette action :

Rechercher / -name .name_file > /path/to/file 2>&1

Lorsque cette commande est exécutée, un fichier est recherché à partir de la racine système de fichiers Avec nom .nom_fichier et rediriger les résultats de recherche (stdout et stderr) vers un fichier /chemin/vers/fichier. Conception > /chemin/vers/fichier 2>&1 redirige la sortie standard vers /chemin/vers/fichier et les erreurs d'impression sur la sortie standard. Cela dit : écrire 2>&1 avant > ne fonctionnera pas, car lorsque l'interpréteur lit 2>&1 , il ne sait pas encore où le flux de sortie standard est redirigé, donc les flux d'erreur et de sortie ne seront pas fusionnés.

$ commande > fichier 2>&1

semblable à l'écriture:

$ commande &> fichier

$ commande 2>&fichier

Si la sortie doit être ignorée, elle peut être dirigée vers le périphérique /dev/null, c'est une sorte de "trou noir" qui prend n'importe quelle quantité d'informations et ne la transforme en rien.

Je pense que les informations fournies sur la redirection des flux seront suffisantes pour en comprendre l'essence, je vais maintenant vous en parler transfert par convoyeur.

Pipeline sous Linux est la capacité de plusieurs programmes à travailler ensemble lorsque la sortie d'un programme est directement transférée à l'entrée d'un autre sans utiliser de fichiers temporaires intermédiaires. La syntaxe d'utilisation du pipeline est la suivante :

$commande1 | commande2

Dans cet exemple, la commande est exécutée commande1, son flux de sortie est utilisé comme flux d'entrée lors de l'exécution commande2.

C'est tout pour aujourd'hui. Je serai heureux de recevoir des commentaires et des ajouts. Merci.

Cordialement, McSim!

Trois directions d'E/S sont dédiées : entrée standard, sortie et flux d'erreurs ( stdin, stdout, stderr ). Par défaut, les trois threads sont associés au terminal. Dans ce cas, le programme affiche tous ses messages, y compris les erreurs, au terminal. Coquille vous permet de rediriger ces flux standards, de définir les E/S et le pooling de threads.

Redirection des flux d'E/S.

>fichier Redirection de la sortie standard vers un fichier déposer

>>fichier -Redirection de la sortie standard vers un fichier déposer avec ajout à la fin du fichier.

-obtenir une entrée standard à partir d'un fichier déposer.

prog1 | prog2 -Transférer le flux de sortie du programme prog1 vers le flux d'entrée du programme prog2.

n>fichier déposer.

n>>fichier -Redirection du flux standard avec le descripteur n vers un fichier déposer avec ajout à la fin du fichier.

n>&m -Combiner des fils avec des poignées n Et m .

$ prog1 >/dev/null 2>&1

/dev/null est un pseudo-appareil qui détruit le flux qui y est dirigé.

Passer le flux de sortie d’un programme au flux d’entrée d’un autre est souvent utilisé. Par exemple:

$ gzip -d archive.tar.gz | tar –xf

C'est ici que le fichier est décompressé archive.tar.gz , emballé par deux archiveurs. Flux de sortie de l'utilitaire gzip transmis au flux d'entrée à l'utilitaire le goudron . De même, la même opération pourrait être réalisée d'une autre manière :

$ gzip -d archive.tar.gz

$ tar -xf archive.tar

Parce que la langue Coquille Bourne est un langage de programmation procédural ; comme d'autres langages similaires, il possède des opérateurs qui vous permettent de contrôler la séquence d'exécution des commandes. Opérateur requis vérifie une certaine condition, en fonction de la réalisation de laquelle le déroulement ultérieur du programme est déterminé. Un tel opérateur est la commande test. Cette commande vérifie qu'une condition est remplie. L'équipe test Il existe deux options d'appel :

condition de test

[ condition ]

Il convient de noter qu'il doit y avoir des espaces entre la parenthèse et la condition, sinon Coquille ne reconnaîtra pas "[" comme commande test . En cas de réussite test Retour "0" .

Conditions de vérification des fichiers :

-f fichier Déposer "déposer" est un fichier normal.

-d fichier Déposer " déposer" est un directeur.
-c fichier Déposer "déposer" est un fichier spécial.
-r fichier Déposer "déposer" a l'autorisation de lecture.

-w fichier Déposer "déposer" dispose d'une autorisation d'écriture.

-x fichier Déposer "déposer" a l’autorisation d’exécuter.

-s fichier Déposer "déposer" pas vide.

Conditions de vérification des chaînes :

chaîne1=chaîne2 Cordes chaîne1 Et chaîne2 correspondre.

chaîne1!=chaîne2 Cordes chaîne1 Et chaîne2 ne correspondent pas.

-n chaîne1 Doubler chaîne1 existe.

-z chaîne1 Doubler chaîne1 n'existe pas.

Conditions pour les opérations avec des entiers :

x -eq y x est égal à y

x -ne y x n'est pas égal à y

x -gt y x est supérieur à y

x -ge y x est supérieur ou égal à y

x -lt y x est inférieur à y

x -le y x est inférieur ou égal à y

Dans ce cas la commande test traite les chaînes exactement comme des entiers. Valeur zéro une chaîne vide correspond également.

Opérations logiques dans le cadre test

! (pas) "NON" logique

-o (ou) "OU" logique

-un (et) "ET" logique

Opérateur conditionnel "si"

Usage général opérateur conditionnel if est représenté comme suit :

si<условие>

alors<список команд>

[elif<условие>

alors<список> ]

Les expressions entre crochets sont facultatives. Ceux. on peut imaginer la modification « hachée » la plus courante de l’opérateur conditionnel :

si<условие>

alors<список команд>

Dans ce cas, si <условие> terminé (code de sortie 0) puis exécuté <список команд>. DANS sinon <список команд> sauté.

Opérateur de sélection cas

En général, la syntaxe des opérateurs est cas comme suit:

cas<строка>dans

Modèle 1)

........

Modèle2)

........

........

Signification <строка> par rapport aux modèles, dans l'ordre. Si une correspondance est trouvée, les commandes de la section correspondante sont exécutées. A noter que les gabarits permettent l’utilisation de masques. Si aucune correspondance n'est trouvée, alors les commandes de la section avec le modèle "*" sont exécutées (similaire à défaut sélecteur changer V AVEC ).

A titre d'exemple, voici un extrait du script d'initialisation BSD-UNIX . Voici les variables (inetd_enable et inetd_flags) ont été obtenus à partir d'un autre fichier ( rc.conf).

. /etc/rc.conf

cas ($inetd_enable) dans

)

si [ -x /usr/sbin/inetd ]; alors

/usr/sbin/inetd $inetd_flags

Fi

;;
esac

Opérateur de boucle avec énumération pour

Syntaxe de l'opérateur pour

pour<имя>

<список команд>

Le fragment mis en évidence entre crochets peut être manquant. Opérateur pour garantit que la boucle est exécutée autant de fois qu'il y a de mots dans la liste de valeurs. Dans ce cas, la variable <имя> prend séquentiellement la signification des mots de la liste. La liste elle-même peut être formée à partir du résultat d’autres commandes. Si la liste est manquante, alors <имя> accepte les valeurs transmises comme paramètres de position au script.

Instruction de boucle avec condition vraie alors que

Syntaxe de l'opérateur alors que en général, il a la structure suivante :

alors que<условие>

<список команд>

Opérateur alors que est préférable lorsque la liste des valeurs des paramètres n'est pas connue à l'avance. La liste des commandes sera exécutée en boucle tant que la condition reste vraie. Lorsque vous entrez pour la première fois dans la boucle, la condition doit être vraie.

Instruction de boucle avec condition fausse jusqu'à

Syntaxe de l'opérateur jusqu'à en général, il a la structure suivante :

jusqu'à<условие>

<список команд>

La liste des commandes sera exécutée en boucle tant que la condition reste fausse. La première fois que vous entrez dans la boucle, la condition ne devrait pas être vraie. Il convient de noter que la condition de boucle est vérifiée pour déceler toute fausseté après chaque, incl. et la première commande exécutée dans la boucle.

Commandes de base Système d'exploitation UNIX pour travailler avec des fichiers

1. Équipe mot de passe.

Syntaxe: mot de passe .

Description : La commande affiche le nom du répertoire actuel pour le shell en cours d'exécution.

Exercice 1.

Utilisez la commande pwd pour déterminer votre répertoire personnel.

Reflétez l’équipe et le résultat de son travail dans le rapport.

2. Équipe homme.

Syntaxe: homme Nom.

Name est le nom de la commande ou de l'utilitaire qui nous intéresse, appel système, fonction de bibliothèque, fichier.

Description : MANUEL UNIX - guide système opérateur UNIX. Les informations à partir de là sont disponibles de manière interactive à l'aide de l'utilitaire homme .

Tâche 2.

Utilisez l'utilitaire man pour rechercher des informations sur la commande pwd.

Notez de brèves informations sur l'équipe dans le rapport (en russe).

3. Équipe CD.

Syntaxe: CD nom_répertoire.

Description : Il s'agit d'une commande pour changer le répertoire courant. DirectoryName est le nom complet ou relatif du répertoire que vous souhaitez rendre actuel.

CD sans paramètres, celui actuel constituera votre répertoire personnel.

Tâche 3.

Augmentez le répertoire actuel d'un niveau. Vérifiez-le, puis revenez à votre répertoire personnel. Vérifiez le changement de répertoire.

L'exécution des commandes terminées sera reflétée dans le rapport.

4. Équipe ls.

Syntaxe: ls nom_répertoire

Description : commande pour afficher le contenu du répertoire spécifié.

ls sans paramètres, imprime une liste de fichiers du répertoire courant.

La liste résultante n'inclura pas les fichiers dont les noms commencent par le symbole « . " - fichiers créés par divers programmes systèmeà vos propres fins. Regarder liste complète les fichiers peuvent être spécifiés dans la commande ls touche "-a",

ceux. ls -un_nom_répertoire

Autorisations de fichiers

Avec chaque fichier dans Système d'exploitation UNIX associé à un mot de 12 bits appelé « autorisations » sur le fichier.

Les 9 bits de poids faible de ce mot sont regroupés en trois groupes de trois bits ; Chaque groupe spécifie les droits d'accès du propriétaire du fichier, de son groupe et de tous les autres utilisateurs. Trois bits dans chaque groupe sont responsables du droit de lire, d'interroger et d'utiliser le fichier.

Pour connaître les droits d'accès à un fichier particulier, vous pouvez utiliser la commande

, Par exemple:

> ls -l /bin/cat

Un groupe de caractères situé en début de ligne -rwxr-xr-x indique le type de fichier (le premier caractère ; le signe moins signifie qu'il s'agit d'un fichier ordinaire, la lettre d signifierait un répertoire, etc.) et les droits d'accès, respectivement, pour le propriétaire (dans ce cas rwx , c'est à dire. lire, écrire et exécuter), le groupe et tous les autres (dans ce cas r-x , c'est à dire. aucun droit d'écriture). Donc le fichier /bin/chat peut être lu et exécuté par n'importe quel utilisateur, mais seul l'utilisateur peut le modifier racine (c'est-à-dire administrateur).

Vous pouvez écrire le mot des droits d'accès au fichier sous forme de nombre octal (3 caractères - chiffre octal), à trois chiffres (propriétaire, groupe, autres utilisateurs), chaque caractère de ce nombre octal à trois chiffres est formé comme la somme des droits : 4 - droits de lecture, 2 - droits d'enregistrement, 1 - d'utilisation (à partir d'une triade binaire) : (111) 2 =2 0 +2 1 +2 2 =(1+2+4) 10 .

Par exemple, 7 = 1 + 2 + 4 Þ droite rwx

4 2 1

6 = 0 + 2+ 4 Þ droite rw- -

4 2 0

Dans un numéro à trois chiffres, précisez les droits : 744 Tous les droits sont définis pour le propriétaire, en lecture seule pour le groupe et en lecture seule pour les autres utilisateurs.

Pour utiliser les autorisations de fichiers, utilisez la commande chmod , qui vous permet de spécifier de nouvelles autorisations sous forme de nombre octal, par exemple :

$ chmod 744 fichierl.c.

Tâche 4.

a) Pour recevoir information complèteà propos de la commande ls, utilisez l'utilitaire man. Redirigez la sortie de la commande vers un fichier texte.

b) Examinez le contenu complet du répertoire actuel et redirigez également cette sortie vers un fichier texte.

c) Utiliser une commande ls-l<имя_файла> Imprimez les informations sur les droits d'accès au fichier texte avec lequel vous avez travaillé à l'étape 4b, puis redirigez ces informations vers le même fichier texte. Expliquez votre conclusion.

5. Équipe chat.

Redirection d'E/S.

Pour visualiser le contenu d'un petit fichier texte à l'écran, vous pouvez utiliser la commande :

chat nom de fichier

Attention! N'essayez pas d'afficher le contenu du répertoire et des fichiers binaires de cette manière.

Un fichier de test volumineux peut être facilement visualisé par une équipe plus (pour une description de l'utilisation, voir MANUEL UNIX ). Pourquoi la commande est-elle gênante ici ? chat ?

Dans une équipe chat Vous pouvez spécifier plusieurs noms de fichiers :

cat fichier1 fichier 2 ... fichier N

dans ce cas, le contenu de tous les fichiers consécutifs sera affiché à l'écran.

Vous pouvez rediriger la sortie vers un fichier :

fichier cat 1 fichier 2 > fichier_résultats

La redirection de la sortie de la sortie standard (écran) vers un fichier est standard pour toutes les commandes. Vous pouvez rediriger l'entrée standard (à partir du clavier), par exemple, extraire les données d'un programme à partir d'un fichier, en utilisant le signe "<”.

chat > new_file - créera un nouveau fichier texte avec le contenu que vous saisissez à l'aide du clavier.

Abandonner le processus de saisie des données -

Tâche 5.

Créez un nouveau fichier texte en utilisant cat et affichez son contenu. Redirigez la sortie du flux standard vers un autre fichier dont vous saisissez le nom au clavier et vérifiez que l'opération a été effectuée correctement.

6. Les commandes les plus simples pour travailler avec des fichiers : cp, rm, mkdir, mv

Pour créer un nouveau répertoire, utilisez la commande :

mkdir nom_répertoire

Pour copier le contenu d'un fichier dans un autre, utilisez la commande :

CP fichier_source_fichier_destination.

Équipe

cp fichier 1 fichier 2…. fichier N répertoire de destination

sert à copier un ou plusieurs fichiers dans un répertoire déjà existant portant le nom destination_directory sous leurs propres noms. Au lieu des noms des fichiers copiés, vous pouvez utiliser leurs modèles. Les modèles sont spécifiés à l'aide de métacaractères :

* - correspond à toutes les chaînes de caractères, y compris les chaînes vides.

Tous les personnages uniques

[...] - correspond à n'importe quelle lettre entre parenthèses. Une paire de caractères séparés par un signe moins spécifie une plage de caractères.

Équipe

cp-r rép_source rép_destination

sert à la copie récursive d'un répertoire (source_dir) vers un nouveau répertoire (destination_dir).

Au lieu des noms dans les commandes de copie, leurs modèles peuvent être utilisés.

Équipe

rm fichier 1 fichier 2…. fichier SUBST

vous permet de supprimer 1 ou plusieurs fichiers réguliers du répertoire actuel.

Des caractères génériques peuvent être utilisés à la place des noms. Si vous souhaitez supprimer un ou plusieurs répertoires ainsi que leur contenu (suppression récursive) dans la commande rm utilise la clé -r

Rm-r dir 1 dir 2

Commande Renommer :

mv nom_source nom_destination

Un fichier nommé nom_source est renommé en fichier nommé nom_destination. Dans ce cas, avant d'exécuter la commande, un fichier nommé nom_destination ne doit pas exister.

Tâche 6.

Créez un nouveau répertoire dans votre répertoire personnel. Organisez-y un petit fichier de test avec deux lignes de contenu :

«J'apprends à travailler sous UNIX OS

Je vais organiser le scénario.

Copiez le contenu de ce fichier dans un autre du même nom, mais dans le répertoire /home. Supprimez le fichier initialement créé de votre répertoire si la copie réussit. Vérifiez le contenu des répertoires et fichiers utilisés.

Tâche 7.

1). Une fois que vous maîtrisez le travail interactif avec les commandes du système d'exploitation UNIX les plus simples, utilisez l'éditeur Kwriter pour créer un script avec un script qui correspond à une exécution séquentielle :

Tâche 3,

Tâche 4B, 4B,

Tâche 5,

Tâche 6.

Dans la tâche 6, n'oubliez pas de vérifier par programme si la copie du fichier a réussi, en affichant des messages texte et le contenu des répertoires correspondants.

Il faut qu'en fichier de commandes l'émission compétente des demandes de saisie de données à partir du clavier a été organisée à l'aide de la commande : $ echo - n « request text ».

2). Enregistrez le script sous le nom Myscript1, exécutez-le avec la commande

sh Monscript1

Entrez les données demandées et vérifiez les résultats.

3). Compilez un rapport sur les travaux de laboratoire réalisés, qui doit refléter à la fois votre travail en mode interactif et avec le script, y compris le texte du script (avec commentaires) et les résultats obtenus à l'écran et dans les fichiers.

Appels système getuid et getpid

Connaître l'identifiant de l'utilisateur qui a lancé le programme pour exécution - UID et l'ID du groupe auquel il appartient ,-GID possible en utilisant les appels système getuid() et getpid() en les appliquant dans ce programme.

Prototypes d'appels système :

#inclure

#inclure

uid_t getuid(void);

gid_t getgid(void);

Tâche 8.

Écrivez, compilez et exécutez un programme qui imprime l'ID utilisateur et l'ID de groupe de l'utilisateur exécutant le programme.

Incluez le programme avec les résultats dans le rapport.

Questions de contrôle

1. La notion de fichier dans Système d'exploitation UNIX . Qu'est-ce que le répertoire personnel ?

2. Quels moyens de regrouper les commandes existent ? Coquille -interprète? donner des exemples d'utilisation.

3. Comment les E/S sont-elles redirigées ?

4. Qu'est-ce qu'un pipeline de commandes ? Donne un exemple.

5. Par des moyens Coquille effectuer des opérations arithmétiques sur Coquille -variable?

6. Quelles sont les règles de génération des noms de fichiers ?

7. Comment la substitution de commandes est-elle effectuée ?

8. Comment interpréter une chaîne cmd1&cmd2& ?

9. Comment interpréter une chaîne cmd1 && cmd2 & ?

10. Comment interpréter une chaîne cmd1 || cmd2& ?

11. Comme dans UNIX Les autorisations sur les fichiers sont-elles définies ? Pour quelle équipe pouvez-vous les surveiller ? fichier spécifique?

12. Comment déterminer l'identifiant de l'utilisateur qui a lancé le programme et l'identifiant de son groupe ?

Travaux de laboratoire № 3.

Processus dans le système d'exploitation UNIX.

But du travail

Apprendre à créer des processus et maîtriser la modification du contexte utilisateur des processus à l'aide des appels système utilisés dans les programmes du langage AVEC, V Système d'exploitation UNIX.

1. Étudier l'organisation des processus dans UNIX : notion de processus, contexte du processus, cycle de vie processus, identification du processus, structure hiérarchique processus. Écrire à AVEC et déboguer le programme conformément à la tâche 1.

2. Familiarisez-vous avec la création d'un processus dans UNIX , avec l'organisation de l'achèvement du processus. Écrire et déboguer un programme (langage AVEC ), conformément à la tâche 2, l'inclure dans le rapport.

3. Explorez les paramètres de la fonction principal() en langue AVEC , variables d'environnement et arguments de ligne de commande. Écrire un programme dans une langue AVEC conformément à la tâche 3, déboguez-le et incluez-le dans le rapport avec les résultats.

4. Explorez la famille de fonctions pour organiser un appel système exec().

5. Écrivez un programme dans la langue AVEC conformément à la version de la tâche 4 donnée par l'enseignant, déboguer le programme et démontrer les résultats obtenus à l'enseignant. Incluez le programme avec les résultats dans le rapport.

6. Défendre le travail auprès de l'enseignant en répondant aux questions du test.

Tout programme est une « machine automatique » conçue pour traiter des données : recevant une information en entrée, il en produit une autre grâce à son travail. Même si les informations entrantes et/ou sortantes peuvent être nulles, c'est-à-dire simplement absentes. Les données qui sont transférées au programme pour traitement sont son entrée, ce qu'il produit à la suite du travail est la sortie. L'organisation des entrées et des sorties pour chaque programme est la tâche du système d'exploitation.

Chaque programme fonctionne avec des données d'un certain type : texte, graphique, son, etc. Comme cela est probablement déjà devenu clair, la principale interface de gestion du système sous Linux est un terminal conçu pour transférer des informations textuelles de l'utilisateur vers le système et dos. Étant donné que l'entrée du terminal et la sortie vers le terminal ne peuvent être informations textuelles, alors l'entrée et la sortie des programmes associés au terminal doivent également être du texte. Cependant, la nécessité de fonctionner avec des données textuelles ne limite pas les capacités de gestion du système, mais au contraire les étend. Une personne peut lire le résultat de n’importe quel programme et comprendre ce qui se passe dans le système. différents programmes s'avèrent compatibles les uns avec les autres car ils utilisent le même type de représentation des données - le texte.

Les commandes et les scripts peuvent recevoir des entrées de deux manières : depuis une entrée standard (liée au clavier) ou depuis un fichier. Une séparation similaire existe pour la sortie : la sortie d'une commande ou d'un script est envoyée par défaut à l'écran du terminal, mais vous pouvez la rediriger vers un fichier. Si des erreurs surviennent pendant le fonctionnement. des messages les concernant sont également affichés à l'écran et le flux d'erreurs peut également être redirigé vers un fichier.

Examinons d'abord quelques commandes qui peuvent être utilisées pour organiser les E/S.

Commandes de sortie vers le périphérique de sortie standard

Linux fournit plusieurs commandes pour imprimer les messages sur la sortie standard :

  • echo - Imprime une chaîne sur la sortie standard.
  • printf - Imprime le texte formaté sur la sortie standard.
  • oui - Imprime le texte répété sur la sortie standard.
  • seq - Imprimer une séquence de nombres sur la sortie standard
  • clear Efface l'écran ou la fenêtre.

Par exemple, lorsque vous utilisez la commande echo, si vous spécifiez le caractère de contrôle \c, une fois la sortie terminée, elle n'ira pas à nouvelle ligne:

$ echo "Quel est ton nom ?\c"

Quel est ton nom ?$

Ici, $ est le symbole d'invitation.

La ligne peut également calculer les valeurs des variables shell et même d'autres commandes. Par exemple, la commande suivante vous indique quel est le répertoire personnel de l'utilisateur actuel (la variable d'environnement $HOME) et à quel terminal il est connecté (la commande tty est entourée de guillemets arrière afin que l'interpréteur mette le résultat de son exécution sur un doubler).

$ echo "Votre répertoire personnel est $HOME, vous êtes connecté au terminal - `tty` "

Votre répertoire personnel est /home/knoppix, vous êtes connecté au terminal - /dev/tty1

Parce que double citation Puisqu'ils ont un objectif spécial dans l'interpréteur shell, afin d'inclure des guillemets doubles dans la chaîne de sortie, vous devez annuler leur objectif spécial à l'aide d'une barre oblique inverse (\). Cela annule l'affectation de tout caractère spécial.

Par exemple, pour afficher la chaîne « /dev/tty1 », vous devez exécuter :

$echo "\"/dev/tty1\""

Saisir les commandes de appareil standard saisir

La commande read lit une ligne de l'entrée standard et écrit son contenu dans les variables spécifiées. Lors de la spécification de plusieurs variables, le premier mot est écrit dans la première, le deuxième mot dans la seconde, etc. le dernier contient le reste de la ligne.

Le script suivant appelle une commande de lecture distincte pour lire chaque variable.


$ test de chat
#!/bin/bash
echo "Nom : \c"
lire le nom
echo "Nom de famille : \c"
lire le nom de famille
echo "Prénom =" $nom "Nom =" $nom de famille

Ensuite, pour exécuter ce script, vous devez donner au fichier de test le droit d'exécution : chmod 0755 test et l'exécuter./test. Résultat de l'exécution : Prénom : Ivan Nom de famille : Petrov Prénom=Ivan Nom de famille=Petrov

FLUX D'ENTRÉE, DE SORTIE ET ​​D'ERREURS STANDARD

Chaque programme lancé depuis l'interpréteur de commandes reçoit trois flux d'E/S ouverts :

Entrée standard (sldin) - sortie standard (sldout) - sortie d'erreur standard (stderr)

Par défaut, ces threads sont associés au terminal. Ceux. Tout programme qui n'utilise pas de flux autres que ceux standard attendra la saisie du clavier du terminal ; toutes les sorties de ce programme, y compris les messages d'erreur, se produiront sur l'écran du terminal.

De plus, chaque processus (commande, script, etc.) exécuté dans l'interpréteur shell est associé à un certain nombre de Ouvrir des fichiers, à partir duquel un processus peut lire ses données : et dans lequel il peut les écrire. Chacun de ces fichiers est identifié par un numéro appelé descripteur de fichier, mais les trois premiers fichiers sont les flux d'E/S par défaut :

Descripteur de fichier
Flux d'entrée standard 0
Sortie standard 1
Flux d'erreur standard 2

En réalité, 12 fichiers ouverts sont créés, mais les fichiers avec les descripteurs 0, 1 et 2 sont réservés aux entrées, sorties et erreurs standard. Les utilisateurs peuvent également travailler avec des fichiers comportant les descripteurs de fichiers 3 à 9 (réservés).

Le fichier d'entrée standard (sldin) a le handle 0. À partir de ce fichier, les processus extraient leurs données d'entrée. Par défaut, le flux d'entrée est associé au clavier (périphérique /dev/tty), mais le plus souvent il provient d'un canal provenant d'autres processus ou d'un fichier normal.

Le fichier de sortie standard (stdout) a le handle 1. Toutes les sorties du processus sont écrites dans ce fichier. Par défaut, les données sont affichées sur l'écran du terminal (device/dev/tty), mais elles peuvent également être redirigées vers un fichier ou redirigées vers un autre processus.

Le fichier de flux d'erreurs standard (siderr) a le descripteur 2. Les messages d'erreur qui se produisent lors de l'exécution de la commande sont écrits dans ce fichier. Par défaut, les messages d'erreur sont affichés sur l'écran du terminal (device /dev/tty), mais ils peuvent également être redirigés vers un fichier. Pourquoi allouer la journalisation des erreurs ? fichier spécial? Le fait est que c'est très moyen pratique extraire les données de sortie réelles des résultats de la commande, ainsi que bonne occasion organiser efficacement la maintenance de divers types de fichiers journaux.

Un grand nombre d'utilitaires utilisent uniquement des flux standard. Pour de tels programmes, le shell permet aux flux d'E/S d'être redirigés indépendamment. Par exemple, vous pouvez supprimer les messages d'erreur, définir l'entrée ou la sortie d'un fichier.

Ceux. Lorsque vous appelez des commandes, vous pouvez spécifier où les entrées doivent être reçues et où les sorties doivent être envoyées, ainsi que les messages d'erreur. Par défaut, sauf indication contraire, il est supposé travailler avec un terminal : les données sont saisies au clavier et affichées à l'écran. Mais l'interpréteur shell dispose d'un mécanisme de redirection qui permet d'associer les flux standards à divers fichiers. Dans ce cas, lors de la redirection du flux d'erreurs standard, un descripteur de fichier (2) doit être spécifié. Cela n’est pas nécessaire pour les flux d’entrée et de sortie.

Un cas particulier utile d'utilisation du mécanisme de redirection de thread consiste à rediriger vers /dev/null, ce qui vous permet de vous débarrasser des messages inutiles à l'écran. En utilisant le même mécanisme, vous pouvez créer des fichiers vides :

% cat monfichier - créera dans le répertoire courant fichier vide mon fichier.

/dev/null est un fichier spécial appelé . "appareil vide" L'écriture s'effectue avec succès, quelle que soit la quantité d'informations « enregistrées ». Lire depuis /dev/null équivaut à lire la fin du fichier EOF.

Redirection des flux d'E/S s'effectue, comme DOS (Plus précisément, l'OS DOS a adopté la syntaxe de redirection des flux depuis UNIX) à l'aide des symboles :

- rediriger le flux de sortie standard
- redirection du flux de sortie standard en mode ajout
- rediriger le flux d'entrée standard
- recevoir des données de l'entrée standard jusqu'à ce qu'un délimiteur soit rencontré

Cependant, contrairement au DOS, lors de la création d'un canal de programme entre deux processus, le système d'exploitation UNIX/Linux lance les deux processus simultanément et transfère les informations via le tampon système (sans enregistrement intermédiaire sur le disque dur). Ainsi, les canaux de programme sous UNIX/Linux OS sont très façon efficaceéchange. Si le tampon système déborde (par exemple, si le programme « émetteur » envoie des informations au canal plus rapidement que le programme « récepteur » ne peut les traiter), le système d'exploitation suspend automatiquement le processus qui écrit sur le canal jusqu'à ce que le tampon soit saturé. est libéré.

Opérateurs de redirection les plus courants

N° Syntaxe Description
1 fichier de commandes Dirige la sortie standard vers nouveau fichier

2 commande 1 fichier Dirige la sortie standard vers le fichier spécifié

3 commande file Dirige la sortie standard vers le fichier spécifié (mode attachement)

4 fichier de commandes 2&1 Dirige la sortie standard et l'erreur vers le fichier spécifié

5 commande 2 fichier Dirige l'erreur standard vers le fichier spécifié

6 commande 2 fichier Dirige l'erreur standard vers le fichier spécifié (mode ajout)

7 fichier de commande 2&1 Dirige la sortie standard et l'erreur vers le fichier spécifié (mode attachement)

8 commandes file1 file2 Reçoit les entrées du premier fichier et envoie la sortie au deuxième fichier

9 fichier de commandes comme entrée standard reçoit les données du fichier spécifié

10 commande delimiter Reçoit les données de l'entrée standard jusqu'à ce qu'un délimiteur soit rencontré

11 commande &m Reçoit les données du fichier avec le descripteur m comme entrée standard

12 commande &m Dirige la sortie standard vers le descripteur de fichier m

L'opérateur n&m permet à un fichier de descripteur n d'être redirigé vers le même emplacement qu'un fichier de descripteur m. Il peut y avoir plusieurs opérateurs similaires sur la ligne de commande, auquel cas ils sont calculés de gauche à droite.

commande exec et utilisation des descripteurs de fichiers

La commande exec remplace le shell actuel par la commande spécifiée. Généralement, il est utilisé pour fermer l’interpréteur actuel et en démarrer un autre. Mais il a aussi d’autres usages.

Par exemple, une commande comme

Le fichier Exec fait du fichier spécifié l'entrée standard de toutes les commandes. Effectuez-le dans
le mode interactif ne sert à rien - il est destiné à être utilisé dans des scripts,
afin que toutes les commandes qui suivent lisent leurs données d'entrée à partir du fichier. Dans ce cas
il doit y avoir une commande à la fin du script

Exec & – qui ferme le flux d’entrée standard (dans ce cas un fichier). Une technique similaire est utilisée
principalement dans les scripts qui s'exécutent lorsque vous vous déconnectez.

La commande exec est un pointeur vers un fichier avec le descripteur 0 (stdin). Ce pointeur ne peut être restauré qu'une fois l'exécution du script terminée.
Si le script a l'intention de continuer à lire les données du clavier, vous devez alors enregistrer
pointeur vers le flux d’entrée précédent. Vous trouverez ci-dessous un court script qui montre comment procéder.

$ chat f_desc
#!/bin/bash
fichier exécutable 3&0 0
lire la ligne
lire la ligne 2
exécution 0&3
écho à 1 inel $
écho $line2

La première commande exec stocke un pointeur vers l'entrée standard (stdin) dans le descripteur de fichier 3
(tout entier compris entre 3 et 9 est autorisé) puis s'ouvre fichier fichierà lire. Les deux prochaines commandes de lecture
lire deux lignes de texte à partir d'un fichier. La deuxième commande exec restaure le pointeur sur l'entrée standard : maintenant
il est associé au fichier stdin, pas au fichier. Les commandes d'écho finales affichent le contenu des lignes lues à l'écran,
qui étaient stockés dans les variables linel et Iine2.

Le résultat du script :
$./f_desc
Bonjour!
Au revoir!

Les opérateurs de redirection de commandes sont utilisés pour modifier les emplacements par défaut des flux d’entrée et de sortie de commande vers un autre emplacement. L’emplacement des flux d’entrée et de sortie est appelé un handle.

Le tableau suivant décrit les opérateurs de redirection d’entrée et de sortie de commande.

Opérateur de redirectionDescription
> Écrit le résultat d'une commande au lieu de la ligne de commande dans un fichier ou un périphérique tel qu'une imprimante.
< Lit le flux d'entrée de commande à partir d'un fichier plutôt qu'à partir du clavier.
>> Ajoute le résultat de la commande à la fin du fichier sans supprimer les informations existantes du fichier.
>& Lit la sortie d'un descripteur comme entrée d'un autre descripteur.
<& Lit l’entrée d’un handle comme sortie d’un autre handle.
| Lit la sortie d'une commande et l'écrit dans l'entrée d'une autre commande. Cette procédure est connue sous le nom de canalisation.

Par défaut, l'entrée de commande (poignée STDIN) est envoyée du clavier à l'interpréteur de commandes Cmd.exe, puis Cmd.exe envoie la sortie de commande (poignée STDOUT) à la fenêtre d'invite de commande.

Le tableau suivant montre les descripteurs disponibles.

Les nombres de 0 à 9 représentent les 10 premiers descripteurs. L'interpréteur de commandes Cmd.exe est utilisé pour exécuter le programme et rediriger l'un des 10 handles. Pour spécifier le handle requis, entrez son numéro avant l’opérateur de redirection. Si le handle n'est pas défini, alors par défaut l'opérateur de redirection d'entrée "<» будет ноль (0), а оператором перенаправления вывода «>" sera un (1). Après avoir entré l'opérateur "<» или «>"Il faut indiquer où lire et où écrire les données. Vous pouvez spécifier le nom du fichier ou l'un des descripteurs existants.

Pour spécifier la redirection vers des handles existants, utilisez une esperluette (&) suivie du numéro du handle souhaité (par exemple, & numéro_de_poignée). Par exemple, pour rediriger le handle 2 (STDERR) vers le handle 1 (STDOUT), entrez :

Descripteurs en double

L’opérateur de redirection « & » duplique la sortie ou l’entrée d’un handle spécifié vers un autre handle spécifié. Par exemple, pour envoyer la sortie de la commande dir à File.txt et envoyer la sortie d'erreur à File.txt, tapez :

répertoire>c:\file.txt 2>&1

Lors de la duplication d'un descripteur, toutes ses caractéristiques originales sont copiées. Par exemple, si un handle est en écriture seule, alors tous ses doublons seront en écriture seule. Vous ne pouvez pas dupliquer un handle en lecture seule dans un handle en écriture seule.

Redirection d'entrée de commande (<)

Pour rediriger la saisie du clavier numérique vers un fichier ou un périphérique, utilisez le "<». Например, для ввода команды sort из файла List.txt введите:

trier

Le contenu de File.txt apparaîtra sur la ligne de commande sous forme de liste par ordre alphabétique.

Opérateur "<» открывает заданное имя файла с доступом только для чтения. Поэтому с его помощью нельзя записывать в файл. Например, при запуске программы с оператором <&2 все попытки прочитать дескриптор 0 ни к чему не приведут, так как изначально он был открыт с доступом только для записи.

Note

  • Le handle 0 est la valeur par défaut pour l'opérateur de redirection d'entrée "<».

Sortie de la commande de redirection (>)

Le résultat de presque toutes les commandes est affiché dans la fenêtre d'invite de commande. Même les commandes qui génèrent des données sur un disque ou sur une imprimante génèrent des messages et des invites dans la fenêtre d'invite de commande.

Pour rediriger la sortie des commandes de la fenêtre d'invite de commandes vers un fichier ou un périphérique, utilisez l'opérateur ">". Cet opérateur est utilisé avec la plupart des commandes. Par exemple, pour rediriger la sortie de la commande dir vers le fichier Dirlist.txt, saisissez :

répertoire>listerépertoire.txt

Si le fichier Dirlist.txt n'existe pas, l'interpréteur de commandes Cmd.exe le créera. Si le fichier existe, Cmd.exe remplacera les informations du fichier par les données reçues de la commande dir.

Pour exécuter la commande dump de routage netsh puis en envoyant les résultats de son travail à Route.cfg, saisissez :

dump de routage netsh > c:\route.cfg

L'opérateur ">" ouvre le fichier spécifié avec un accès en écriture seule. Le fichier ne peut donc pas être lu à l'aide de cet opérateur. Par exemple, lors de l'exécution d'un programme avec un opérateur de redirection<&0 все попытки записать дескриптор 1 ни к чему не приведут, так как изначально дескриптор 0 был открыт с доступом только для чтения.

Note.

  • Le handle 1 est la valeur par défaut pour l’opérateur de redirection de sortie « > ».

Utilisation de l'opérateur "<&» для перенаправления ввода и дублирования

Pour utiliser l'opérateur de redirection d'entrée, le fichier spécifié doit déjà exister. Si le fichier d'entrée existe, l'interpréteur de commandes Cmd.exe l'ouvre avec un accès en lecture seule et envoie son contenu à la commande comme s'il s'agissait d'une entrée sur le clavier numérique. Lorsqu’un handle est spécifié, l’interpréteur de commandes Cmd.exe le duplique dans un handle qui existe sur le système.

Par exemple, pour lire File.txt dans le descripteur d'entrée 0 (STDIN), saisissez :

Pour ouvrir un fichier File.txt, trier son contenu, puis l'envoyer vers une fenêtre d'invite de commande (STDOUT), tapez :

trier< file.txt

Pour rechercher File.txt et rediriger le handle 1 (STDOUT) et le handle 2 (STDERR) vers Search.txt, saisissez :

fichier de recherche fichier.txt>search.txt 2<&1

Pour dupliquer le descripteur 3 défini par l'utilisateur comme entrée du descripteur 0 (STDIN), saisissez :

Utilisation de l'opérateur ">&" pour rediriger l'entrée et la dupliquer

Lorsque vous redirigez la sortie vers un fichier et spécifiez un nom de fichier existant, l'interpréteur de commandes Cmd.exe ouvre le fichier avec un accès en écriture seule et écrase son contenu. Si un handle est spécifié, l’interpréteur de commandes Cmd.exe duplique le fichier dans le handle existant.

Pour dupliquer le descripteur 3 défini par l'utilisateur dans le descripteur 1, saisissez :


Pour rediriger toutes les sorties, y compris la sortie du descripteur 2 (STDERR), les commandes ipconfig dans le handle 1 (STDOUT), puis en redirigeant la sortie vers Output.log, entrez :


ipconfig.exe>>output.log 2>&1

Utilisation de l'opérateur ">>" pour ajouter la sortie

Pour ajouter le résultat d'une commande à la fin d'un fichier sans perdre les informations qui y sont stockées, utilisez un caractère double supérieur à (>>). Par exemple, la commande suivante ajoute la liste de répertoires créée par la commande dir, au fichier Dirlist.txt :


rép>>réplist.txt

Pour ajouter une sortie de commande netstatà la fin du fichier Tcpinfo.txt saisissez :


netstat>>tcpinfo.txt

Parfois, il est plus pratique de l'écrire ainsi :

SET OutFile="%~n0.html" > %OutFile% ÉCHO ^ >> %OutFile% ÉCHO ^ >> %OutFile% ÉCHO ^ meilleure page ^>> %OutFile% ÉCHO ^>> %OutFile% ÉCHO ^ >> %OutFile% ECHO Bonjour tout le monde >> %OutFile% ECHO ^>> %OutFile% ÉCHO ^

Utilisation de l'opérateur de chaîne (|)

L'opérateur de canalisation verticale (|) prend la sortie d'une commande (STDOUT par défaut) et la dirige vers l'entrée d'une autre commande (STDIN par défaut). Par exemple, la commande suivante trie un répertoire :

Dans cet exemple, les deux commandes sont exécutées simultanément, mais la commande trier fait une pause jusqu'à ce que le résultat de la commande soit reçu dir. Équipe trier utilise la sortie de la commande dir comme entrée, puis envoie sa sortie au descripteur 1 (STDOUT).

Combinaison de commandes avec des opérateurs de redirection

En combinant des commandes de filtre avec d'autres commandes et noms de fichiers, vous pouvez créer des commandes personnalisées. Par exemple, pour enregistrer les noms de fichiers contenant la chaîne « LOG », utilisez la commande suivante :

rép /b | recherchez "LOG" > loglist.txt

Sortie de commande dir envoyé à la commande filter trouver. Les noms de fichiers contenant la chaîne « LOG » sont stockés dans le fichier Loglist.txt sous forme de liste (par exemple, NetshConfig.log, Logdat.svd et Mylog.bat).

Lorsque vous utilisez plusieurs filtres dans une seule commande, ils doivent être séparés à l’aide d’un tube (|). Par exemple, la commande suivante recherche dans chaque répertoire du lecteur C les fichiers dont le nom contient la chaîne « Journal » et les affiche page par page :

rép c:\ /s /b | trouver "LOG" | plus

La présence d'un tube (|) indique à cmd.exe que la sortie de la commande DIR doit être envoyée à la commande filter trouver. La commande find sélectionne uniquement les noms de fichiers contenant la chaîne « LOG ». La commande more affiche les noms de fichiers obtenus par la commande trouver avec une pause après que chaque écran soit rempli. Pour plus d'informations sur les commandes de filtre, voir

ARTICLES LIÉS