Note de l'auteur : Une grande partie du contenu de cet article est extrait, avec quelques modifications importantes pour s'adapter au format d'article Opensource.com, du chapitre 3 :Flux de données, de mon nouveau livre, The Linux Philosophy for SysAdmins.
Tout dans Linux tourne autour de flux de données, en particulier de flux de texte. Les flux de données sont les matières premières sur lesquelles les utilitaires GNU, les utilitaires principaux de Linux et de nombreux autres outils de ligne de commande effectuent leur travail.
Comme son nom l'indique, un flux de données est un flux de données, en particulier de données textuelles, transmis d'un fichier, d'un périphérique ou d'un programme à un autre à l'aide de STDIO. Ce chapitre présente l'utilisation de canaux pour connecter des flux de données d'un programme utilitaire à un autre à l'aide de STDIO. Vous apprendrez que la fonction de ces programmes est de transformer les données d'une certaine manière. Vous découvrirez également l'utilisation de la redirection pour rediriger les données vers un fichier.
Le Terminal Linux
- Les 7 meilleurs émulateurs de terminaux pour Linux
- 10 outils de ligne de commande pour l'analyse de données sous Linux
- Télécharger maintenant :Aide-mémoire SSH
- Aide-mémoire des commandes Linux avancées
- Tutoriels de ligne de commande Linux
J'utilise le terme "transformer" en conjonction avec ces programmes car la tâche principale de chacun est de transformer les données entrantes de STDIO d'une manière spécifique comme prévu par l'administrateur système et d'envoyer les données transformées à STDOUT pour une utilisation éventuelle par un autre programme de transformation ou redirection vers un fichier.
Le terme standard, "filtres", implique quelque chose avec lequel je ne suis pas d'accord. Par définition, un filtre est un appareil ou un outil qui élimine quelque chose, comme un filtre à air qui élimine les contaminants en suspension dans l'air afin que le moteur à combustion interne de votre automobile ne se mette pas à mort sur ces particules. Dans mes cours de chimie au lycée et au collège, le papier filtre était utilisé pour éliminer les particules d'un liquide. Le filtre à air de mon système CVC domestique élimine les particules que je ne veux pas respirer.
Bien qu'ils filtrent parfois les données indésirables d'un flux, je préfère de loin le terme "transformateurs" car ces utilitaires font bien plus. Ils peuvent ajouter des données à un flux, modifier les données de manière étonnante, les trier, réorganiser les données dans chaque ligne, effectuer des opérations basées sur le contenu du flux de données, et bien plus encore. N'hésitez pas à utiliser le terme que vous préférez, mais je préfère les transformateurs. Je m'attends à être seul dans ce cas.
Les flux de données peuvent être manipulés en insérant des transformateurs dans le flux à l'aide de canaux. Chaque programme de transformation est utilisé par l'administrateur système pour effectuer certaines opérations sur les données du flux, modifiant ainsi son contenu d'une manière ou d'une autre. La redirection peut ensuite être utilisée à la fin du pipeline pour diriger le flux de données vers un fichier. Comme mentionné, ce fichier peut être un fichier de données réel sur le disque dur ou un fichier de périphérique tel qu'une partition de lecteur, une imprimante, un terminal, un pseudo-terminal ou tout autre périphérique connecté à un ordinateur.
La capacité de manipuler ces flux de données à l'aide de ces programmes de transformation petits mais puissants est au cœur de la puissance de l'interface de ligne de commande Linux. De nombreux utilitaires de base sont des programmes de transformation et utilisent STDIO.
Dans les mondes Unix et Linux, un flux est un flux de données textuelles provenant d'une source; le flux peut circuler vers un ou plusieurs programmes qui le transforment d'une manière ou d'une autre, puis il peut être stocké dans un fichier ou affiché dans une session de terminal. En tant qu'administrateur système, votre travail est intimement lié à la manipulation de la création et du flux de ces flux de données. Dans cet article, nous allons explorer les flux de données :ce qu'ils sont, comment les créer et un peu comment les utiliser.
Flux de texte :une interface universelle
L'utilisation de l'entrée/sortie standard (STDIO) pour l'entrée et la sortie du programme est un fondement essentiel de la façon de faire de Linux. STDIO a d'abord été développé pour Unix et a depuis trouvé sa place dans la plupart des autres systèmes d'exploitation, y compris DOS, Windows et Linux.
« C'est la philosophie d'Unix :écrire des programmes qui font une chose et le font bien. Écrivez des programmes pour travailler ensemble. Écrivez des programmes pour gérer les flux de texte, car il s'agit d'une interface universelle. »
— Doug McIlroy, Bases de la philosophie Unix
STDIO
STDIO a été développé par Ken Thompson dans le cadre de l'infrastructure requise pour implémenter des canaux sur les premières versions d'Unix. Les programmes qui implémentent STDIO utilisent des descripteurs de fichiers standardisés pour l'entrée et la sortie plutôt que des fichiers stockés sur un disque ou un autre support d'enregistrement. STDIO est mieux décrit comme un flux de données mis en mémoire tampon, et sa fonction principale est de diffuser des données depuis la sortie d'un programme, fichier ou périphérique vers l'entrée d'un autre programme, fichier ou périphérique.
Il existe trois flux de données STDIO, dont chacun est automatiquement ouvert en tant que fichier au démarrage d'un programme - enfin, les programmes qui utilisent STDIO. Chaque flux de données STDIO est associé à un descripteur de fichier, qui n'est qu'un ensemble de métadonnées décrivant les attributs du fichier. Les descripteurs de fichiers 0, 1 et 2 sont explicitement définis par convention et comme longue pratique comme STDIN, STDOUT et STDERR, respectivement.
STDIN, descripteur de fichier 0 , est une entrée standard qui est généralement saisie à partir du clavier. STDIN peut être redirigé depuis n'importe quel fichier, y compris les fichiers de périphérique, au lieu du clavier. Il n'est pas courant d'avoir besoin de rediriger STDIN, mais cela peut être fait.
STDOUT, descripteur de fichier 1 , est la sortie standard qui envoie le flux de données à l'affichage par défaut. Il est courant de rediriger STDOUT vers un fichier ou de le rediriger vers un autre programme pour un traitement ultérieur.
STDERR, Descripteur de fichier 2 . Le flux de données pour STDERR est également généralement envoyé à l'écran.
Si STDOUT est redirigé vers un fichier, STDERR continue de s'afficher à l'écran. Cela garantit que lorsque le flux de données lui-même n'est pas affiché sur le terminal, c'est STDERR qui l'est, garantissant ainsi que l'utilisateur verra toutes les erreurs résultant de l'exécution du programme. STDERR peut également être redirigé vers le même programme de transformation ou transmis au programme de transformation suivant dans un pipeline.
STDIO est implémenté en tant que bibliothèque C, stdio.h , qui peut être inclus dans le code source des programmes afin qu'il puisse être compilé dans l'exécutable résultant.
Flux simples
Vous pouvez effectuer les expériences suivantes en toute sécurité dans le fichier /tmp répertoire de votre hôte Linux. En tant qu'utilisateur root, créez /tmp le PWD, créez un répertoire de test, puis faites du nouveau répertoire le PWD.
# cd /tmp ; mkdir test ; cd test
Entrez et exécutez le programme de ligne de commande suivant pour créer des fichiers avec du contenu sur le lecteur. Nous utilisons le dmesg commande simplement pour fournir des données pour les fichiers à contenir. Le contenu n'a pas autant d'importance que le fait que chaque fichier a du contenu.
# for I in 0 1 2 3 4 5 6 7 8 9 ; do dmesg > file$I.txt ; done Vérifiez qu'il y a maintenant au moins 10 fichiers dans /tmp/ avec les noms file0.txt via file9.txt .
# ll
total 1320
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file0.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file1.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file2.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file3.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file4.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file5.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file6.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file7.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file8.txt
-rw-r--r-- 1 root root 131402 Oct 17 15:50 file9.txt
Nous avons généré des flux de données en utilisant le dmesg commande, qui a été redirigée vers une série de fichiers. La plupart des utilitaires principaux utilisent STDIO comme flux de sortie et ceux qui génèrent des flux de données, plutôt que d'agir pour transformer le flux de données d'une manière ou d'une autre, peuvent être utilisés pour créer les flux de données que nous utiliserons pour nos expériences. Les flux de données peuvent être aussi courts qu'une ligne ou même un seul caractère, et aussi longs que nécessaire.
Exploration du disque dur
Il est maintenant temps de faire un peu d'exploration. Dans cette expérience, nous examinerons certaines des structures du système de fichiers.
Commençons par quelque chose de simple. Vous devriez être au moins un peu familier avec le dd commande. Officiellement connu sous le nom de "vidage de disque", de nombreux administrateurs système l'appellent "destructeur de disque" pour une bonne raison. Beaucoup d'entre nous ont détruit par inadvertance le contenu d'un disque dur entier ou d'une partition en utilisant le dd commande. C'est pourquoi nous allons traîner dans le /tmp/test répertoire pour effectuer certaines de ces expériences.
Malgré sa réputation, dd peut être très utile pour explorer divers types de supports de stockage, de disques durs et de partitions. Nous l'utiliserons également comme outil pour explorer d'autres aspects de Linux.
Connectez-vous à une session de terminal en tant que root si vous ne l'êtes pas déjà. Nous devons d'abord déterminer le fichier spécial de périphérique pour votre disque dur en utilisant le lsblk commande.
[root@studentvm1 test]# lsblk -i
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 60G 0 disk
|-sda1 8:1 0 1G 0 part /boot
`-sda2 8:2 0 59G 0 part
|-fedora_studentvm1-pool00_tmeta 253:0 0 4M 0 lvm
| `-fedora_studentvm1-pool00-tpool 253:2 0 2G 0 lvm
| |-fedora_studentvm1-root 253:3 0 2G 0 lvm /
| `-fedora_studentvm1-pool00 253:6 0 2G 0 lvm
|-fedora_studentvm1-pool00_tdata 253:1 0 2G 0 lvm
| `-fedora_studentvm1-pool00-tpool 253:2 0 2G 0 lvm
| |-fedora_studentvm1-root 253:3 0 2G 0 lvm /
| `-fedora_studentvm1-pool00 253:6 0 2G 0 lvm
|-fedora_studentvm1-swap 253:4 0 10G 0 lvm [SWAP]
|-fedora_studentvm1-usr 253:5 0 15G 0 lvm /usr
|-fedora_studentvm1-home 253:7 0 2G 0 lvm /home
|-fedora_studentvm1-var 253:8 0 10G 0 lvm /var
`-fedora_studentvm1-tmp 253:9 0 5G 0 lvm /tmp
sr0 11:0 1 1024M 0 rom
Nous pouvons voir à partir de cela qu'il n'y a qu'un seul disque dur sur cet hôte, que le fichier spécial de périphérique qui lui est associé est /dev/sda , et qu'il a deux partitions. Le /dev/sda1 partition est la partition de démarrage, et le /dev/sda2 partition contient un groupe de volumes sur lequel le reste des volumes logiques de l'hôte ont été créés.
En tant que root dans la session du terminal, utilisez le dd commande pour afficher l'enregistrement de démarrage du disque dur, en supposant qu'il est attribué à /dev/sda appareil. Le bs= l'argument n'est pas ce que vous pourriez penser; il spécifie simplement la taille du bloc et le count= L'argument spécifie le nombre de blocs à vider dans STDIO. Le if= l'argument spécifie la source du flux de données, dans ce cas, le /dev/sda appareil. Notez que nous ne regardons pas le premier bloc de la partition, nous regardons le tout premier bloc du disque dur.
[root@studentvm1 test]# dd if=/dev/sda bs=512 count=1
�c�#�м���؎���|�#�#���!#��8#u
��#���u��#�#�#�|���t#�L#�#�|���#�����t��pt#���y|1��؎м ��d|<�t#��R�|1��D#@�D��D#�##f�#\|f�f�#`|f�\
�D#p�B�#r�p�#�K`#�#��1��������#a`���#f��u#����f1�f�TCPAf�#f�#a�&Z|�#}�#�.}�4�3}�.�#��GRUB GeomHard DiskRead Error
�#��#�<u��ܻޮ�###��� ������ �_U�1+0 records in
1+0 records out
512 bytes copied, 4.3856e-05 s, 11.7 MB/s
Cela imprime le texte de l'enregistrement de démarrage, qui est le premier bloc sur le disque, n'importe quel disque. Dans ce cas, il y a des informations sur le système de fichiers et, bien qu'il soit illisible car stocké au format binaire, la table de partition. S'il s'agissait d'un périphérique amorçable, l'étape 1 de GRUB ou d'un autre chargeur de démarrage serait située dans ce secteur. Les trois dernières lignes contiennent des données sur le nombre d'enregistrements et d'octets traités.
En commençant par le début de /dev/sda1 , examinons quelques blocs de données à la fois pour trouver ce que nous voulons. La commande est similaire à la précédente, sauf que nous avons spécifié quelques blocs de données supplémentaires à afficher. Vous devrez peut-être spécifier moins de blocs si votre terminal n'est pas assez grand pour afficher toutes les données en même temps, ou vous pouvez diriger les données via l'utilitaire le moins et l'utiliser pour parcourir les données, dans les deux cas. N'oubliez pas que nous faisons tout cela en tant qu'utilisateur root car les utilisateurs non root ne disposent pas des autorisations requises.
Entrez la même commande que dans l'expérience précédente, mais augmentez le nombre de blocs à afficher à 100, comme indiqué ci-dessous, afin d'afficher plus de données.
[root@studentvm1 test]# dd if=/dev/sda1 bs=512 count=100
##33��#:�##�� :o�[:o�[#��S�###�q[#
#<�#{5OZh�GJ͞#t�Ұ##boot/bootysimage/booC�dp��G'�*)�#A�##@
#�q[
�## ## ###�#���To=###<#8���#'#�###�#�����#�' �����#Xi �#��` qT���
<���
� r���� ]�#�#�##�##�##�#�##�##�##�#�##�##�#��#�#�##�#�##�##�#��#�#����# � �# �# �#
�
�#
�#
�#
�
�#
�#
�#
�
�#
�#
�#100+0 records in
100+0 records out
51200 bytes (51 kB, 50 KiB) copied, 0.00117615 s, 43.5 MB/s
Essayez maintenant cette commande. Je ne reproduirai pas l'intégralité du flux de données ici car cela prendrait énormément d'espace. Utilisez Ctrl-C pour éclater et arrêter le flux de données.
[root@studentvm1 test]# dd if=/dev/sdaCette commande produit un flux de données qui est le contenu complet du disque dur, /dev/sda , y compris l'enregistrement de démarrage, la table de partition et toutes les partitions et leur contenu. Ces données pourraient être redirigées vers un fichier pour être utilisées comme une sauvegarde complète à partir de laquelle une restauration à chaud peut être effectuée. Il pourrait également être envoyé directement sur un autre disque dur pour cloner le premier. Mais n'effectuez pas cette expérience particulière.
[root@studentvm1 test]# dd if=/dev/sda of=/dev/sdx
Vous pouvez voir que le dd La commande peut être très utile pour explorer les structures de divers types de systèmes de fichiers, localiser des données sur un périphérique de stockage défectueux, et bien plus encore. Il produit également un flux de données sur lequel nous pouvons utiliser les utilitaires de transformation afin de modifier ou de visualiser.
Le vrai point ici est que dd , comme de nombreuses commandes Linux, produit un flux de données en sortie. Ce flux de données peut être recherché et manipulé de plusieurs façons à l'aide d'autres outils. Il peut même être utilisé pour des sauvegardes fantômes ou des duplications de disque.
Aléatoire
Il s'avère que le hasard est une chose souhaitable dans les ordinateurs - qui savait ? Il existe un certain nombre de raisons pour lesquelles les administrateurs système peuvent vouloir générer un flux de données aléatoires. Un flux de données aléatoires est parfois utile pour écraser le contenu d'une partition complète, telle que /dev/sda1 , ou même l'intégralité du disque dur, comme dans /dev/sda .
Effectuez cette expérience en tant qu'utilisateur non root. Entrez cette commande pour imprimer un flux sans fin de données aléatoires sur STDIO.
[student@studentvm1 ~]$ cat /dev/urandomUtilisez Ctrl-C pour briser et arrêter le flux de données. Vous devrez peut-être utiliser Ctrl-C plusieurs fois.
Les données aléatoires sont également utilisées comme source d'entrée pour les programmes qui génèrent des mots de passe aléatoires ainsi que des données et des nombres aléatoires à utiliser dans les calculs scientifiques et statistiques. J'aborderai le caractère aléatoire et d'autres sources de données intéressantes un peu plus en détail au chapitre 24 :Tout est un fichier.
Rêves illusoires
Les tubes sont essentiels à notre capacité à faire des choses incroyables sur la ligne de commande, à tel point que je pense qu'il est important de reconnaître qu'ils ont été inventés par Douglas McIlroy au début d'Unix (merci, Doug !). Le site Web de l'Université de Princeton contient un extrait d'une interview de McIlroy dans laquelle il discute de la création du tube et des débuts de la philosophie Unix.
Remarquez l'utilisation de canaux dans le programme de ligne de commande simple illustré ci-dessous, qui répertorie chaque utilisateur connecté une seule fois, quel que soit le nombre de connexions actives. Effectuez cette expérience en tant qu'utilisateur étudiant. Entrez la commande ci-dessous :
[student@studentvm1 ~]$ w | tail -n +3 | awk '{print $1}' | sort | uniq
root
student
[student@studentvm1 ~]$ Les résultats de cette commande produisent deux lignes de données qui montrent que la racine et l'étudiant de l'utilisateur sont tous deux connectés. Il n'indique pas combien de fois chaque utilisateur est connecté. Vos résultats seront presque certainement différents des miens.
Les tubes, représentés par la barre verticale ( | ), sont le ciment syntaxique, l'opérateur, qui relie ces utilitaires de ligne de commande. Les tubes permettent à la sortie standard d'une commande d'être "canalisée", c'est-à-dire diffusée de la sortie standard d'une commande vers l'entrée standard de la commande suivante.
L'opérateur |&peut être utilisé pour diriger le STDERR avec STDOUT vers STDIN de la commande suivante. Ce n'est pas toujours souhaitable, mais cela offre une flexibilité dans la capacité d'enregistrer le flux de données STDERR à des fins de détermination du problème.
Une chaîne de programmes connectés à des canaux s'appelle un pipeline, et les programmes qui utilisent STDIO sont officiellement appelés filtres, mais je préfère le terme "transformateurs".
Pensez à la façon dont ce programme devrait fonctionner si nous ne pouvions pas diriger le flux de données d'une commande à l'autre. La première commande effectuerait sa tâche sur les données, puis la sortie de cette commande devrait être enregistrée dans un fichier. La commande suivante devrait lire le flux de données à partir du fichier intermédiaire et effectuer sa modification du flux de données, en envoyant sa propre sortie à un nouveau fichier de données temporaire. La troisième commande devrait prendre ses données du deuxième fichier de données temporaire et effectuer sa propre manipulation du flux de données, puis stocker le flux de données résultant dans encore un autre fichier temporaire. À chaque étape, les noms des fichiers de données devraient être transférés d'une commande à l'autre d'une manière ou d'une autre.
Je ne supporte même pas d'y penser parce que c'est tellement complexe. N'oubliez pas :la simplicité est géniale !
Construire des pipelines
Lorsque je fais quelque chose de nouveau, que je résous un nouveau problème, je ne me contente généralement pas de taper un pipeline de commandes Bash complet à partir de rien. Je commence généralement avec seulement une ou deux commandes dans le pipeline et je construis à partir de là en ajoutant plus de commandes pour traiter davantage le flux de données. Cela me permet de visualiser l'état du flux de données après chacune des commandes du pipeline et d'apporter les corrections nécessaires.
Il est possible de créer des pipelines très complexes qui peuvent transformer le flux de données à l'aide de nombreux utilitaires différents qui fonctionnent avec STDIO.
Redirection
La redirection est la capacité de rediriger le flux de données STDOUT d'un programme vers un fichier au lieu de la cible par défaut de l'affichage. Le caractère "supérieur à" (> ), alias "gt", est le symbole syntaxique de redirection de STDOUT.
La redirection du STDOUT d'une commande peut être utilisée pour créer un fichier contenant les résultats de cette commande.
[student@studentvm1 ~]$ df -h > diskusage.txtIl n'y a pas de sortie vers le terminal à partir de cette commande sauf en cas d'erreur. En effet, le flux de données STDOUT est redirigé vers le fichier et STDERR est toujours dirigé vers le périphérique STDOUT, qui est l'affichage. Vous pouvez afficher le contenu du fichier que vous venez de créer à l'aide de la commande suivante :
[student@studentvm1 test]# cat diskusage.txt
Filesystem Size Used Avail Use% Mounted on
devtmpfs 2.0G 0 2.0G 0% /dev
tmpfs 2.0G 0 2.0G 0% /dev/shm
tmpfs 2.0G 1.2M 2.0G 1% /run
tmpfs 2.0G 0 2.0G 0% /sys/fs/cgroup
/dev/mapper/fedora_studentvm1-root 2.0G 50M 1.8G 3% /
/dev/mapper/fedora_studentvm1-usr 15G 4.5G 9.5G 33% /usr
/dev/mapper/fedora_studentvm1-var 9.8G 1.1G 8.2G 12% /var
/dev/mapper/fedora_studentvm1-tmp 4.9G 21M 4.6G 1% /tmp
/dev/mapper/fedora_studentvm1-home 2.0G 7.2M 1.8G 1% /home
/dev/sda1 976M 221M 689M 25% /boot
tmpfs 395M 0 395M 0% /run/user/0
tmpfs 395M 12K 395M 1% /run/user/1000
Lorsque vous utilisez le symbole> pour rediriger le flux de données, le fichier spécifié est créé s'il n'existe pas déjà. S'il existe, le contenu est écrasé par le flux de données de la commande. Vous pouvez utiliser des symboles double supérieur à,>>, pour ajouter le nouveau flux de données à tout contenu existant dans le fichier.
[student@studentvm1 ~]$ df -h >> diskusage.txt
Vous pouvez utiliser cat et/ou less pour afficher le fichier diskusage.txt fichier afin de vérifier que les nouvelles données ont été ajoutées à la fin du fichier.
Le symbole <(inférieur à) redirige les données vers le STDIN du programme. Vous pouvez utiliser cette méthode pour entrer des données d'un fichier dans STDIN d'une commande qui ne prend pas de nom de fichier comme argument mais qui utilise STDIN. Bien que les sources d'entrée puissent être redirigées vers STDIN, comme un fichier utilisé comme entrée pour grep, cela n'est généralement pas nécessaire car grep prend également un nom de fichier comme argument pour spécifier la source d'entrée. La plupart des autres commandes prennent également un nom de fichier comme argument pour leur source d'entrée.
Je fais juste le tour
Le grep La commande est utilisée pour sélectionner des lignes qui correspondent à un modèle spécifié à partir d'un flux de données. grep est l'un des utilitaires de transformation les plus couramment utilisés et peut être utilisé de manière très créative et intéressante. Le grep La commande est l'une des rares à pouvoir être correctement appelée filtre car elle filtre toutes les lignes du flux de données que vous ne voulez pas ; il ne laisse que les lignes que vous voulez dans le flux de données restant.
Si le PWD n'est pas le /tmp/test répertoire, faites en sorte qu'il en soit ainsi. Commençons par créer un flux de données aléatoires à stocker dans un fichier. Dans ce cas, nous voulons des données un peu moins aléatoires qui seraient limitées aux caractères imprimables. Un bon programme générateur de mot de passe peut le faire. Le programme suivant (vous devrez peut-être installer pwgen s'il ne l'est pas déjà) crée un fichier contenant 50 000 mots de passe de 80 caractères en utilisant chaque caractère imprimable. Essayez-le sans rediriger vers le random.txt fichier d'abord pour voir à quoi cela ressemble, puis faites-le une fois redirigé le flux de données de sortie vers le fichier.
$ pwgen -sy 80 50000 > random.txt
Considérant qu'il y a tellement de mots de passe, il est très probable que certaines chaînes de caractères soient identiques. D'abord, cat le random.txt fichier, puis utilisez le grep commande pour localiser des chaînes courtes sélectionnées au hasard parmi les dix derniers mots de passe à l'écran. J'ai vu le mot "voir" dans l'un de ces dix mots de passe, donc ma commande ressemblait à ceci :grep see random.txt , et vous pouvez essayer cela, mais vous devez également choisir vous-même certaines chaînes à vérifier. Les chaînes courtes de deux à quatre caractères fonctionnent mieux.
$ grep see random.txt
R=p)'s/~0}wr~2(OqaL.S7DNyxlmO69`"12u]h@rp[D2%3}1b87+>Vk,;4a0hX]d7see;1%9|wMp6Yl.
bSM_mt_hPy|YZ1<TY/Hu5{g#mQ<u_(@8B5Vt?w%i-&C>NU@[;zV2-see)>(BSK~n5mmb9~h)yx{a&$_e
cjR1QWZwEgl48[3i-(^x9D=v)seeYT2R#M:>wDh?Tn$]HZU7}j!7bIiIr^cI.DI)W0D"'[email protected]
z=tXcjVv^G\nW`,y=bED]d|7%s6iYT^a^Bvsee:v\UmWT02|P|nq%A*;+Ng[$S%*s)-ls"dUfo|0P5+n
Résumé
C'est l'utilisation de canaux et de redirection qui permet de nombreuses tâches incroyables et puissantes qui peuvent être effectuées avec des flux de données sur la ligne de commande Linux. Ce sont des canaux qui transportent les flux de données STDIO d'un programme ou d'un fichier à un autre. La possibilité de diriger des flux de données via un ou plusieurs programmes de transformation permet une manipulation puissante et flexible des données dans ces flux.
Chacun des programmes dans les pipelines démontrés dans les expériences est petit, et chacun fait bien une chose. Ce sont aussi des transformateurs; c'est-à-dire qu'ils prennent l'entrée standard, la traitent d'une manière ou d'une autre, puis envoient le résultat à la sortie standard. L'implémentation de ces programmes en tant que transformateurs pour envoyer des flux de données traités de leur propre sortie standard à l'entrée standard des autres programmes est complémentaire et nécessaire pour l'implémentation des tubes en tant qu'outil Linux.
STDIO n'est rien de plus que des flux de données. Ces données peuvent être presque n'importe quoi, de la sortie d'une commande pour répertorier les fichiers dans un répertoire, ou un flux de données sans fin provenant d'un périphérique spécial comme /dev/urandom , ou même un flux contenant toutes les données brutes d'un disque dur ou d'une partition.
Tout périphérique sur un ordinateur Linux peut être traité comme un flux de données. Vous pouvez utiliser des outils ordinaires comme dd et cat pour vider les données d'un appareil dans un flux de données STDIO qui peut être traité à l'aide d'autres outils Linux ordinaires.