Name: Tremplin Numérique
Price range: $$$

Peu importe que vous appreniez le terminal ou un pro chevronné, il y a toujours beaucoup de petites astuces à apprendre – des volets qui vous font gagner du temps. J'ai trois astuces de bash utiles que vous pouvez ajouter à votre arsenal.

Sommaire

Substitution de processus, pour transformer les données en fichiers de données temporaires

Vous avez probablement rencontré un scénario où vous aviez besoin d'un chemin de fichier comme argument, mais tout ce que vous avez, ce sont des données.

Par exemple, disons que vous vouliez modifier un texte que vous avez déjà dans le terminal:

        echo "foo" | nano

La commande précédente ne fonctionne pas, car vous ne pouvez pas tuer les données dans Nano; Au lieu de cela, vous devez fournir un chemin de fichier, comme ceci: nano /path/to/file.txt.

Pour résoudre ce problème, vous utiliserez probablement une séquence de commandes similaire à ce qui suit:

        echo foo > bar.txt
nano bar.txt

Sur deux commandes distinctes, vous créez un fichier, puis faites quelque chose avec. Cette approche est sous-optimale car elle laisse les fichiers diffusés sur votre système de fichiers, et vous devez également taper le chemin. La substitution du processus résout ce problème:

        echo <(true)

Si vous exécutiez la commande précédente, vous l'avez vu imprimer un chemin de fichier comme ce qui suit:

/dev/fd/16

La substitution de processus génère un fichier temporaire à partir de la sortie d'une commande, permettant à une autre commande de le lire. Ainsi, dans l'exemple précédent, « <(true)" génère le chemin de sortie, et "echo" le reçoit. Les données de la sortie sont tout simplement «vraies».

La partie « FD » du chemin fait référence au terme « Descripteur de fichiers », qui n'est qu'un identifiant que les logiciels utilisent en interne pour désigner les fichiers ouverts. Cet exemple a un descripteur de fichiers de 16. Les descripteurs de fichiers sont privés dans les processus qui les utilisent – qui est « Echo » dans ce cas.

Utilisons une substitution de processus de manière utile:

        nano <(echo "foo")

La commande précédente est la même que la saisie des éléments suivants:

        echo "foo" > /tmp/foo
nano /tmp/foo

Vous ne pourrez pas enregistrer et modifier le texte lors de l'exécution nano <(écho "foo") Parce que le fichier spécialement créé est en lecture seule, mais vous pouvez changer où vous l'enregistrez avec le raccourci Ctrl + O.

Substitution du processus d'entrée / sortie

L'expression « <(foo)" crée un saisir substitution de processus. Alternativement, vous pouvez également créer un sortir Substitution du processus:

        echo "foo" > >(cat)

La commande précédente est la même que la saisie des éléments suivants:

        echo "foo" > /tmp/foo
cat /tmp/foo

Bien que les deux commandes puissent apparaître différentes, elles fonctionnent de la même manière. Cela devient plus clair une fois que vous comprenez que écho « foo » >> (chat) Écrit « Foo » dans un fichier spécial, dont la commande CAT lit ensuite.

Donc, pour résumer:

écho <(vrai) est un saisir Substitution de processus et Echo reçoit les données via un chemin de fichier spécial (dans ce cas, les données sont uniquement « vraies »).
écho « foo » >> (chat) est un sortir substitution du processus et CAT reçoit le mot écho via un chemin spécial. Le premier caractère « > » est l'opérateur de redirection, et le second fait partie de l'expression de substitution elle-même.

Pour terminer cette section, je pense qu'un véritable exemple le liera bien:

        diff <(ls -1 ~) <(ls -1 /tmp)

Cette commande comparera les différences entre deux répertoires. Une substitution de processus d'entrée est utile dans ce cas car Diff s'attend à des chemins de fichier, et c'est ce que les substitutions de processus fournissent.

Le drapeau « LS -1 » est un seul, pas la lettre l.

Expansion de l'histoire pour répéter les commandes

Les développeurs de bash aiment utiliser souvent le terme «expansion». Cela semble compliqué, mais cela signifie simplement changer une petite chose en quelque chose de plus grand – pour l'étendre. L'exemple le plus célèbre est l'expansion de Tilde (~), qui se développe dans un chemin pour votre répertoire domestique.

Les trois exemples suivants sont tous appelés extensions de l'histoire. Ces expressions se développent toutes des entrées de caractères simples dans les éléments de l'historique de votre coquille.

Bang, bang !!

C'est l'une de mes commandes les plus utilisées après CD et LS. C'est simple à utiliser et à comprendre. Il réinstalle la dernière commande que vous avez exécutée.

        ls
!!

Vous pouvez voir dans la sortie de commande que la commande LS exécute deux fois.

Développez un élément spécifique dans votre historique

Tout d'abord, regardez votre histoire pour choisir une commande appropriée:

        history

Ensuite, choisissez simplement l'un des nombres à gauche et insérez-le comme n:

!N

Vérifiez la commande avant de la réexécuter, car si vous exécutez accidentellement la mauvaise commande, vous aurez une mauvaise journée.

La meilleure chose à propos de l'élargissement de ces éléments d'historique numérotés est que leurs chiffres restent cohérents, ce qui vous permet de vous familiariser avec eux. Bien sûr, cette familiarité ne dure que jusqu'à ce que vous supprimez votre fichier ~ / .bash_history.

Se développer par son nom, pour une sélection plus facile

La recherche de l'historique de votre commandement souvent et la localisation d'une commande numérotée spécifique peut devenir fastidieuse. Une approche alternative et plus efficace existe: Bash vous permet de taper partiellement le début d'une commande, et il exécutera le match le plus récent.

        echo foo
!e
!ech

Ceci est parfait lors de l'alternance entre plusieurs commandes lors d'une seule session terminale. Cependant, pour les commandes à long terme (beaucoup plus anciennes), je préfère utiliser un outil de recherche d'historique floue à la place.

Groupes de commandement

Parfois, vous voudrez exécuter un certain nombre de commandes en groupe, mais traitez leur sortie comme un résultat. Considérez l'exemple suivant:

        echo foo > /tmp/foo.txt
echo bar >> /tmp/foo.txt

Le caractère « > » est appelé l'opérateur de redirection, et il envoie la sortie de commande au fichier spécifié, écrasant le contenu; « >> » fait de même, sauf qu'il ajoute au fichier – ajouter Opérateur de redirection.

La commande précédente créera un fichier qui ressemble:

foo
bar

Parfois, lorsque vos commandes sont plus complexes, l'utilisation d'une telle approche peut être laide en raison de nombreuses lignes inutiles. L'approche plus simple consiste à utiliser un groupe de commandes.

Un groupe de commandes fusionne toutes les sorties de ses commandes en une seule. Cela rend le traitement le résultat beaucoup plus simple.

        { echo foo; echo bar; } > /tmp/foo.txt

Cela entraînera la même sortie que la commande précédente. La redirection ne doit pas se produire une seule fois, il n'y a donc pas de usage pour l'opérateur de redirection d'ajout (>>).

Un point-virgule après chaque commande est requise, en particulier la commande finale. Des espaces entre les supports et les mots de commande sont également nécessaires.

Vous pouvez prouver que les commandes en dehors du groupe ne s'exécutent qu'une seule fois en exécutant la séquence de commandes suivante:

        { echo "A"; echo "B"; } | wc -l

Le groupe de commandes envoie les deux sorties ECHO en tant que flux unique. C'est pourquoi « WC » compte les deux lignes ensemble comme un seul message et affiche 2; Sinon, il afficherait 1 sur deux lignes distinctes.

Un exemple de cas d'utilisation du monde réel:

        { ping -c 1 example.com; ping -c 1 example.net; } > /tmp/ping.txt

En résumé:

La substitution du processus remplace un processus par un chemin de fichier temporaire. Par exemple, nano <(écho "foo") et écho « foo » >> (chat).
Les extensions de l'historique des coquilles sont des caractères spéciaux qui font référence à vos éléments d'historique bash. Par exemple, ! foo, ! N ou !!.
Un groupe de commandes unifie les sorties de plusieurs commandes en un seul résultat. Par exemple, {echo « foo »; écho « bar »; }> /tmp/foo.txt.

Tout couvert ne fait que gratter la surface de ce que Bash a à offrir. Si les expansions de l'histoire de Shell vous plaisent, vous allez adorer notre tutoriel sur la façon d'utiliser la commande historique. Vous pouvez également être intéressé par des astuces qui facilitent l'apprentissage de la ligne de commande.