Discussion :

[karamaster]

Bonsoir, je suis débutant en programmation shell. J'ai deux fonctions. L'un affiche un message quand le disque est plein et l'autre affiche l'espace occupé par les processus en mémoire en Mo.

1ère fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function checkSpaceDisk()
 
{
#Extraction du nom des disques installés
for DISK in $(df -x tmpfs  -x devtmpfs |grep dev |awk -F ‘’ ‘’ ‘{ print $1}’ |cut -d/ -f 3)
 
Do
   #Espace disque utilisé
   espaceUtilise=$(df |grep grep -w « $DISM » |awk -F '' '' ‘{ print $5}’)
 
   #Espace disque total. Valeur retournée à la caractère G à la fin donc j'extrais les chiffres
   espaceTotal=$(df -x tmpfs  -x devtmpfs |grep dev |awk -F '' '' ‘{ print $2}’) |grep '-o [[:digit:]])')
 if [[ '' $espaceUtilise '' -eq  '' espaceTotal '' ]]; then
    Echo « Le disque $DISK est plein »
 
Fi
 
done
 
}

Message d'erreur

512 : nombre entier attendu comme expression


La fonction 2
A pour objectif d'extraire la quantité de mémoire occupée et à l'affiché en méga octet.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
function checkSpaceDisk()
{
   #Récupération de la mémoire totale
   totalMemoire=sudo cat /proc/meminfo |grep MemTotal
   #Liste de tous les processus avec tri
   listeProcessus=ps -eo pid, %mem --sort=-%mem
   #à partir de là, je n'avance plus. L'objectif c'est de parcourir la liste des processus et la quantité
   #extrait ces deux colonnes, convertir la quantité % en méga Octet avec l'opération
   #taille="$processusEnCours" * "$totalMemoire
}

[N_BaH]

Bonjour,

grep |awk | cut ce n'est pas possible ! awk* sait très bien faire tout ça tout seul.

attention : '' ce n'est pas " !
et $espaceTotal, ce n'st pas espaceTotal.

--
* awk est un langage à part entière; pourquoi ne pas utiliser perl, ou python ?!

[karamaster]

Merci, N_BAH, c'est dans un cadre pédagogique que je fais donc je dois utiliser les outils en conséquence.
Pour les guillemets c'est un petit souci avec mon clavier.

[jack-ft]

1ère fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function checkSpaceDisk()
 
{
#Extraction du nom des disques installés
for DISK in $(df -x tmpfs  -x devtmpfs |grep dev |awk -F ‘’ ‘’ ‘{ print $1}’ |cut -d/ -f 3)
 
Do
   #Espace disque utilisé
   espaceUtilise=$(df |grep grep -w « $DISM » |awk -F '' '' ‘{ print $5}’)
 
   #Espace disque total. Valeur retournée à la caractère G à la fin donc j'extrais les chiffres
   espaceTotal=$(df -x tmpfs  -x devtmpfs |grep dev |awk -F '' '' ‘{ print $2}’) |grep '-o [[:digit:]])')
 if [[ '' $espaceUtilise '' -eq  '' espaceTotal '' ]]; then
    Echo « Le disque $DISK est plein »
 
Fi
 
done
 
}

Message d'erreur

512 : nombre entier attendu comme expression

Le formatage de ton fichier est très très étrange. Peut-être est-ce le résultat d'une copie de Windoze ou un passage par W0RD ?

Comme dit N_BaH, il faut absolument corriger TOUS les guillemets typographiques et autres apostrophes et anti-apostrophes.

Par exemple, il faut changer:
awk -F ‘’ ‘’ ‘{ print $1}’ # avec des apostrophes typographiques (obliques à gauche et obliques à droite)
en
awk -F " " '{ print $1}' # avec des guillemets ascii et des apostrophes bien verticales
ou
awk -F ' ' '{ print $1}' # avec des apostrophes bien verticales
(j'ai fait exprès de ne pas utiliser la balise CODE pour qu'on voie bien les caractères erronés de ton code)


En plus de toutes les corrections pour le remettre correctement (si ce n'est déjà fait), comme le "grep grep" redoublé, il est possible que l'erreur 512 vienne de la ligne 13 (qui porte malheur) où je remplacerais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if [[ '' $espaceUtilise '' -eq  '' espaceTotal '' ]]; then  # avec des apostrophes doublées et un manque de dollar

par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

 if test "$espaceUtilise" -eq  "$espaceTotal"; then # avec des vrais guillemets d'informaticien et un petit dollar de plus

Tu noteras que la couleur des 2 bouts de code est différente dans ton navigateur.

[karamaster]

Les erreurs de " et ' sont dû au copier/coller et j'avais un petit souci avec mon clavier. Voici la capture de tous le code. le retour à la ligne de certaines lignes de code sont faits pour afficher tout le code de la ligne.
Est-ce que tu peux m'expliquer : if test ?

[Sve@r]

Bonjour

Est-ce que tu peux m'expliquer : if test

Au contraire des autres langages de prog, le shell n'évalue pas des expressions mais des programmes (ou des commandes).
Si un programme (ou une commande) retourne 0, elle est assimilée à vrai, et pas 0 c'est assimilé à faux (parce qu'il n'y a qu'une seule raison qui fait que la commande réussit, mais il peut y en avoir plein qui font qu'elle échoue)
Donc on peut évaluer n'importe quel programme (commande) pourvue qu'elle retourne un état 0/pas 0. Ainsi on peut avoir

• if grep (si le grep trouve)
• if read (si le read lit)
• if ls (si le ls s'exécute)
• etc etc etc...

La seule commande (à ma connaissance) qui ne respecte pas cette règle c'est expr qui renvoie 0 si tout s'est bien passé mais que ce qu'elle affiche ne vaut pas 0, 1 si tout s'est bien passé et qu'elle affiche 0 (?????), et autre chose si ça se passe mal

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
~$ expr 4; echo $?
4
0
~$ expr 0; echo $?
0
1
~$ expr eaz + 4; echo $?
expr: argument non entier
2

Et donc on ne peut pas demander if expr puisque le check sera considére faux si "expr" affiche 0 (alors que tout s'est pourtant bien passé).

La commande "test" est une commande comme les autres, sauf que son rôle est d'évaluer des expressions, et retourner 0 si l'expression est vraie et pas 0 si elle n'est pas vraie. Elle respecte donc la règle donc peut être checkée via if test .... De fait, c'est cette commande qui sert à évaluer les choses donc if test ... est l'instruction que l'on voie généralement le plus souvent dans un shell. D'où ici aussi.
Et la commande [ ... ] est juste un raccourci syntaxique de la commande test donc if test "toto" = "toto"; then echo "ok"; fi est équivalente à _{if [ "toto" = "toto" ]}; then echo "ok"; fi. Et la commande [[ ... ]] est la même mais en plus intelligent (elle sait par exemple gérer si un élément est vide, comprendra l'idée sous-jacente de ce type d'instruction "5" < 7 qui compare une string et un int, etc).

Et attention, c'est dangereux d'écrire ce genre de syntaxe for DISK in $(commande); do ...; done car si la commande renvoie (par exemple) 3 lignes avec sur chaque ligne une info sur 2 mots, le "for" se calant sur l'espace fera 6 itérations, en traitant à chaque fois une partie de l'info sans jamais traiter l'info en entier.

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
~$ for l in $(awk 'BEGIN {for (i=0; i < 10; i++) printf("%d %d\n", i, i*i)}'); do echo "[$l]"; done
[0]
[0]
[1]
[1]
[2]
[4]
[3]
[9]
[4]
[16]
[5]
[25]
[6]
[36]
[7]
[49]
[8]
[64]
[9]
[81]

Il vaut mieux lui préférer commande |while read DISK ; do ...; done car le read se cale sur le <return> terminant chaque ligne...

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
~$ awk 'BEGIN {for (i=0; i < 10; i++) printf("%d %d\n", i, i*i)}' |while read l; do echo "[$l]"; done
[0 0]
[1 1]
[2 4]
[3 9]
[4 16]
[5 25]
[6 36]
[7 49]
[8 64]
[9 81]

... ou sur sa jolie remplaçante while read DISK; do ...; done < <(commande) qui fait la même chose mais en évitant le pipe donc le sous-processus avec tous ses inconvénients.

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
~$ while read l; do echo "[$l]"; done < <(awk 'BEGIN {for (i=0; i < 10; i++) printf("%d %d\n", i, i*i)}')
[0 0]
[1 1]
[2 4]
[3 9]
[4 16]
[5 25]
[6 36]
[7 49]
[8 64]
[9 81]

[N_BaH]

[[ [...] comprendra l'idée sous-jacente de ce type d'instruction "5" < 7 qui compare une string et un int

test aussi sait le faire. Enfin, elle croit savoir le faire. , parce qu'en fait, tout comme [[, elle ne compare que des chaînes.
Que ce soit pour test ou [[, <, =, != et > sont des opérateurs lexicaux : ils comparent du texte.
les opérateurs arithmétiques sont : -eq, -ne,-lt, -le, -gt, et -ge.
et p'is c'est tout !

La seule commande (à ma connaissance) qui ne respecte pas cette règle c'est expr qui renvoie 0 si tout s'est bien passé mais que ce qu'elle affiche ne vaut pas 0, 1 si tout s'est bien passé et qu'elle affiche 0 (?????), et autre chose si ça se passe mal

je ne suis pas sûr de bien comprendre. L'évaluation arithmétique du shell fonctionne comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ ((0)); echo $?
1
$

[Sve@r]

test aussi sait le faire. Enfin, elle croit savoir le faire. , parce qu'en fait, tout comme [[, elle ne compare que des chaînes.

Non, elle ne sait pas faire. test "5" < 7 répond "bash: 7: Aucun fichier ou dossier de ce type" (c'est pas pour rien que j'ai utilisé le signe "<" dans mon exemple )

tout comme [[, elle ne compare que des chaînes.
Que ce soit pour test ou [[, <, =, != et > sont des opérateurs lexicaux : ils comparent du texte.

J'ai pas dit que c'était forcément une bonne idée que d'écrire [[ "5" < 7 ]], juste qu'elle arrivait à comprendre quelque chose. Qu'elle la comprenne à l'envers de ce que voulait l'auteur ben tant pis pour l'auteur (d'ailleurs perso je ne l'utilise jamais car je préfère que mon script plante si je me rate dans mes variables plutôt qu'il continue en faisant croire que tout s'est bien passé )

je ne suis pas sûr de bien comprendre. L'évaluation arithmétique du shell fonctionne comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ ((0)); echo $?
1
$

De fait, le status étant 1 (pas 0), malgré que la commande se soit bien exécutée, elle est vue (considérée, assimilée) comme fausse et ne peut pas être intégrée dans un "if" dans l'expression if expr ... pour quelqu'un qui, par exemple, essaierait cette façon de faire pour (encore une fois par exemple) checker le fait que l'opération puisse/ne puisse pas se faire...

[Jipété]

Bonsoir,

tu vas avoir des soucis : $5 n'est pas l'espace occupé en xyzBytes, c'est le pourcentage en %, c'est $3 que tu dois utiliser.
Regarde sur ma machine où sdb et sdc sont deux disques identiques partitionnés de la même manière (le second sert de sauvegarde au premier) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$ while read ligne; do echo "$ligne"; done < <(df -x tmpfs -x devtmpfs | grep -v Sys. | awk '{print $1 " " $2 " " $3 " " $4}')
/dev/sda1 200536336 35414928 154865024
/dev/sdb1 1720225688 810906172 821867460
/dev/sdc1 1720225688 812450808 820322824

(grep -v Sys. sert à supprimer la ligne d'en-tête des colonnes)
Si je rajoute $5 ça donne ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
/dev/sda1 200536336 35414932 154865020 19%
/dev/sdb1 1720225688 810906172 821867460 50%
/dev/sdc1 1720225688 812450808 820322824 50%

Et qu-est-ce que je peux bien faire avec ces valeurs en % à part les comparer à 100 %?
Donc $3, et à partir de là tu vas te rendre compte que l'espace total - l'espace libre ne correspond pas exactement à l'espace occupé, il y a des variations, on en a déjà parlé ici il y a quelques années.
Flemme de chercher et il fait vraiment trop chaud, mais il me semble qu'on avait conclu qu'il valait mieux utiliser stat pour avoir des valeurs plus correctes, exemple sur sdb1 d'un petit programme tiré du man :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Taille totale               :    1671960199168 octets
Espace utilisé              :     830367932416 octets
Espace disponible           :     841592266752 octets

Voir man 2 statfs mais c'est du C, plus du shell...

Ah, pour avoir les valeurs en octets (plus précis), utilise df -B1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
while read ligne; do echo "$ligne"; done < <(df -B1 -x tmpfs -x devtmpfs | grep -v Sys. | awk '{print $1 " " $2 " " $3 " " $4}')
/dev/sda1 205349208064 36267986944 158578683904
/dev/sdb1 1761511104512 830367956992 841592242176
/dev/sdc1 1761511104512 831949627392 840010571776

Et tu t'amuseras à comparer les valeurs pour sdb1 dans les deux cas, avec df ci-dessus et avec statfs juste avant...

[N_BaH]

non. pas grep | awk; seulement awk '!/Sys/{print $1,$2,$3,$4}'.
mais, étant donné que la sorite de df peut être paramétrée pour n'afficher que les champs voulus, ce sera seulement df --exclude-type=tmpfs,devtmpfs --output=... | tail -n+2

[Jipété]

Yep !

Pas mal !
Des trucs que je ne connaissais pas, mais un cafouillage avec --exclude-type= (ou un problème de distro ?) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
$ while read ligne; do echo "$ligne"; done < <(df -B1 --exclude-type=tmpfs,devtmpfs --output=source,itotal,iused,iavail | tail -n+2)
udev               1771100    462   1770638
tmpfs              1794069    800   1793269
/dev/sda1         12804096 383937  12420159
tmpfs              1794069      1   1794068
tmpfs              1794069      4   1794065
tmpfs              1794069     25   1794044
/dev/sdb1        109297664 165583 109132081
/dev/sdc1        109297664 286644 109011020
tmpfs               358813     66    358747

donc retour à l'origine :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$ while read ligne; do echo "$ligne"; done < <(df -B1 -x tmpfs -x devtmpfs --output=source,itotal,iused,iavail | tail -n+2)
/dev/sda1         12804096 383937  12420159
/dev/sdb1        109297664 165583 109132081
/dev/sdc1        109297664 286644 109011020

En fait, après tests, il faut utiliser --exclude-type=tmpfs --exclude-type=devtmpfs, qui ne présente aucun intérêt par rapport à -x valeur1 -x valeur2, dommage.

EDIT :
Aparté : comme l'aide n'est pas claire sur l'utilisation des noms dans FIELD_LIST, j'ai fait le test suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ while read ligne; do echo "$ligne"; done < <(df -B1 -x tmpfs -x devtmpfs --output=source,fstype,itotal,iused,iavail,ipcent,size,used,avail,pcent,file,target)
Sys. de fichiers Type    Inœuds IUtil.    ILibre IUti%   blocs de 1B      Utilisé        Dispo Uti% Fichier Monté sur
/dev/sda1        ext4  12804096 383963  12420133    3%  205349208064  36280119296 158566551552  19% -       /
/dev/sdb1        ext4 109297664 165583 109132081    1% 1761511104512 830367956992 841592242176  50% -       /data
/dev/sdc1        ext4 109297664 286644 109011020    1% 1761511104512 832030683136 839929516032  50% -       /dbck

Quelqu'un pourra nous expliquer la différence entre IUti% et Uti% ?
Même question pour IUtil. et Utilisé, et pour ILibre et Dispo.
Merci,

[Sve@r]

En fait, après tests, il faut utiliser --exclude-type=tmpfs --exclude-type=devtmpfs, qui ne présente aucun intérêt par rapport à -x valeur1 -x valeur2

C'est la même option. Mais généralement je préfère mettre (dans mes scripts) les options longues plus explicites, et les options courtes quand je lance la commande ponctuellement.
Ensuite si on exclut certains types de montages, on peut alors aussi se poser la question pour les montages de type cdrom et les montages NFS....

[papajoker]

Yep !
Quelqu'un pourra nous expliquer la différence entre IUti% et Uti% ?
Même question pour IUtil. et Utilisé, et pour ILibre et Dispo.

Dans la doc i pour inode

‘itotal’
Total number of inodes.
‘iused’
Number of used inodes.
‘iavail’
Number of available inodes.
‘ipcent’
Percentage of IUSED divided by ITOTAL.

----------

espace libre ne correspond pas exactement à l'espace occupé

ici, c'est un exercice, de toute façon, il n'y a pas d'intérêt à calculer la taille d'une partition : si il reste 5 octets , il reste de la place mais on ne peut rien faire (et même avec 1Go de libre, on peut avoir aussi le même problème si on désire copier un "énorme" fichier)

----------

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$ while read ligne; do echo "$ligne"; done < <(df -B1 --exclude-type=tmpfs,devtmpfs --output=source,itotal,iused,iavail | tail -n+2)

bien sûr, ici le while.. done < < n'a aucun intérêt sinon ajouter du code complètement inutile

[N_BaH]

cafouillage avec --exclude-type= (ou un problème de distro ?)

non, non. c'est moi qui gatouille.

[Jipété]

Dans la doc i pour inode

Merci pour l'info, pas dispo dans mon man.

ici, c'est un exercice, de toute façon, il n'y a pas d'intérêt à calculer la taille d'une partition : si il reste 5 octets , il reste de la place mais on ne peut rien faire (et même avec 1Go de libre, on peut avoir aussi le même problème si on désire copier un "énorme" fichier)

Certes, mais il n'est pas interdit de prendre de bonnes habitudes et au lieu de tester sur espace total = espace utilisé, on pourrait utiliser (pseudo-code) if espace_utilisé > 90% alors alerte, tout comme if taille_fichier_à_copier > espace_libre alors alerte.

bien sûr, ici le while.. done < < n'a aucun intérêt sinon ajouter du code complètement inutile

Bien vu, du coup il n'y a plus que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
df -B1 -x tmpfs -x devtmpfs --output=source,size,used,avail | tail -n+2
/dev/sda1         205349208064  36283375616 158563295232
/dev/sdb1        1761511104512 830367965184 841592233984
/dev/sdc1        1761511104512 832030683136 839929516032

[karamaster]

Yep !

Pas mal !
Des trucs que je ne connaissais pas, mais un cafouillage avec --exclude-type= (ou un problème de distro ?) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
$ while read ligne; do echo "$ligne"; done < <(df -B1 --exclude-type=tmpfs,devtmpfs --output=source,itotal,iused,iavail | tail -n+2)
udev               1771100    462   1770638
tmpfs              1794069    800   1793269
/dev/sda1         12804096 383937  12420159
tmpfs              1794069      1   1794068
tmpfs              1794069      4   1794065
tmpfs              1794069     25   1794044
/dev/sdb1        109297664 165583 109132081
/dev/sdc1        109297664 286644 109011020
tmpfs               358813     66    358747

donc retour à l'origine :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$ while read ligne; do echo "$ligne"; done < <(df -B1 -x tmpfs -x devtmpfs --output=source,itotal,iused,iavail | tail -n+2)
/dev/sda1         12804096 383937  12420159
/dev/sdb1        109297664 165583 109132081
/dev/sdc1        109297664 286644 109011020

En fait, après tests, il faut utiliser --exclude-type=tmpfs --exclude-type=devtmpfs, qui ne présente aucun intérêt par rapport à -x valeur1 -x valeur2, dommage.

EDIT :
Aparté : comme l'aide n'est pas claire sur l'utilisation des noms dans FIELD_LIST, j'ai fait le test suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
$ while read ligne; do echo "$ligne"; done < <(df -B1 -x tmpfs -x devtmpfs --output=source,fstype,itotal,iused,iavail,ipcent,size,used,avail,pcent,file,target)
Sys. de fichiers Type    Inœuds IUtil.    ILibre IUti%   blocs de 1B      Utilisé        Dispo Uti% Fichier Monté sur
/dev/sda1        ext4  12804096 383963  12420133    3%  205349208064  36280119296 158566551552  19% -       /
/dev/sdb1        ext4 109297664 165583 109132081    1% 1761511104512 830367956992 841592242176  50% -       /data
/dev/sdc1        ext4 109297664 286644 109011020    1% 1761511104512 832030683136 839929516032  50% -       /dbck

Quelqu'un pourra nous expliquer la différence entre IUti% et Uti% ?
Même question pour IUtil. et Utilisé, et pour ILibre et Dispo.
Merci,

Bonsoir, désolé pour le retour tardif. J'essayais de comprendre également les différentes solutions.
Je suis arrivé à ce code qui marche. Merci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
 
while read ligne; 
do 
 nomDisque=$(echo "$ligne" | cut -d ' ' -f1)
 tailleDisque=$(echo "$ligne" | cut -d ' ' -f2)
 if [ "$tailleDisque" -eq 0 ]; then
      echo "Le disque $nomDisque est plein
 fi
done < <(df -x tmpfs -x devtmpfs | grep -v Sys. | awk '{print $1 " " $4}'

Pour ma seconde préoccupation. Il s'agit d'afficher tous les processus qui occupent par exemple 20Mo de mémoire.
Dans un premier temps, j'extrais la taille total de la mémoire.
Ensuite le pourcentage avec la commande ps et enfin je multiplie le pourcentage par la mémoire total divisé par 100.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
totalMemoire=sudo cat /proc/meminfo |grep MemTotal |awk '{print $2}'
 
while read ligne; 
do 
 memoire=$(echo "$ligne" | awk '{print $2}')
 
 if [ "$memoire" != 0 ]; then
      tailleOccupee=$(echo "$memoire" * "$totalMemoire" /100)
      echo "$tailleOccupee" 
 fi
done < <(ps aux --no-headers | awk '{print $2 " " $4}')

RESULTAT : Rien en sortie.

[Sve@r]

totalMemoire=sudo cat /proc/meminfo |grep MemTotal |awk '{print $2}'.

RESULTAT : Rien en sortie.

Ce n'est pas la bonne syntaxe pour placer le résultat d'une commande dans une variable. Et tu la connais puisque tu l'emploies correctement en lignes 7 et 10.
Accessoirement le sudo ne sert à rien (le fichier /proc/meminfo est accessible en lecture). Et puis cat fic |grep ... s'écrit plus simplement grep ... fic (et passer par fgrep quand c'est possible est plus rapide ou alors préciser que la chaine cherchée est au début de la ligne permet là aussi d'optimiser la recherche). Et N_BaH a donné il n'y a pas si longtemps que ça la syntaxe pour faire chercher directement par le awk.

if [ "$memoire" != 0 ]

On compare les chiffres avec -eq, -ne, -gt, -ge, -lt, -le. Ca semble équivalent au premier regard mais pas au second. Exemple [ 00 = 0 ] est faux tandis que [ 00 -eq 0 ] est vrai. Ceci dit, malheureusement, ni l'un ni l'autre ne fonctionneront avec un float.

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
while read ligne; do 
 memoire=$(echo "$ligne" | awk '{print $2}')
 
 if [ "$memoire" != 0 ]; then
      tailleOccupee=$(echo "$memoire" * "$totalMemoire" /100)
      echo "$tailleOccupee" 
 fi
done < <(ps aux --no-headers | awk '{print $2 " " $4}')

A quoi sert d'avoir récupéré $2 dans le "ps" puisque tu n'utilises (après donc l'avoir récupéré via un autre awk alors que cut, plus petit donc plus rapide, aurait parfaitement pu le faire) que $4 ???
Et puis aussi... je ne suis pas certain que "echo" sache faire un calcul. A mon avis, quand il va traiter l'étoile, ça va merder grave à l'affichage...

Code bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
if [ "$tailleDisque" -eq 0 ]; then
      echo "Le disque $nomDisque est plein"
fi

A mon avis, l'OS t'aura prévenu depuis bien longtemps...

[N_BaH]

accessoirement, cat non plus !
et grep aussi, non plus.

edit : et il est possible de paramétrer la sortie de ps pour n'afficher que les champs dont on a besoin. Ainsi, même awk n'est plus nécessaire.
ne reste que le calcul, qu'on peut ne pas faire ligne par ligne :

Code /bin/bash :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
$ mem=( $(ps hax -o %mem) )
$ echo $(IFS='+'; echo "${mem[*]}") | bc -l
35.1
$

[Jipété]

Bonjour,

On compare les chiffres avec -eq, -ne, -gt, -ge, -lt, -le.

les nombres ! J'ai testé, voir tout en bas.

quand je tape help test, il me vient une petite page sympathique récapitulant les options de base pour les tests, mais une ligne me pose problème, vers la fin :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
      arg1 OP arg2   Arithmetic tests.  OP is one of -eq, -ne, -lt, -le, -gt, or -ge.
 
    Arithmetic binary operators return true if ARG1 is equal, not-equal,
    less-than, less-than-or-equal, greater-than, or greater-than-or-equal
    than ARG2.

en français (et je rajoute les traits d'union sinon c'est parfois pas clair) ,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
    les opérateurs binaires arithmétiques renvoient vrai si ARG1 est égal-à, non-égal-à,
    inférieur-à, inférieur-ou-égal-à, supérieur-à ou supérieur-à-ou-égal-à ARG2.

En gros j'en conclus ça renvoie toujours vrai. Ou je n'ai rien compris ?

Merci pour les lumières,

EDIT
Bon, j'ai fait ça,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
$ a=5
$ b=3
$ [ $a -eq $b ] && echo "a=b"
$ [ $a -ne $b ] && echo "a<>b"
a<>b
$ [ $a -lt $b ] && echo "a<b"
$ [ $a -le $b ] && echo "a<=b"
$ [ $a -gt $b ] && echo "a>b"
a>b
$ [ $a -ge $b ] && echo "a>=b"
a>=b

qui prouve noir sur blanc qu'"ils" se sont trompés en rédigeant leur ligne d'aide, ou alors faudra bien m'expliquer.

Et ça fonctionne tout pareil avec [ $((a)) -OP $((b)) ] && echo "texte" mais l'avantage, c'est qu'on peut faire des opérations, là, genre [ $((a-2)) ... et ça, c'est bien sympa.

quant aux nombres, j'ai testé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$ a=5
$ b=3
$ [ $((a+7)) -eq $((b*4)) ] && echo "a=b"
a=b
$ [ $((a+7)) -eq $((b*4)) ] && echo $(((a+7))+((b*4)))
24

[Flodelarab]

Les opérateurs binaires. C'est là que traduire n'est pas pertinent.
-eq equal
-ne not equal
-lt less than
-le less or equal
-gt greater than
-ge greater or equal

Mais aussi -ot older than par exemple

La ligne d'aide explicite en masse les opérateurs définis sans explications.