Opérations numériques Shell

$ i=0;$ ((i++))$ echo $i1$ let i++$ echo $i2$ expr $i + 13$ echo $i2$ echo $i 1 |

illustrer:

 expression

après

 $ je

,

 +

, 1 séparés par des espaces. Si une multiplication est effectuée, l'opérateur doit être échappé, sinon le Shell interprétera le signe de multiplication comme un caractère générique, ce qui entraînera une erreur de syntaxe ;

 embarrassant

derrière

 1 $

et

 2 $

se réfèrent respectivement à

 $ je

et 1, c'est-à-dire les 1er et 2ème chiffres de gauche à droite.

Utilisez les commandes intégrées de Shell pour afficher les types de chaque commande comme suit :

 $ type typetype est un shell intégré $ type letlet est un shell intégré $ type exprexpr est haché (/usr/bin/expr)$ type bcbc est haché (/usr/bin/bc)$ type awkawk est /usr/bin/awk

On peut le voir dans la démonstration ci-dessus :

 laisser

Il s'agit d'une commande intégrée de Shell, et les autres commandes sont des commandes externes, toutes dans

 /usr/bin

annuaire. et

 expression

et

 avant JC

Parce qu'il vient d'être utilisé, il a été chargé en mémoire.

 hacher

tableau. Cela nous aidera à comprendre les principes derrière les différentes méthodes d'exécution de scripts présentées dans le chapitre précédent.

Remarque : Si vous souhaitez afficher l'aide pour différentes commandes, par exemple

 laisser

et

 taper

En attendant la commande intégrée du Shell, vous pouvez utiliser une commande intégrée du Shell

 aide

pour afficher l'aide associée, et certaines commandes externes sont accessibles via une commande externe de Shell

 homme

pour afficher l'aide, une utilisation telle que

 aider à laisser

,

 expression manuelle

attendez.

Exemple : ajouter de 1 à un certain nombre

 #!/bin/bash# calc.shi=0;while [ $i -lt 10000 ]do ((i++)) doneeecho $i

Description : Passez ici

 while [expression conditionnelle] ; faire .... fait

Cycle à réaliser.

 -lt

est inférieur au signe

 <

, voir pour plus de détails

 test

Utilisation des commandes :

 test homme

.

Comment exécuter ce script ?

Méthode 1 : Passer directement le fichier script en paramètre du sous-Shell (Bash)

 $ bash calc.sh$ type bashbash est haché (/bin/bash)

Méthode 2 : Réussir

 frapper

commandes intégrées

 .

ou

 source

mettre en œuvre

 $ ./calc.sh

ou

 $ source ./calc.sh$ type .. est un type shell intégré $ sourcesource est un shell intégré

Méthode 3 : modifier le fichier pour qu'il soit exécutable et l'exécuter directement sous le Shell actuel

 $ chmod ./calc.sh $ ./calc.sh

Ensuite, nous démontrerons une par une l'utilisation d'autres méthodes pour calculer la variable plus un, c'est-à-dire

 ((je++))

aligner avec l'un des éléments suivants :

 soit i++;i=$(expr $i + 1)i=$(echo $i+1|bc)i=$(echo $i 1 | awk '{printf $1+$2;}')

Le temps de calcul de la comparaison est le suivant :

 $ temps calc.sh10000real 0m1.319suser 0m1.056ssys 0m0.036s$ temps calc_let.sh10000real 0m1.426suser 0m1.176ssys 0m0.032s$ temps calc_expr.sh1000real 0m27.425suser 0m5.060ssys 0m14.177s$ temps calc_bc.sh1000real 0m56.576suser 0m9.353ssys 0m24.618s$ temps ./calc_awk.sh100real 0m11.672suser 0m2.604ssys 0m2.660s

illustrer:

 temps

La commande peut être utilisée pour compter le temps d'exécution de la commande. Cette partie du temps comprend le temps d'exécution total, le temps d'exécution de l'espace utilisateur et le temps d'exécution de l'espace noyau.

 trace

Implémentation des appels système.

Grâce à la comparaison ci-dessus, on peut constater que

 (())

a la plus grande efficacité opérationnelle. et

 laisser

En tant que commande intégrée au Shell, elle est également très efficace, mais

 expression

,

 avant JC

,

 embarrassant

L'efficacité du calcul est relativement faible. Par conséquent, si le Shell lui-même peut réaliser le travail concerné, il est recommandé de donner la priorité aux fonctions fournies par le Shell lui-même. Mais il existe des fonctions que le Shell lui-même ne peut pas exécuter, telles que les opérations en virgule flottante, l'aide de commandes externes est donc nécessaire. De plus, compte tenu de la portabilité des scripts Shell, n'utilisez pas certaines syntaxes spécifiques à Shell lorsque les performances ne sont pas critiques.

 laisser

,

 expression

,

 avant JC

peut être utilisé pour trouver modulo, et les opérateurs sont tous

 %

,et

 laisser

et

 avant JC

Il peut être utilisé pour trouver l'exponentiation. Les opérateurs sont différents.

 **

, ce dernier est

 ^

. Par exemple:

Exemple : modélisation

 $ expr 5 % 21$ soit i=5%2$ echo $i1$ echo 5 % 2 bc1$ ((i=5%2))$ echo $i1

Exemple : exponentiation

 $ soit i=5**2$ echo $i25$ ((i=5**2))$ echo $i25$ echo 5^2 |

Exemple : conversion hexadécimale

La conversion de base est également une opération relativement courante que vous pouvez utiliser.

 Frapper

Prise en charge intégrée pour

 avant JC

Pour compléter par exemple la conversion de 11 en octal en décimal, vous pouvez :

 $ echo obase=10;ibase=8;11 | bc -l9$ echo $((8#11))9

Ce qui précède convertit les nombres d'un certain système de base en base 10. Si vous souhaitez effectuer une conversion entre n'importe quel système de base, toujours

 avant JC

Plus flexible car utilisable directement

 ibase

et

 obèse

Spécifiez respectivement la source de base et la cible de conversion de base.

Exemple : codage de caractères ascii

Si vous souhaitez exprimer certaines chaînes dans une base spécifique, vous pouvez utiliser

 oh

commande, telle que le séparateur par défaut

 IFS

y compris les espaces,

 LANGUETTE

En plus des sauts de ligne, vous pouvez utiliser

 homme ascii

preuve.

 $ echo -n $IFS |

arithmétique à virgule flottante

 laisser

et

 expression

Ni l'un ni l'autre ne peut effectuer d'opérations en virgule flottante, mais

 avant JC

et

 embarrassant

Peut.

Exemple : Divisez 1 par 13 en conservant 3 chiffres significatifs

 $ echo scale=3; 1/13 | bc.076$ echo 1 13 |

illustrer:

 avant JC

La précision doit être spécifiée lors de l'exécution d'opérations en virgule flottante, sinon elle est définie par défaut sur 0, c'est-à-dire que lors de l'exécution d'opérations en virgule flottante, le résultat par défaut ne conserve que les entiers. et

 embarrassant

Très flexible lors du contrôle du nombre de décimales, simplement en

 imprimer

Le contrôle du format peut être obtenu.

Supplément : En cours d'utilisation

 avant JC

Lors de l'exécution d'opérations, s'il n'est pas utilisé

 échelle

Spécifiez la précision lorsque vous êtes dans

 avant JC

ajouter après

 -l

option, des opérations en virgule flottante peuvent également être effectuées, mais la précision par défaut à ce moment est de 20 chiffres. Par exemple:

 $ écho 1/13100 | bc -l.00007633587786259541

Exemple : valeur du cosinus par rapport à l'angle

utiliser

 avant JC -l

Le calcul peut atteindre une grande précision :

 $ export cos=0,996293 ; échelle d'écho=100 ; a(sqrt(1-$cos^2)/$cos)*180/(a(1)*4) | -l4.9349547554113836327198340369318406051597063986552438753727649177325495504159766011527078286004072131

Bien sûr, il peut également être utilisé

 embarrassant

Pour calculer :

 $ echo 0.996293 | awk '{ printf(%sn, atan2(sqrt(1-$1^2),$1)*180/3.1415926535);}'4.93495

Exemple : Il existe un ensemble de données permettant de trouver le ménage ayant le revenu mensuel par habitant le plus élevé.

Un ensemble de données de test est généré ici de manière aléatoire et le nom du fichier est

 revenu.txt

.

 1 3 44902 5 38963 4 31124 4 47165 4 45786 6 53997 3 50898 6 30299 4 619510 5 5145

Remarque : Les trois colonnes de données ci-dessus correspondent au numéro de famille, à la taille de la famille et au revenu familial mensuel total.

Analyse : Afin de trouver la famille avec le revenu mensuel moyen le plus élevé, vous devez diviser les deux colonnes suivantes, c'est-à-dire trouver le revenu mensuel moyen de chaque famille, puis trier en fonction du revenu mensuel moyen pour trouver la famille avec les revenus les plus élevés.

accomplir:

 #!/bin/bash# gettopfamily.sh[ $# -lt 1 ] && echo veuillez saisir le fichier de revenus && exit -1[ ! -f $1 ] && echo $1 n'est pas un fichier && exit -1treatment=$1awk '{ printf(%d %0.2fn, 1 $, 3 $/2 $);}' $revenu trier -k 2 -n -r

illustrer:

 [ $# -lt 1 ]

: Nécessite la saisie d'au moins un paramètre,

 $#

Est le nombre de paramètres passés dans le Shell

 [ ! -f $1 ]

: Nécessite que le paramètre d'entrée soit un fichier,

 -f

Pour l'utilisation, voir

 test

Commande,

 test homme

 revenu=1$

: Attribuez les paramètres d'entrée à la variable de revenu, puis utilisez-la comme

 embarrassant

paramètres, c'est-à-dire les fichiers à traiter

 embarrassant

: Divisez la troisième colonne du fichier par la deuxième colonne pour trouver le revenu mensuel moyen Compte tenu de l'exactitude, deux chiffres de précision sont retenus.

 trier -k 2 -n -r

:Voici le résultat de

 embarrassant

La deuxième colonne du résultat

 -k 2

, c'est-à-dire que le revenu mensuel moyen est trié, trié par nombres

 -n

, et triés par ordre décroissant

 -r

.

Démo :

 $ ./gettopfamily.sh revenue.txt7 1696,339 1548,751 1496,674 1179,005 1144,5010 1029,006 899,832 779,203 778,008 504,83

Supplément : précédent

 revenu.txt

Les données sont générées de manière aléatoire. Lors de certaines expériences, il est souvent nécessaire de générer certaines données de manière aléatoire. Dans la section suivante, nous les présenterons en détail. Ici est généré

 revenu.txt

Script de données :

 #!/bin/bash# genrandomdata.shfor i in $(seq 1 10)do echo $i $(($RANDOM/8192+3)) $((RANDOM/10+3000))done

Remarque : également utilisé dans le script ci-dessus

 séquence

La commande génère une colonne de nombres de 1 à 10. L'utilisation détaillée de cette commande sera présentée plus en détail dans la dernière section de cet article.

nombre aléatoire

variables d'environnement

 ALÉATOIRE

Générez des nombres aléatoires de 0 à 32767, tandis que

 embarrassant

de

 rand()

La fonction peut générer des nombres aléatoires entre 0 et 1.

Exemple : obtenir un nombre aléatoire

 $ echo $RANDOM81$ echo | awk '{srand(); printf(%f, rand());}'0.237788

illustrer:

 srand()

Lorsqu'il n'y a pas de paramètre, l'heure actuelle est utilisée comme

 rand()

Un générateur de nombres aléatoires

 graine

.

Exemple : Générer aléatoirement un nombre de 0 à 255

peut passer

 ALÉATOIRE

somme échelonnée de variables

 embarrassant

milieu

 rand()

pour obtenir une amplification.

 $ expr $RANDOM / 128$ echo | awk '{srand(); printf(%dn, rand()*255);}'

Réflexion : Si vous souhaitez générer de manière aléatoire une adresse IP pour un certain segment IP, comment devez-vous procéder ? Voir exemple : Friendly obtient une adresse IP utilisable.

 #!/bin/bash# getip.sh -- obtenir automatiquement une adresse IP utilisable# auteur : falcon <[email protected]># mise à jour : mar. 30 octobre 23:46:17 CST 2007# définissez votre propre réseau, passerelle par défaut , et le délai d'expiration du ping commandnet=192.168.1default_gateway=192.168.1.1over_time=2# vérifie le adresse IP actuelle -c 1 $default_gateway -W $over_time[ $? -eq 0 ] && echo l'adresse IP actuelle est correcte && exit -1;while do :; eth0 ifconfig eth0  $net.$(($RANDOM /130 +2))  up # configurer la route de la passerelle par défaut ajouter le gw par défaut $default_gateway # vérifier la nouvelle configuration ping -c 1 $default_gateway -W $over_time # si cela fonctionne, terminez [ $? -eq 0 ] && breakdone

Remarque : Si votre adresse de passerelle par défaut n'est pas

 192.168.1.1

, veuillez le configurer vous-même

 passerelle_par défaut

(peut être utilisé

 route-n

commande pour afficher), car en utilisant

 siconfig

Lors de la configuration de l'adresse, vous ne pouvez pas la configurer comme adresse de passerelle, sinon votre adresse IP sera la même que celle de la passerelle, ce qui empêchera l'ensemble du réseau de fonctionner correctement.

Autres opérations

En fait, une série de nombres peut être générée via une boucle, mais pourquoi ne pas l'utiliser s'il existe des outils associés !

 séquence

C'est un si petit outil qui peut générer une série de nombres. Vous pouvez spécifier l'intervalle croissant des nombres ou le séparateur entre deux nombres adjacents.

Exemple : obtenir une série de nombres

 $ séq 512345$ séq 1 512345$ séq 1 2 5135$ séq -s : 1 2 51:3:5$ séq 1 2 14135791113$ séq -w 1 2 1401030507091113$ séq -s : -w 1 2 1401:03:05:07:09:11:13$ séq -f 0x%g 1 50x10x20x30x40x5

Une utilisation plus typique

 séquence

Par exemple, construisez des liens dans un format spécifique, puis utilisez

 wget

Téléchargez-les :

 $ pour i dans `seq -fhttp://thns.tsinghua.edu.cn/thnsebooks/ebook73/%02g.pdf 1 21`;do wget -c $i;

ou

 $ pour i dans `seq -w 1 21`;do wget -c http://thns.tsinghua.edu.cn/thnsebooks/ebook73/$i done ;

Supplément : en

 Frapper

Version 3 et supérieure, en

 pour

circulaire

 dans

Derrière, on peut passer directement

 {1..5}

Générez de manière plus concise des nombres de 1 à 5 (notez qu'il n'y a que deux points entre 1 et 5), par exemple :

 $ pour i dans {1..5} ; do echo -n $i ; done1 2 3 4 5

Exemple : compter le nombre d'occurrences de chaque mot dans une chaîne

Donnons d'abord une définition d'un mot : une série de caractères unique ou multiple composée de lettres.

Tout d’abord, comptez le nombre d’occurrences de chaque mot :

 $ wget -c http://tinylab.org$ cat index.html | sed -es/[^a-zA-Z]/n/g | grep -v ^$ trier |

Ensuite, comptez les 10 mots les plus fréquents :

 $ wget -c http://tinylab.org$ cat index.html | sed -es/[^a-zA-Z]/n/g | grep -v ^$ | -k 1 -r | tête -10 524 a 238 balise 205 href 201 classe 193 http 189 org 175 tinylab 174 www 146 div 128 titres

illustrer:

 index des chats.html

: Afficher le contenu du fichier index.html

 sed -es/[^a-zA-Z]/n/g

: Remplacez les caractères non alphabétiques par des espaces, en ne conservant que les caractères alphabétiques

 grep -v ^$

: supprimer les lignes vides

 trier

: Trier

 uniq -c

: Comptez le nombre de mêmes lignes, c'est-à-dire le numéro de chaque mot

 trier -n -k 1 -r

: D'après la première colonne

 -k 1

nombre

 -n

Ordre inverse

 -r

trier

 tête -10

: Supprimez les dix premières lignes

Exemple : compter le nombre d'occurrences d'un mot spécifié

Deux approches peuvent être envisagées :

Ne compte que les mots qui doivent être comptés

Utilisez l'algorithme ci-dessus pour compter le nombre de tous les mots, puis renvoyez les mots qui doivent être comptés à l'utilisateur

Cependant, les deux méthodes peuvent être mises en œuvre via la structure suivante. Examinons d'abord la première méthode :

 #!/bin/bash# statistic_words.shif [ $# -lt 1 ]; then echo Utilisation : basename $0 FILE WORDS .... exit -1fiFILE=$1((WORDS_NUM=$#-1))for n in $( seq $WORDS_NUM)do shift cat $FILE | sed -es/[^a-zA-Z]/n/g  | ^$ | trier | grep ^$1$ |

illustrer:

 si pièce d'état

: Nécessite au moins deux paramètres, le premier fichier de mots et les paramètres suivants sont les mots à compter.

 FICHIER=$1

 : Obtient le nom du fichier, qui est la première chaîne après le script

 ((WORDS_NUM=$#-1))

: Obtenez le nombre de mots, c'est-à-dire le nombre total de paramètres

 $#

moins le paramètre de nom de fichier (1)

 pour la partie boucle

: Passer en premier

 séquence

Générez une série de nombres de mots qui doivent être comptés,

 changement

est une variable intégrée au Shell (veuillez transmettre

 aider à changer

Obtenir de l'aide), il déplace les paramètres transmis par l'utilisateur à partir de la ligne de commande vers l'arrière dans l'ordre et utilise le paramètre actuel comme premier paramètre.

 1 $

, passé comme ça

 1 $

Vous pouvez parcourir tous les mots saisis par l'utilisateur (si vous y réfléchissez bien, cela ressemble à un indice de tableau). Vous pouvez considérer

 changement

Remplacez la phrase suivante par

 écho 1 $

test

 changement

Usage

Démo :

 $ chmod +x statistic_words.sh$ ./statistic_words.sh index.html tinylab linux python 175 tinylab 43 linux 3 python

Regardons la deuxième méthode, il nous suffit de modifier

 changement

La phrase suivante suffit :

 #!/bin/bash# statistic_words.shif [ $# -lt 1 ]; then echo ERREUR : vous devez saisir au moins 2 mots ; echo Utilisation : basename $0 FILE WORDS .... exit -1fiFILE=$1((WORDS_NUM= $#-1))pour n dans $(seq $WORDS_NUM)do shift cat $FILE sed | -es/[^a-zA-Z]/n/g  | grep -v ^$ trier |

Démo :

 $ ./statistic_words.sh index.html tinylab linux python 175 tinylab 43 linux 3 python

Explication : Évidemment, la première méthode est beaucoup plus efficace, car elle trouve les mots qui doivent être comptés à l'avance et les compte ensuite, alors que ce n'est pas le cas dans cette dernière méthode. En fait, si vous utilisez

 grep

de

 -E

option, nous n’avons pas besoin d’introduire de boucle, mais nous pouvons le faire avec une seule commande :

 $ cat index.html | sed -es/[^a-zA-Z]/n/g | grep -v ^$ trier | grep -E ^tinylab$|^linux$ |

ou

 $ cat index.html | sed -es/[^a-zA-Z]/n/g | grep -v ^$ | egrep ^tinylab$|^linux$ |

Description : Il faut faire attention à

 sed

Les commandes peuvent traiter les fichiers directement sans passer

 chat

Le résultat de la commande est ensuite transmis via le pipeline, ce qui peut réduire les opérations inutiles du pipeline, de sorte que la commande ci-dessus peut être simplifiée comme suit :

 $ sed -es/[^a-zA-Z]/n/g index.html | grep -v ^$ | egrep ^tinylab$|^linux$ |

On voit donc que ces commandes

 sed

,

 grep

,

 unique

,

 trier

Comme ils sont utiles. Bien qu’ils ne remplissent que des fonctions simples par eux-mêmes, grâce à certaines combinaisons, ils peuvent réaliser une variété de choses. À propos, il existe également une commande très utile pour compter les mots.

 toilettes -w

, vous pouvez également l'utiliser en cas de besoin.

Supplément : il est également mentionné dans le livre Advanced Bash-Scripting Guide

 iota

commande et

 facteur

commande, comme elle n’est pas disponible sur la machine, il n’y a pas de test.

 facteur

La commande peut générer tous les nombres premiers d’un certain nombre. comme:

 Facteur $ 100100 : 2 2 5 5

résumé

À ce stade, le calcul numérique de l'exemple de programmation Shell se termine. Cet article présente principalement :

Opérations sur les entiers, opérations sur virgule flottante, génération de nombres aléatoires et génération de séquences dans la programmation Shell

La différence entre les commandes intégrées de Shell et les commandes externes, et comment afficher leurs types et leur aide

Plusieurs façons d'exécuter des scripts Shell

Plusieurs commandes externes Shell couramment utilisées :

 sed

,

 embarrassant

,

 grep

,

 unique

,

 trier

attendez

Exemple : nombres croissants ; recherche du revenu mensuel moyen obtenu automatiquement ;

 IP

Adresse ; compter le nombre de mots

Autres : les utilisations associées telles que les listes de commandes, les tests conditionnels, etc. ont été couvertes dans les exemples ci-dessus, veuillez les lire attentivement.

Si vous avez le temps, veuillez le consulter.

matériel

Guide de script Bash avancé

poser treize questions

Douze articles sur les bases du shell

Manuel SED

Manuel d'utilisation AWK

Plusieurs forums de discussion Shell

LinuxSir.org

ChinaUnix.net

post-scriptum

Il m'a fallu plus de 3 heures pour finir d'écrire. Il est actuellement 23h33. Il est temps de retourner au dortoir et d'aller me coucher. Je corrigerai les fautes de frappe et ajouterai du contenu demain.

Le 31 octobre, certaines formulations ont été modifiées, un exemple de calcul du revenu mensuel moyen d'un ménage a été ajouté, un résumé et des références ont été ajoutés, et tous les codes ont été annexés.

La programmation Shell est une chose très intéressante, si vous réfléchissez à : l'exemple ci-dessus de calcul du revenu mensuel moyen d'un ménage, puis d'utilisation

 M$ Exceller

En comparant ce travail, vous constaterez que le premier est si simple et sans tracas, et qu'il vous donne un sentiment de facilité d'utilisation.