[LINUX] Notions de base UNIX (deuxième partie)

À propos de cet article

Ceci est un résumé des bases des ordinateurs personnels UNIX. Si vous lisez cet article et le comprenez correctement, vous aurez une bonne compréhension d'UNIX. Veuillez cliquer sur le lien ci-dessous pour la première partie.

Notions de base UNIX (première partie) https://qiita.com/minnsou/items/6b6b74fcd79bd00ace1a

Cadre environnemental

Comment mettre en place l'environnement

Les shells utilisés sous UNIX (sh, csh, bash, etc.) peuvent être personnalisés. Il existe deux manières principales de personnaliser les commandes.

1. Méthode par fichier de configuration Un fichier de paramètres est un fichier qui décrit les paramètres d'une commande. En règle générale, une commande qui utilise un fichier de paramètres lit d'abord le contenu du fichier de paramètres lors de son démarrage et modifie son fonctionnement en fonction de la description. Par exemple, utilisez «.profile» pour sh et «.bash_profile» ou «.bashrc» pour bash. Cela dépend de la coque.
2. Méthode par variable d'environnement Les variables d'environnement sont utilisées en définissant des valeurs dans les variables. Lorsque la commande est appelée, elle vérifie la valeur de la variable d'environnement selon les besoins et change son comportement en fonction de la valeur définie. Les variables d'environnement sont généralement définies dans le fichier de paramètres.

Shell interactif et shell non interactif

Il existe deux types de démarrage du shell: __interactif __ et __ non interactif __. L'interactif est une forme de répétition de tâches telles que «lorsqu'un humain fait une demande, l'ordinateur la traite». Non-interactif est une forme dans laquelle tout le contenu du traitement est décrit dans un fichier ou quelque chose à l'avance, et l'ordinateur lit le contenu et le traite. Notez qu'un fichier de configuration qui peut être lu par un shell non interactif, tel que le fichier de configuration csh .cshrc, entraînera généralement une erreur lors de l'affichage d'un message ou de la configuration du terminal. Pour csh, vous devez utiliser la variable shell $ prompt pour séparer les cas.

Variables de shell et variables d'environnement

Dans le fichier de paramètres du shell, définissez les variables du shell, les variables d'environnement, les alias, etc. __ La variable shell __ est une variable unique au shell. Certaines de ces variables ont une signification particulière et vous pouvez modifier le comportement du shell en définissant de telles variables. La variable __environment __ est une variable appartenant à tous les processus utilisés sous UNIX, pas au shell. Lorsqu'un autre processus est créé à partir d'un processus, le processus nouvellement créé hérite des variables d'environnement définies dans le processus d'origine telles quelles.

Les variables de shell et d'environnement sont «Les variables d'environnement sont passées aux processus enfants, mais les variables de shell ne sont pas transmises (les variables d'environnement sont gérées par le noyau, donc lorsqu'un processus enfant est généré, c'est-à-dire qu'une commande est appelée depuis le shell. A ce moment, le noyau peut transmettre une copie des variables d'environnement du shell au processus enfant, mais les variables du shell sont gérées par le shell, donc __ le noyau ne détecte pas __) ". Lorsque la variable shell et la variable d'environnement sont confondues, il est bon de se rappeler __ "La variable shell est utilisée pour définir le comportement du shell lui-même, et la variable d'environnement est utilisée pour définir le comportement de la commande que le shell lance" __ ..

Les variables shell sont définies avec variable = value pour sh, bash et zsh. Ne mettez pas d'espaces aux deux extrémités de =. Un exemple de variable shell est

--Prompt (PS1 est $, PS2 est> , PS4 est#est le paramètre de base. Notez que la valeur par défaut de PS1 sur Mac est\ h: \ W \ u \ Dans $, \ h est le nom d'hôte, \ W est le nom du répertoire courant et \ u est le nom d'utilisateur.) --Nombre de commandes à enregistrer dans l'historique (HISTSIZE) --Les caractères utilisés dans le remplacement de l'historique (histchars, qui est! ʻEt ^ par défaut, mais il n'y a rien dans la variable, vous pouvez donc changer ce caractère en le définissant comme histchars =% `)

etc.

Des exemples de variables d'environnement sont PATH, TERM, HOME, USER, SHELL, etc. (bash ne peut pas être inférieur), qui est généralement supérieur. Tous peuvent être trouvés dans ʻecho $ PATH. Si vous voulez que la variable shell a que vous avez définie soit une variable d'environnement, utilisez ʻexport a. Cependant, des variables d'environnement comme celle-ci disparaissent également lorsque vous vous déconnectez du shell, donc si vous voulez les conserver de manière permanente, vous devez les écrire dans .bashrc etc.

Vous pouvez voir toutes les variables d'environnement avec les commandes printenv et ʻexport, et vous pouvez voir l'explication des variables d'environnement typiques utilisées dans le système avec man environ. La commande declare` (mais vous pouvez également voir les fonctions définies) voir toutes les variables du shell.

alias

Possibilité de donner des alias aux commandes. Avec cette fonction, vous pouvez effectuer les opérations suivantes.

1. Réduisez l'effort de frappe (comme ʻalias md = mkdir`)
2. Créez une nouvelle commande (comme créer votre propre commande)
3. Anticipez les fautes de frappe (comme «alias mroe = more»)
4. Changez la signification de la commande (comme ʻalias ls = 'ls -F'`)
5. Faites des choses que les scripts shell ne peuvent pas faire (définir des variables shell et d'environnement pour le shell que vous utilisez actuellement n'a pas de sens dans les scripts shell, car l'exécution de ce script shell lance un autre shell)

Paramètres du terminal

Les paramètres du terminal sont également l'un des éléments définis dans le fichier de paramètres du shell. La commande la plus importante pour configurer le terminal est la commande stty. Avec la commande stty, vous pouvez définir la clé d'affectation des bornes et le mode de sortie. Par exemple, la commande stty erase ^ H changera la clé pour supprimer un caractère en Ctrl-H. Ce qui suit est une liste de clés fréquemment utilisées qui peuvent être modifiées avec stty.

Expression régulière (sous UNIX)

Une expression régulière est l'un des moyens de représenter un ensemble de chaînes basé sur une certaine règle. Notez que les expressions régulières utilisées dans cet article à l'avenir sont celles utilisées sous UNIX et sont légèrement différentes de celles utilisées dans la théorie des automates et la théorie linguistique.

Par exemple, dans la chaîne ^ a. * Ttion $, "il y a un au début de la ligne (^), et il y a 0 ou plusieurs répétitions (*) d'un caractère (. ). , Tion suivi de la fin de la ligne ($) ". Les caractères avec des significations spéciales telles que «^» et «*» sont appelés metacharacter.

Il n'y a pas un type d'expression régulière, et les fonctions réalisées par l'outil sont limitées, et la méthode d'expression est légèrement différente. Ici, je vais le présenter en deux parties.

1. Expressions régulières de «grep», «ed »,« vi »,« sed »,« less »
2. Expressions régulières des séries ʻegrep et ʻawk

De plus, il convient de noter__Remplacement du nom de fichier Shell__Utilisé dans*(Chaîne de caractères arbitraire)Ou?(N'importe quel personnage)Notez que la signification du symbole est légèrement différente de celle des métacaractères tels que.ps | grep *tionSi vous entrez une commande comme*Par la coquille__Le nom du fichier est remplacé en premier__。ps | grep '*.tion'comme''Doit être inclus dans.

1. Expressions régulières des séries «grep», «ed »,« vi »,« less »

• Élimine la signification du métacaractère \ m m -- ^ Début de la ligne -- $ ʻFin de ligne --. Tout caractère unique --[c1c2 ... cn]N'importe lequel des caractères d'une ligne (par exemple," [abc] "est" a "ou" b "ou" c ") --[^ c1c2 ... cn]Tout caractère autre que les caractères arrangés (par exemple, si[^ abs], tout caractère autre que ʻa, b et s) --0 répétitions ou plus de l'expression régulière r * r -- \ (r ) Expression régulière étiquetée r (Ceci est un groupe d'expressions régulières, et si vous ajoutez * après cela, vous pouvez exprimer 0 ou plusieurs répétitions) -- \ N`` La n`ième expression régulière marquée représente la chaîne correspondante

Par exemple

--ʻA * c correspond à " c "" ʻac "" ʻa ac "et ainsi de suite. -- \ ([ab] c ) \ 1 correspond à "ʻacac" ou " bcbc ". Quand "'\ ([ab] c ) "correspond à" ʻac "," \ 1" représente "ʻac", donc il ne correspond pas à "ʻacbc".

2. Expressions régulières des séries ʻegrep et ʻawk

C'est fondamentalement le même que l'expression régulière ci-dessus, mais le format de l'expression régulière définie dans la théorie linguistique peut être utilisé.

--Une ou plusieurs répétitions de l'expression régulière «r +» «r» --Il y a ou n'a pas un r? Expression régulière r -- r1 | r2 Expression régulière r1 ou r2 (signifiant ou)

• Regroupement des expressions régulières (r) r (cela rend les expressions régulières marquées inutilisables dans ʻegrep` etc.)

Par exemple

--ʻAb + c correspond à "ʻabc", "ʻabbc", "ʻabbbc", etc. -- (a | b) c correspond à "ʻac" ou " bc` "

Trouver et remplacer

Chercher

En gros, utilisez vi ou emacs search ou grep pour rechercher des mots dans __file, et utilisez la commande find pour rechercher __file name __.

Dans vi, en mode commande, «/ keyword» est utilisé pour la recherche avant et «? Keyword» est utilisé pour la recherche inverse. emacs utilise Ctrl-S keyword pour rechercher vers l'avant et Ctrl-R keyword pour rechercher vers l'arrière.

grep, ʻegrep et fgrepsont des commandes qui reçoivent certaines données, en extraient la ligne qui correspond à la chaîne de caractères spécifiée et en sortent. La forme de base estgrep keyword files, et lorsque le nom de fichier filesn'est pas spécifié, les données sont entrées à partir de l'entrée standard.grep est le plus ancien de la soi-disant" famille grep ". ʻEgrep est fondamentalement grep, mais les expressions régulières qui peuvent être gérées ont été développées. fgrep peut rechercher plusieurs chaînes en même temps, mais ne peut pas utiliser d'expressions régulières.

La commande find recherche le fichier lui-même. L'utilisation standard de la commande find est la suivante.

rechercher des critères de recherche dans l'annuaire

Par exemple, «find. -Name» * .py »signifie rechercher tous les fichiers dans le répertoire de travail actuel qui se terminent par« .py ». Vous pouvez également utiliser find. -Name '* .py' -atime + 15 pour rechercher des fichiers qui n'ont pas été consultés depuis plus de 16 jours. -atime représente le dernier temps d'accès (temps d'accès).

Un exemple plus pratique est find. -Name '* ~' -exec rm {} \; -print. Il s'agit de supprimer le nom de fichier se terminant par ~ (rm {}) et de l'imprimer (-print). L'option -exec exécute les commandes UNIX jusqu'au point-virgule échappé (\;), et` {} ʻest définie pour contenir le chemin qui remplit les conditions.

Remplacement

Le remplacement par «vi» est identique à la fonction de remplacement de la commande «ex», qui est une autre face de «vi». ʻEdetsed` utilisent des commandes de remplacement similaires. Fondamentalement, il a le format suivant et remplace la chaîne qui correspond à «modèle» par «chaîne».

range s/pattern/string/g

Spécifiez la plage de remplacement pour «plage». Par exemple, «%» représente la ligne entière, et «début, fin» représente les lignes de «début» à «fin». Les expressions régulières peuvent être utilisées pour «modèle» et «chaîne». Le dernier «/ g» signifie changer toutes les pièces de rechange en une seule ligne. Les détails ici seront traités en détail dans l'introduction de la commande sed. Vous pouvez remplacer emacs par M-% (M-x query-replace).

filtre

Filter est un programme qui traite les données d'entrée à partir de l'entrée standard et sort le résultat vers l'entrée standard. Il existe deux types principaux, le premier est celui qui vous permet de spécifier la fonction de filtre en donnant un programme au filtre lui-même (sed, ʻawk, perl`, etc.), et le second est que la fonction est décidée depuis le début. Les choses («tête», «queue», etc.).

Exemple de filtre

Utilisez les commandes head et tail pour créer un filtre avec une nouvelle fonctionnalité comme exemple. Utilisez belly n m comme filtre pour extraire les lignes n à m. Le contenu du ventre est le suivant.

.sh

#!/bin/bash
from=$1
to=$2
arg=$(($to - $from + 1))
head -$to | tail -$arg

Vous pouvez maintenant récupérer les lignes 12-14 de foo.txt avec la commande cat -n foo.txt | ./belly 12 14.

Commande tee

Un filtre qui sort l'entrée de l'entrée standard à la fois vers le fichier spécifié comme argument et la sortie standard. Par exemple, si vous faites make | tee bar.txt, vous pouvez afficher le résultat de la commande make dans bar.txt et aussi à l'écran.

Commande sort

Un filtre qui trie l'entrée de l'entrée standard ligne par ligne et la sort vers la sortie standard. Par exemple, avec ls -l | sort -nr + 4, le 4ème champ (taille du fichier) est comparé sous forme de valeur numérique et organisé par ordre décroissant. -n est comparé comme un nombre, -r est affiché dans l'ordre inverse comme spécifié, et -f est insensible à la casse.

Commande ʻUniq`

Un filtre qui prend en compte les lignes dupliquées si les lignes adjacentes d'entrée de l'entrée standard ont le même contenu, supprime les lignes dupliquées et sort vers la sortie standard. Par exemple, supposons que vous ayez des fichiers aa, bb et cc dans le répertoire OLD et des fichiers aa1, bb et cc dans le répertoire NEW. (ls OLD; ls NEW) | sort

aa
aa1
bb
bb
cc
cc

Est affiché, mais(ls OLD; ls NEW) | sort | uniqPuis

aa
aa1
bb
cc

Est affiché. Les bb et cc que je porte disparaissent.

Commande tr

Un filtre qui remplace l'entrée de l'entrée standard en unités de caractères et la renvoie vers la sortie standard. Utilisez sous la forme tr old-string new-string et remplacez les caractères qui apparaissent dans old-string par les caractères qui correspondent à new-string. Pour tr ab XY, remplacez a par X et b par Y. S'il s'agit de «tr a-z A-Z», tous les alphabets sont remplacés par des lettres majuscules et affichés. Par exemple, ls | tr a-z A-Z affichera les noms de fichiers dans toutes les lettres majuscules. Si vous spécifiez l'option -d, cela devient un filtre qui supprime le caractère spécifié, donc si vous utilisez fichier cat | tr -d '\ 015', vous pouvez supprimer le CR du caractère de contrôle (windows est la fin de la ligne). Est-ce que CR LF et UNIX est seulement LF, donc la commande ci-dessus corrigera les sauts de ligne).

Commande ʻExpand`

Un filtre qui convertit les onglets d'entrée de l'entrée standard en un nombre correspondant de blancs et les sort en sortie standard. ʻUnexpand` est un filtre qui remplace les blancs consécutifs par des tabulations.

Commande fold

Un filtre qui sort l'entrée de l'entrée standard vers la sortie standard après avoir forcé la coupure de ligne de sorte que la longueur de chaque ligne devienne un nombre fixe de caractères. Par exemple, utilisez la commande ʻexpand file | fold -65pour rendre la largeur de ligne de 65 caractères. La commandefold` n'interprète pas les tabulations, donc prétraitez avec expand comme dans cet exemple.

Commande pr

Un filtre qui convertit l'entrée de l'entrée standard au format de sortie pour les imprimantes ligne et la sort vers la sortie standard. Plus précisément, il est possible d'ajouter le nom du fichier, l'heure et le numéro de page comme en-tête de chaque numéro de page, et de rendre le texte multi-colonne.

Commande sed

sed (éditeur de flux) est un éditeur conçu pour être utilisé comme filtre. La forme de base est «sed command». command représente" quel type de fonction est appliqué à la ligne qui correspond à quelle adresse ". Le format est «fonction [adresse1 [, adresse2]]». Si une adresse est spécifiée, la fonction est appliquée uniquement à cette ligne, si deux adresses sont spécifiées, la fonction est appliquée à toutes les lignes entre les deux adresses, et si aucune adresse n'est spécifiée, la fonction de fonction est appliquée à toutes les lignes.

Il existe plusieurs façons de spécifier l'adresse. Vous pouvez utiliser des nombres pour représenter le nombre de lignes et vous pouvez également utiliser des expressions régulières. Par exemple, pour «10p», appliquez la fonction p sur la 10e ligne. Pour / ^ a /, / ^ b / p, appliquez la fonction p de la ligne commençant par a à la ligne commençant par b.

Les éléments suivants pour chaque fonction.

• La fonction p est une fonction utilisée pour afficher le contenu de la ligne __ en cours de traitement. Par défaut, sed sort le résultat traité par la commande, mais lorsque l'option -n est spécifiée, la sortie de ligne automatique n'est pas effectuée, donc seule la ligne spécifiée par la fonction p est affichée. devenir. Par exemple, `cat -n / usr / share / dict / words | sed -n '100, 105p' 'affichera chaque ligne de la ligne 100 à la ligne 105.
• La fonction d est une fonction utilisée pour supprimer __ lignes inutiles de l'entrée. Par exemple, la commande sed '/ ^ BEGIN /, / ^ END / d' supprime de la ligne commençant par BEGIN au début de la ligne jusqu'à la ligne commençant par END au début de la ligne. La fonction q est une fonction qui met fin à l'exécution de sed lorsqu'elle correspond à l'adresse, et est utilisée comme sed -e '100, 105p'-e' 105 q'. -e est une option à utiliser lorsque vous souhaitez traiter plusieurs fonctions. Dans cet exemple, l'exécution de sed se termine à la 105e ligne.
• La fonction s est une fonction qui effectue un remplacement de chaîne de caractères __ en utilisant __ expressions régulières. Il est exprimé sous la forme de «s / expression-régulière / remplacement / indicateurs». Remplace la première chaîne qui correspond à l'expression régulière spécifiée dans le modèle de recherche «expression régulière» pour la ligne en cours de traitement par la chaîne spécifiée dans le modèle de remplacement «remplacement». Dans flags, spécifiez des flags pour changer le comportement de la fonction s. Par exemple, g remplace toutes les chaînes qui correspondent à une expression régulière dans une ligne (par défaut, seule la première chaîne correspondante est remplacée). Si p, la ligne correspondante est sortie.
• La fonction y est une fonction __ qui remplace __ unités d'entrée, comme la commande tr. Par exemple, si vous entrez y / aiueo / AIUEO /, toutes les lettres de aiueo seront en majuscules.

D'autres résultats tels que le branchement et le stockage intermédiaire peuvent être obtenus, mais les détails sont omis.

Commande ʻAwk` (chêne)

awk est un langage pour traiter les lignes d'entrée selon des modèles. Je suis doué pour le traitement de fichiers au format tableau, où chaque ligne d'entrée est séparée par des délimiteurs tels que des espaces et des tabulations. Un peu plus près de c. Pour exécuter awk, vous pouvez spécifier programme comme argument de ʻawk program, ou écrire le programme dans le fichier program-file comme ʻawk -f program-file et l'écrire dans -f. Il existe une méthode pour le spécifier en option. Le contenu de programme est

pattern1 { action1 }
pattern2 { action2 }
...

Le modèle pattern__ pour __input et l'action ʻaction__ à exécuter lorsque le modèle est mis en correspondance sont décrits comme une paire. Lorsque pattern est omis, l'action ʻaction est exécutée sur toutes les lignes d'entrée. Lorsque «{action}» est omis, la ligne correspondant à «pattern» est sortie.

Spécifiez le modèle d'expression régulière en le mettant entre /. ʻAwk '/ ^ From: /' affichera toutes les lignes commençant par From:. Lorsque vous spécifiez le programme awk sur la ligne de commande, assurez-vous de le placer entre'_ afin que le programme donné à __awk soit un argument. ʻAwk divise automatiquement la ligne d'entrée en champs par des délimiteurs. Par exemple, «ls -l» est le mode dans «$ 1» (tel que «-rw-r - r -»), «$ 2» est le nombre de liens physiques, «$ 3» est le nom du propriétaire et «$ 4» Entrez le nom du groupe, «$ 5», comme la taille du fichier (dans l'ordre dans lequel «ls -l» est affiché).

Par exemple, ls -l | awk '$ 5> 1000 {print" taille du fichier ", $ 9," is ", $ 5;}'

size of file filename1 is 34694
size of file filename2 is 1011
size of file filename3 is 56203

Seuls les fichiers dont la taille est supérieure à 1 000 sont affichés. En plus de «print», les affectations et opérations de variables et les instructions de contrôle telles que «if» et «for» peuvent être incluses dans «action», mais les détails sont omis.

Compression et archivage

compression

Dans le domaine de l'informatique, un mécanisme permettant de réduire la quantité (quantité de données) d'informations exprimées sous une forme quelconque sans perdre son contenu est envisagé depuis longtemps. Un tel mécanisme est appelé compression de données, ou simplement compression. La restauration d'un fichier compressé s'appelle decompression.

La commande compress n'a pas cette compression élevée, mais elle n'est pas lente et est fournie en standard avec la plupart des systèmes UNIX. Une fois compressé, il a une extension de .Z. Utilisez la commande ʻuncompresspour la décompression. La commandegzipa une extension .gz. C'est un type de logiciel GNU. Utilisez la commandegunzip pour décompresser un fichier compressé avec la commande gzip. Si vous utilisez la commande zcat, vous pourrez peut-être décompresser à la fois le fichier compressé par la commande compress et le fichier compressé par la commande gzip. Il existe également une commande de compression appelée «bzip2». Utilisez la commande bunzip2` pour la décompression.

archiver

La combinaison de plusieurs fichiers en un seul fichier s'appelle __archive __. Les commandes d'archivage incluent «tar», «shar», «cpio», «zip».

«tar» est une abréviation de «archive sur bande», qui était à l'origine une commande pour créer un fichier d'archive sur bande magnétique. Cependant, le support qui peut être utilisé ne se limite pas à la bande magnétique. Cette commande est utilisée sous la forme tar key filename .... La clé ne contient qu'un des cinq caractères de commande «c», «t», «x», «r», «u »et des options si nécessaire.

-- c crée un fichier tar --t examine le contenu du fichier tar --x récupère le fichier du fichier tar --r et ʻu` ajoutent des fichiers à la fin du fichier tar

Les options fréquemment utilisées sont les suivantes.

• L'option v signifie verbeux, et si vous spécifiez cela, les noms de fichiers à traiter dans l'archive seront affichés dans l'ordre.
• L'option f prend un argument et spécifie le nom du fichier tar à créer

Cependant, l'option dans tar est spécifiée en la connectant avec le caractère de commande et d'autres options sans ajouter le caractère " - ". Par exemple, tar cvf srcfiles.tar. / Src crée un fichier tar appelé scrfiles.tar basé sur ./src.

Il y a aussi GNU tar, qui étend la commande originale tar. Parfois, il a le nom de commande gtar, et parfois il a le nom de commande tar. Il existe de nombreuses autres commandes telles que «shar», «cpio» et «zip», mais elles sont omises ici.

Heures du jour

Connaître l'heure actuelle

Utilisez la commande date pour voir l'heure. L'option -u définit l'heure standard de Greenwich.

Afficher le calendrier

La commande cal pour voir le calendrier. Par exemple, vous pouvez voir le calendrier de novembre 2019 à cal 11 2019. Notez que s'il n'y a qu'un seul argument, il sera interprété comme une année.

Utilisez le réveil

La commande Leave peut être utilisée comme réveil. Si vous réglez «quitter 1920», l'alarme sera réglée à 19:20 et un message apparaîtra avec un bip sonore. Il existe également un moyen de spécifier «congé + 30» (un message est envoyé après 30 minutes), et il est également possible de définir une alarme avec un temps relatif à partir du présent. Utilisez la commande kill lorsque vous n'en avez pas besoin.

Prenez un intervalle

La commande sleep est littéralement une commande pour se reposer sans rien faire. Une commande qui se repose et se termine sans rien faire pendant le nombre de secondes donné dans l'argument. Par exemple, si vous exécutez la commande sleep 300; echo" Le thé est juste prêt. "&, Après 5 minutes, la commande ʻecho` sera exécutée et un message sera affiché.

Exécutez la commande à l'heure spécifiée

Il existe une commande ʻatcomme l'une des méthodes pour exécuter la commande au moment où vous décidez. Cela exécutera le script shell spécifié à l'heure spécifiée. Au format ʻat time [filename], entrez l'heure de début dans time et le nom du script shell à exécuter dans filename. Si le nom de fichier n'est pas spécifié, le script shell est lu à partir de l'entrée standard et exécuté. Par exemple, la commande ʻat 6am 6 script exécutera le script à 6 heures du matin le 6 juin. Cependant, cette commande utilise sh par défaut. De plus, la sortie standard et la sortie d'erreur standard de ce script proviennent de __mail__, donc si vous ne l'aimez pas, effectuez la redirection (> result.out`, etc.).

Le statut du script shell spécifié pour être exécuté par la commande ʻat peut être connu par la commande ʻatq. Utilisez la commande ʻatrm pour annuler l'exécution du script shell spécifié par la commande ʻat.

Travaillez régulièrement

UNIX a un mécanisme pour démarrer des commandes sur une base régulière. Avec ce mécanisme, il est possible de supprimer automatiquement les fichiers inutiles chaque jour. Ce mécanisme est réalisé par un démon appelé cron. De plus, le fichier qui définit les commandes qui sont exécutées régulièrement est appelé le fichier crontab. Le démon cron fait référence au contenu du fichier crontab et exécute des commandes régulièrement.

Utilisez la commande crontab pour configurer le fichier crontab. Utilisez crontab -e pour créer un nouveau fichier crontab ou modifier son contenu. Cela lancera l'éditeur et chargera le fichier crontab de l'utilisateur.

Dans le fichier crontab, écrivez un paramètre par ligne. Dans le fichier crontab utilisé par les utilisateurs généraux, chaque ligne se compose des six éléments suivants séparés par des espaces.

min hour day mon day-of-week command

Les quatre premiers sont la spécification des minutes (min), des heures (heures), des jours (jour) et des mois (lun). day-of-week spécifie le jour, 0 est dimanche, 1 est lundi, et ainsi de suite.

Par exemple

0 0 1 1 * find $HOME -name '*core' -atime +7 exec rm {} \;

La commande find $ HOME -name '* core' -atime +7 exec rm {} \; est exécutée à 0:00 le 1er janvier. Si vous spécifiez «*» au lieu d'un nombre dans les cinq premiers champs qui spécifient une commande, la commande sera exécutée quel que soit le nombre dans ce champ. Exécutez avec l'option -l pour afficher le contenu du fichier crontab. Pour supprimer le fichier crontab, utilisez crontab -r.

Mesurer le temps d'exécution de la commande

Utilisez la commande time pour mesurer le temps d'exécution d'une commande. Le format de la «commande temporelle».

programmation bash

Script shell

Un fichier dans lequel les commandes sont stockées à l'avance afin de pouvoir être exécutées dans un lot est appelé shell script. C'est un peu démodé, mais on l'appelle aussi batch dans le sens où la méthode de traitement est décidée avant le début de l'exécution. Il est également appelé shell program parce que le processus est organisé dans un but.

Il est difficile de taper bash script_name chaque fois que vous exécutez un script shell, donc si vous mettez #! / Bin / bash au début du fichier, vous pouvez l'exécuter en tant que commande. Vous pouvez donc le faire simplement en tapant . / Nom_fichier (mais vous devez rendre le mode fichier exécutable, comme chmod + x nom_fichier). Un script shell qui peut être exécuté en tant que commande de cette manière est appelé __shell commande __.

Comportement lors de l'exécution de commandes shell

Premièrement, lorsque bash découvre que le nom de la commande est nom_fichier, il recherche ce fichier à partir du chemin de recherche de la commande (cependant, lorsqu'il s'agit de. / Nom_fichier, il ne recherche pas à partir du chemin car le chemin a déjà été spécifié). Et lorsque le fichier est en mode exécutable, regardez la première ligne du fichier.

1. Lorsque le début d'une ligne est «#!», Le noyau est invité à exécuter le fichier. Ensuite, démarrez le fichier spécifié par le nom de chemin absolu après #! En tant que programme. Par exemple, #! / Bin / csh ou #! / Usr / bin / python. Le fichier texte est utilisé comme entrée. Tout ce qui est écrit après le chemin absolu est considéré comme un argument.
2. Sinon, démarrez bash et utilisez le reste du fichier texte comme entrée

Notez que la gestion de «#» est différente de manière non interactive de celle de l'utilisation interactive du shell. Notez que lorsque vous utilisez «#» dans un script shell, il sera reconnu comme __comment __. Par exemple, si vous exécutez rm important # à partir de la ligne de commande et que vous l'exécutez avec un script shell, les fichiers qui disparaissent seront différents. Si vous voulez supprimer ʻimportant # dans un script shell, échappez-le comme ʻimportant \ #.

Lorsque bash est démarré, le répertoire de travail actuel de bash à démarrer et le répertoire de travail actuel à démarrer sont __matched __. Vous pouvez également utiliser des chemins relatifs pour exécuter des commandes shell.

Détails variables

Dans bash, les variables peuvent également utiliser array. Par exemple, déclarez le tableau names = (hatter duchesse alice). Vous pouvez maintenant faire référence à la valeur comme ʻecho $ {names [0]} `.

Lors de l'écriture d'un script shell, vous souhaitez parfois utiliser la valeur par défaut lorsqu'une variable n'est pas définie, ou effectuer un traitement en fonction du nombre de tableaux. À cette fin, bash fournit un moyen de savoir si une variable est définie ou le nombre de tableaux. Les basiques sont énumérés ci-dessous.

Utilisez la commande read pour saisir des variables à partir de l'entrée standard.

J'ai écrit un exemple réel de script shell dans un fichier appelé script.sh.

script.sh

#!/bin/bash
echo "this result is produced by $0"
echo '$#' is $#
echo '$*' is $*
echo '$$' is $$ '(process id)'
echo ${word:-abcg}
echo '$1' is ${word:=$1}

Si vous exécutez ceci avec ./script.sh hello bash et la ligne de commande, ce sera comme suit. «$» représente l'ID de processus du shell. Un exemple typique d'utilisation de ceci est __ pour créer un fichier temporaire utilisé dans un script shell. Si vous remplacez quelque chose comme `tmp = tmp. $`, vous pouvez créer en toute sécurité un fichier temporaire en utilisant la propriété que l'ID de processus ne sera jamais couvert jusqu'à la fin du processus.

Redirection d'E / S

Les entrées et sorties de processus sont spécifiées à l'aide d'un nombre basé sur 0 appelé descriptor. 0 représente l'entrée standard, 1 représente la sortie standard et 2 représente la sortie d'erreur standard. Il est possible de sortir la sortie vers le descripteur num to file sous la forme de num> file. Si vous ajoutez & et le descripteur num après la redirection> to make> & num, la sortie sera redirigée vers le fichier num. C'est difficile à comprendre, je vais donc donner un exemple.

Le ʻoutput.sh` suivant est un script qui renvoie la chaîne de caractères stdout vers la sortie standard et la chaîne de caractères stderr vers la sortie d'erreur standard.

output.sh

#!/bin/bash
echo "stdout" >&1
echo "stderr" >&2

Cela provient de https://qiita.com/laikuaut/items/e1cc312ffc7ec2c872fc.

1. Avec ./output.sh> a, la chaîne de caractères de stdout est saisie dans a. C'est la même chose que ./output.sh 1> a, seul 1 est omis.
2. Avec ./output.sh 2> a, la chaîne de caractères de stderr est saisie dans a.
3. Avec ./output.sh 1> a 2> b, la chaîne stdout est dans a et la chaîne stderr est dans b.
4. Avec ./output.sh> & a, les deux chaînes sont entrées dans un fichier. L'insertion d'un espace entre «>» et «&» entraînera une erreur.
5. Dans ./output.sh> a 2> & 1, les deux chaînes sont entrées dans un fichier.
6. Dans ./output.sh 2> & 1> a, __a ne peut contenir que la chaîne stdout __. C'est parce que la chaîne stderr est sortie vers la sortie standard __ au premier 2> & 1. Après cela, > a est terminé, donc seule la sortie standard est écrite dans le fichier.

À propos de la structure de contrôle

En programmation, il peut être nécessaire de juger les conditions, de décider de la prochaine partie à exécuter ou de répéter le processus jusqu'à ce qu'une certaine condition soit satisfaite. Comme syntaxe pour contrôler une telle exécution, ici

1. if
2. for
3. while
4. case
5. Fonction
6. Autres commandes prenant en charge la structure de contrôle

Pour reprendre.

1. if

La syntaxe de if est la suivante.

if commandlist1
then commandlist2
else commandlist3
fi

__ Une liste de commandes __ est une liste de commandes séparées par ; ou des sauts de ligne. Dans la commande ʻif, lorsque le résultat de l'exécution de commandlist1(c'est-à-dire, l'état de fin de la dernière commande) est normal end (0),commandlist2est exécuté en supposant que la condition est satisfaite. Sinon, exécutezcommandlist3. fi` est l'inverse de if. Il y a aussi elif.

2. for

La grammaire de for est la suivante.

for variable in list
do commandlist
done

Dans l'instruction for, le premier mot de la liste list est défini comme la valeur de la variable variable, et la commande list commandlist de do to done est exécutée. Ensuite, définissez le deuxième mot de la liste sur variable et répétez ... Il existe également des commandes «continue» et «break».

Les listes peuvent être exprimées de plusieurs manières. Il peut être répertorié comme «for i in a1.py a2.py», ou la substitution de nom de fichier peut être utilisée comme «for i in * .py». Dans bash, vous pouvez assigner chaque chemin à la variable ʻi en définissant: sur la variable d'environnement qui représente le délimiteur ʻIFS et en le définissant sur pour i dans $ PATH.

A titre d'exemple concret, le ʻif_for.sh` suivant.

if_for.sh

#!/bin/bash
for i in u.c t.c
do
    echo $i
    cc -c $i
    if [ $? != 0 ] #Voici si test$? !=Idem avec 0
    then break
    fi
done

cc est la commande à compiler. Puisque la compilation échoue (les noms de fichier u.c et t.c sont des noms convenablement décidés et ne peuvent pas être compilés), une valeur autre que 0 est entrée dans «$?». La commande [ a la forme [exp], calcule l'expression de ʻexp, et si le résultat est vrai, elle se termine normalement (renvoie 0 comme état de fin), sinon elle se termine anormalement (1 comme état de fin). (Renvoie) la commande. La même chose que la commande [est la commandetest`. Cette fois, le fichier u.c n'existe pas (probablement), donc ce n'est pas grave si la boucle for s'arrête correctement.

Il existe différentes expressions dans l'expression «exp», donc certaines sont affichées.

---a filename Le nom de fichier existe ---d filename Le nom de fichier existe et est un répertoire --str1 = str2 La chaîne str1 et la chaîne str2 sont égales --str1! = str2 La chaîne str1 et la chaîne str2 ne sont pas égales --num1 -eq num2 Comparé à un nombre, l'entier num1 = l'entier num2 (égal). --num1 -gt num2 Comparé à un nombre, l'entier num1> l'entier num2 (supérieur à).

3. while

La syntaxe de while est la suivante.

while commandlist1
do commandlist2
done

Cela répète commandlist2 jusqu'à ce que commandlist1 se termine normalement (renvoie 0 comme état de fin). À titre d'exemple concret, le "while.sh" suivant.

while.sh

while true
do
sleep 10
w
done

Ceci consiste à exécuter la commande w toutes les 10 secondes. La commande w est une commande qui montre qui est connecté et ce qu'il fait. La commande après while entre dans la boucle si elle se termine avec succès (c'est-à-dire quand $? Vaut 0). La commande true ne se termine que normalement, donc elle boucle pour toujours. Il existe également une commande «false», qui se termine simplement de manière anormale.

4. case

La grammaire du cas est la suivante.

case string in
pattern1 ) commandlist1 ;;
pattern2 ) commandlist2 ;;
...
esac

Tout d'abord, vérifiez si la chaîne «string» correspond à «pattern1», et si c'est le cas, exécutez «commandlist1». S'il n'y a pas de correspondance, passez à «pattern2». La déclaration de cas le répète. Le dernier «esac» est une description inverse de «case». A titre d'exemple concret, le "case.sh" suivant.

case.sh

#!/bin/bash
for word in *
do
    case $word in
        *.out)
            echo $word is out file;;
        *.sh)
            echo $word is sh file;;
        *)
            echo $word is other file;;
    esac
done

Par exemple, si vous avez un fichier appelé ʻaa.out bb.sh`` cc.txt` dans un répertoire, vous pouvez l'exécuter.

aa.out is out file
bb.sh is sh file
cc.txt is txt file

Est affiché.

5. Fonction

Les fonctions peuvent être définies sous la forme name () {commandlist;}. Après avoir exécuté cette définition, exécuter «nom» comme une commande exécutera la «liste de commandes» correspondante. Un exemple concret est écrit ci-dessous dans func.sh.

func.sh

go () {
echo "file name = $1"
if test ! -r $1     # !Signifie le déni
then echo $1 is not found
else echo $1 is found
fi
}
go foo.txt
go bar.txt

Si vous l'exécutez avec . / Func_script.sh dans un répertoire où le fichier foo.txt existe et le fichier bar.txt n'existe pas

file name =  foo.txt
foo.txt is found
file name =  bar.txt
bar.txt is not found

Sera.

6. Autres commandes prenant en charge la structure de contrôle

-La commande ʻexec met fin à l'exécution du shell lui-même qui exécute actuellement la commande ʻexec et exécute le fichier spécifié. Par exemple, la commande ʻexec / bin / sh` se déplacera vers sh si elle réussit, et continuera dans le shell tel quel en cas d'échec.

-La commande ʻeval donne la ligne de commande ligne de commande comme argument et l'exécute. Par exemple, si ʻeval echo hello, seul bonjour est affiché. Ceci est utilisé

1. Lors de l'exécution de la chaîne de caractères produite par une certaine commande en tant que commande
2. Lors de l'évaluation des variables imbriquées Est. Un exemple de 1 est ʻeval $ SHELL --version, qui vous indique la version. Un exemple de 2 est ʻeval '$' $ temp, qui vous permet de voir le contenu de la variable pointée par la variable temp.

-La commande ʻexit termine l'exécution du shell. ʻSortie expr se termine avec la valeur de l'expression ʻexpr comme état de sortie. Il est normal de définir ʻexit 1 pour une terminaison normale et ʻexit 0 pour une terminaison anormale. L'expression ʻexpr est facultative.

-La commande source existe pour csh, bash et zsh. Pour sh, utilisez .. Dans le cas de bash shell_script, __ lancera un nouveau processus bash et exécutera shell_script, mais s'il est exécuté dans source ou ., il sera exécuté dans ce shell. Si vous exécutez le source_dot.sh suivant avec source et bash respectivement, vous pouvez voir que le répertoire actuel après la fin est différent. Cependant, zsh ne peut plus remplacer «source» par «.».

source_dot.sh

echo 1 \$PWD is $PWD
echo 2 ls
ls
echo 3 change dir
cd ..
echo 4 \$PWD is $PWD
echo 5 ls
ls

-La commande goto est une commande qui se déplace vers la ligne où label: ʻest écrit quand il y a une ligne appelée goto label`.

Traitement de signal

Dans bash et sh, vous pouvez spécifier le traitement du signal reçu dans le script shell avec la commande trap. Avec trap command num, la commande commande est exécutée lorsque le signal spécifié par le numéro de signal num se produit. Si «trap» «num», n'acceptez pas le signal spécifié par le numéro de signal «num» (exécuter «»). S'il s'agit de «trap num», le traitement du signal spécifié par le numéro de signal «num» est restauré. Le loop.sh suivant est présenté comme un exemple concret.

loop.sh

trap "echo 'you tried to kill me!'" TERM
trap "echo 'you hit CTRL-C!'" INT
while true; do
      sleep 5
      ps
done

Si vous le démarrez avec bash loop.sh, il continuera d'exécuter la commande ps toutes les 5 secondes. Ce processus ne peut pas être arrêté avec Ctrl-C. C'est parce que Ctrl-C envoie un signal appelé INT, mais après avoir exécuté la commande ʻecho, il retourne à nouveau à l'instruction while. Même si vous arrêtez le processus une fois avec Ctrl-Z, vérifiez l'ID de processus (PID) avec la commande ps et tapez la commande kill, ce processus est toujours actif (même si vous revenez au premier plan avec la commande fgvous Le message a essayé de me tuer s'affiche et la commandepscontinue d'être exécutée) C'est parce que la commandekillenvoie un signal appelé TERM. Si vous voulez arrêter ce processus, utilisez la commandekill -KILL`.

Signal envoyé à la déconnexion

Selon les paramètres UNIX, la déconnexion peut envoyer un signal HUP (HangUP) à tous les processus exécutés à partir de ce terminal. Les processus qui ne traitent pas spécifiquement le signal HUP se terminent lorsqu'ils reçoivent le signal HUP. Le processus que vous souhaitez exécuter même après la déconnexion est lancé en ajoutant une commande après nohup. Par exemple, si vous définissez noh up python aa.py &, python aa.py continuera à fonctionner même après votre déconnexion.

Remplacement complexe

Lorsque le nom de la variable est stocké dans la variable n, écrire $ {$ n} pour récupérer sa valeur ne le remplace pas. En effet, après la substitution de variable de «$ n», la substitution de variable n'est plus effectuée. Afin de récupérer la valeur de cette variable, il est nécessaire de l'évaluer à nouveau en utilisant ʻeval` ou similaire. Plus précisément, ce qui suit.

Le shell décompose la ligne de commande en arguments une fois que toutes les substitutions (substitution d'alias, substitution d'historique, substitution de variable, substitution de commande, substitution de nom de fichier, etc.) sont terminées. Par conséquent, si la valeur de la variable est __ chaîne de caractères vide __ ou __ contient des espaces __, l'indice __ peut se déplacer lors de l'obtention du nième argument, donc soyez prudent.

Commandes intégrées

La commande exécutée par le shell lui-même est appelée __ commande intégrée __. Les commandes intégrées sont appelées commandes internes, et d'autres commandes sont parfois appelées commandes externes. Il est fondamentalement impossible pour d'autres processus de se référer à ou de modifier l'état d'un processus dans un shell. Par conséquent, cd, qui modifie le répertoire de travail actuel du processus shell, est une commande intégrée. Il peut y avoir à la fois des commandes intégrées et externes, telles que la commande kill, mais la commande externe kill a la limitation que le numéro de travail stocké par le shell ne peut pas être utilisé.

Commandes prenant en charge bash

-CommandeBasename et commande dirname La commande basename affiche le chemin avec le répertoire et l'extension supprimés. Si aucune extension n'est spécifiée, le chemin d'accès avec le répertoire supprimé est affiché. La commande dirname affiche le chemin avec le nom de fichier supprimé. Il est plus facile à comprendre en regardant l'exemple d'exécution.

・ Commande ʻExpr` Une commande qui calcule l'expression d'argument et renvoie le résultat du calcul à la sortie standard. Le format «exp exp». L'expression «exp» a différentes formes, dont certaines sont affichées.

Cependant, bash a une syntaxe intégrée de $ ((exp)), vous n'avez donc pas à utiliser cette commande. Il s'agit d'une commande fréquemment utilisée dans sh.

À propos de la coque

Différents shells sont utilisés sous UNIX. Les shells les plus typiques sont sh et csh, mais ces shells sont rarement utilisés de nos jours. En effet, il existe un shell pratique basé sur ces derniers avec diverses améliorations. Une brève introduction à un shell typique.

--tcsh est un shell avec des fonctions étendues basées sur csh. En particulier, il existe de nombreuses améliorations des fonctions pour le travail interactif telles que l'édition de ligne de commande. --ksh est un shell avec des fonctions sh améliorées. Il a été développé par David Korn, il prend donc l'acronyme k. --Bash est un shell développé par le projet GNU. Il est basé sur la syntaxe de sh. --zsh est un shell créé dans le but d'être le "shell final". Une coque ambitieuse qui intègre presque toutes les fonctionnalités existantes. Il est basé sur la syntaxe de sh.

fonction utile

Le shell relativement nouveau a diverses fonctionnalités que sh et csh n'ont pas. Les fonctions typiques sont les suivantes.

• Remplacement du nom de fichier qui spécifie une plage de nombres
• Fonction de correction automatique des sorts --Fonction d'exécution de commande régulière
• Redirection avancée --Exécution périodique des commandes --Exécuter la commande à une heure spécifiée --Fonction de surveillance de connexion et de déconnexion

Il existe de nombreux coquillages, alors trouvez celui qui vous convient.

À la fin

C'est la fin du résumé. Le contenu ci-dessus n'est que le premier volume du [super texte UNIX](https://www.amazon.co.jp/new The-UNIX-Super-Text-version révisée et étendue / dp / 4774116823), donc si vous en avez l'occasion, le deuxième volume Je pourrais le faire. Je vous serais reconnaissant si vous pouviez signaler des erreurs.