Pour sortir de la boucle bash. BASH : description des boucles for, while, until et exemples d'utilisation

Et maintenant, le tour du cinquième sujet du cycle est venu. Dans ce document, je continuerai à examiner les structures de contrôle du shell bash. Le post précédent couvrait les instructions conditionnelles. Il est maintenant temps pour des structures de langage intégrales telles que les instructions de boucle. Les boucles, comme les conditions, sont des outils qui permettent de contrôler l'ordre dans lequel les commandes sont exécutées.
Bash prend en charge les boucles for, while, until et select. Examinons maintenant de plus près chacun d'eux.

pour l'instruction de la boucle

La syntaxe générale de l'instruction for est la suivante :

pour variables
faire
liste de commandes
fait

La boucle for de bash est assez différente de la boucle for des langages de programmation tels que C ou PHP. Donc, si vous êtes un programmeur C, vous devrez vous habituer à ces différences afin de ne pas vous perdre.
À la suite de la substitution de modèle, une liste de mots est obtenue. A chaque itération, la variable prend chaque valeur suivante de cette liste, et les commandes entre do et done sont exécutées. Les itérations s'arrêtent lorsque les mots de la liste sont épuisés.
$ for day in Mon Tue Wed Thu Fri do echo "Today $day" done
Les mots réservés de l'instruction for peuvent également être écrits sur une seule ligne, comme c'était le cas dans le post précédent pour l'instruction if. Pour ce faire, mettez ";". Réécrivons l'exemple précédent en gardant cette fonctionnalité à l'esprit :
$ par jour en Lun Mar Mer Jeu Ven; do echo "Aujourd'hui c'est $jour" ; fait
L'absence de construction équivaut à écrire en [courriel protégé]À propos du paramètre [courriel protégé] dit dans .

instruction de boucle while

La syntaxe générale de l'instruction while est :

tandis que liste1
faire
liste2
fait

List1 est exécuté en premier. S'il réussit, c'est-à-dire renvoie le code zéro, le contrôle passe à list2. Les itérations continuent jusqu'à ce que le résultat de l'exécution de list1 devienne différent de zéro. Par exemple:
i=10 tant que [ $i -gt 0 ] ; faire echo $i i=$(($i-1)) fait ; echo "fin"

jusqu'à l'instruction de boucle

La syntaxe générale de l'instruction until est :

jusqu'à la liste1
faire
liste2
fait

List1 est exécuté en premier. S'il échoue, c'est-à-dire avec un code de retour différent de zéro, le contrôle passe à list2. Les itérations continuent jusqu'à ce que le résultat de l'exécution de list1 devienne zéro. Par exemple:
i=10 jusqu'à [ $i -lt 0 ] ; faire echo $i i=$(($i-1)) fait ; echo "fin"

sélectionnez l'instruction de boucle

La syntaxe générale de l'instruction select est :

sélectionner une variable
faire
liste
fait

À la suite de la substitution de modèle, une liste de mots est obtenue. L'opérateur ajoute des numéros de série à ces mots et envoie l'ensemble complet au flux d'erreur standard. L'absence de construction équivaut à écrire en [courriel protégé] Après cela, une invite s'affiche et une ligne est lue à partir du flux d'entrée standard. Si la chaîne contient un nombre correspondant à n'importe quel mot de la liste, la variable obtient ce nombre comme valeur. Si un mot approprié n'a pas été trouvé, la valeur de la variable devient une chaîne vide. Après cela, la liste des commandes est exécutée et l'itération continue jusqu'à ce que le caractère de fin de fichier soit trouvé dans la ligne d'entrée ou jusqu'à ce que break ou return soit rencontré dans la liste des commandes.
Les commandes break et return sont utilisées pour contrôler la progression de la boucle. La commande break interrompt l'exécution de la boucle, tandis que return renvoie un code de résultat (zéro ou non nul).
L'instruction select est utile pour créer des menus numérotés. Par exemple, dans le répertoire ~/temp il y a 3 fichiers : proto.txt, file.txt et readme. Un exemple de fragment de script qui vous permet de visualiser rapidement n'importe lequel d'entre eux.
echo "Sélectionnez le fichier à afficher :" sélectionnez le fichier dans ~/temp/* Quitter ; faire si [ -f $fichier ]; puis chat $fichier; sinon casser; fi fait
En exécutant ce script, nous verrons à l'écran :
Sélectionnez un fichier à afficher :
1) /home/istergul/temp/fichier.txt
2) /home/istergul/temp/proto.txt
3) /home/istergul/temp/readme
4) Quitter

La rubrique suivante examinera les substitutions de paramètres conditionnels. J'attends tes commentaires avec impatience.

Dans cette conférence, nous continuons à nous familiariser avec frapper. Je tiens à vous rappeler que nous examinons ces éléments frapper pour nous aider à comprendre les scripts système opérateur. Ces éléments sont certainement des cycles et des fonctions. Si quelqu'un a étudié la programmation, il n'y aura aucune difficulté à comprendre ces problèmes.

pour la boucle

Cycle pour V frapper a deux types. Considérons d'abord la version classique pour. La vue générale est la suivante :

Entre éléments pour Et dans une variable est définie, qui à son tour prend une valeur à partir d'une séquence de valeurs données entre dans Et faire. Entre faire Et fait il y a des commandes qui sont exécutées à chaque fois que la variable change de valeur. La boucle s'arrête lorsque la variable prend la dernière valeur de la séquence. Les valeurs de la séquence sont séparées par un espace.

Et voici un exemple pratique :

La séquence de valeurs peut être spécifiée de différentes manières. Explicitement - comme dans l'exemple ci-dessus, ou à l'aide d'autres variables, ou à l'aide de commandes spéciales. Regardons quelques exemples. Étant donné que les valeurs sont séparées par un espace, toute variable contenant une chaîne avec des espaces peut être utilisée comme telles valeurs :

Le résultat sera le même que dans le premier exemple.

Si vous devez spécifier une séquence de nombres, vous pouvez utiliser la commande suite et mécanisme de substitution. Équipe suite renvoie une séquence de valeurs numériques à l'écran. La syntaxe est simple et sera claire à partir de l'exemple ci-dessous :

Résultat:

Revenons au second type. pour. Souvent, dans les scripts, vous pouvez trouver l'option dite de type C pour, qui est utilisé pour les boucles basées sur des nombres. Prenons un exemple :

La boucle est exécutée tant que la condition vérifiée dans l'expression est vraie. Dès que l'expression renvoie faux, la boucle est terminée.

Exemple pratique :

#!/bin/bash
je=1
tandis que [ $i -lt 7 ]
faire
écho $i
soit i=i+1
fait

Dans notre exemple, nous vérifions que la variable je inférieur à (-lt), le nombre 7 et si oui, alors la valeur de la variable est affichée. Expression soit i=i+1, incrémente la variable de un, vérifie à nouveau, etc. let indique à l'interpréteur que les arguments doivent être traités comme des valeurs numériques. Cette ligne pourrait s'écrire laisse moi ++(variante de type c). Lorsque le nombre est augmenté de plus d'un, il peut s'écrire : Soit i+=2- dans ce cas je augmentera par pas de 2. Une autre façon d'augmenter une variable est d'utiliser la calculatrice intégrée (ne fonctionne qu'avec des nombres entiers). Le calculateur est accessible par des doubles parenthèses : je=$(($i+1)) ou par carré : je=$[$i+1] Vous pouvez également utiliser la calculatrice en ligne de commande :

Avec les boucles, vous devez faire attention à ne pas avoir l'option d'une boucle infinie. Au fait pour le débogage frapper scripts, vous pouvez remplacer la première ligne par #!/bin/bash-x ou exécutez le script avec la commande bash-x:

[courriel protégé]:~/linux$ bash -x ./testfor.sh
+ je=1
+ ‘[‘ 1 -gt 5 ‘]’
+ écho i=1
je=1
+ soit i=i+1
+ ‘[‘ 2 -gt 5 ‘]’
+ écho i=2
je=2
+ soit i=i+1
+ ‘[‘ 3 -gt 5 ‘]’
+ écho i=3
je=3
+ soit i=i+1
+ ‘[‘ 4 -gt 5 ‘]’
+ écho i=4
je=4
+ soit i=i+1
+ ‘[‘ 5 -gt 5 ‘]’
+ écho i=5
je=5
+ soit i=i+1
+ ‘[‘ 6 -gt 5 ‘]’

Assurez-vous de vous entraîner à écrire de petits scripts pour consolider votre compréhension du fonctionnement des boucles dans frapper.

Fonctions en bash

Les fonctions s'appliquent dans frapper très large. Les fonctions sont décrites de deux manières : avec un mot-clé fonction, et sans elle.

Première manière :

fonction nom_fonction
{
corps de fonction
}

Deuxième manière :

nom_fonction()
{
corps de fonction
}

La fonction est appelée par son nom n'importe où dans le script, mais seulement après la description de la fonction elle-même. Les fonctions peuvent également recevoir des paramètres, qui sont spécifiés avec un espace après l'appel (nom) de la fonction. Prenons un exemple de script frapper:

#!/bin/bash
amorce de fonction
{
si [ $# -ne 0 ]
alors
locale a=1
echo "Nombre de paramètres passés - $#"
pour moi dans [courriel protégé]
faire
echo "$ un-ième paramètre— $i"
laisse a++
fait
retour 0
autre
echo "Aucun paramètre passé"
retour 1
Fi
}
echo "Appel d'une fonction avec paramètres :"
amorce a b c
echo $?
echo "Appel d'une fonction sans paramètre :"
apprêt
echo $?

DANS cet exemple donné une fonction nommée apprêt. Appel d'une fonction avec paramètres : amorce a b c et sans paramètre : apprêt. Dans le corps de la fonction, toutes les constructions doivent vous être familières, à l'exception de $# , $i Et [courriel protégé] .$# - renvoie le nombre de paramètres passés à la fonction. Dans notre exemple, ce sera le nombre 3 .[courriel protégé] renvoie tous les paramètres sur une seule ligne. Dans l'exemple, ce serait un bc. Et à travers $1 , $2 , $3 etc. vous pouvez accéder à chaque paramètre individuellement. $? - contient le code d'exécution de la dernière commande. Dans notre exemple, le code d'exécution de la fonction.

La fonction peut aussi retourner valeur numérique par mot-clé retour. En règle générale, ils renvoient 0 si la fonction s'est terminée sans erreur, ou une valeur non nulle si quelque chose s'est mal passé. Dans l'exemple, en cas d'appel de fonction avec paramètres, la valeur 0 est retournée, et si la fonction a été appelée sans paramètres, le code 1 sera retourné.

Tout ce qui concerne le passage de paramètres à une fonction fonctionne exactement de la même manière pour un script. Vous pouvez également passer des paramètres à un script et les manipuler de la même manière en utilisant $#, [courriel protégé], $N. De même catégorie et option - $0 - qui retourne le nom de la commande qui a lancé le script. Si le script a été exécuté sur commande ./script.sh, puis écho $0 renverra une valeur ./script.sh, et si sur commande /home/igor/linux/script.sh, alors la valeur sera renvoyée /home/igor/linux/script.sh.

L'une des règles de base de l'administration système peut être exprimée comme suit : si vous devez faire souvent la même chose, écrivez un script et laissez-le faire le travail pour vous. Si vous devez effectuer plusieurs fois une action dans le script, vous devez utiliser cycles. DANS Coup de GNU vous pouvez créer des boucles avec des constructions pour, alors que Et jusqu'à.

Si vous vous êtes déjà intéressé à la programmation, il y a de fortes chances que vous connaissiez déjà ces constructions. Si, comme moi, vous étudiez frapper Si vous n'avez aucune expérience en programmation derrière vous, l'utilisation des boucles peut ne pas être assez évidente pour être comprise. Commençons par identifier les différences entre divers types cycles, puis passez aux exemples.

Cycle pour est conçu pour répéter des actions jusqu'à ce qu'elles soient toutes terminées. Imaginez, par exemple, que vous ayez un répertoire d'images et que vous ayez besoin de les convertir d'un format à un autre. Vous pouvez utiliser une boucle pour avec le programme convertir du paquet ImageMagick(ou un autre programme), par exemple, pour convertir des images du format JPEG au format PNG. Ou, par exemple, vous devrez peut-être convertir un grand nombre de fichiers audio à partir de MP3 V OGG Vorbis.

Cycle alors que utilisé pour répéter des actions Au revoir effectué (est vrai) certaines conditions. Cycle jusqu'à fonctionne un peu différemment : il effectue une action jusqu'à jusqu'à ce que la condition soit remplie. Ainsi, par exemple, vous pouvez contrer et effectuer une action jusqu'à jusqu'à ce que sa valeur atteigne 10. Regardons cela plus en détail avec des exemples.

Commençons par une boucle pour. Son format est :

Pour je dans $(commande); faites la commande $i ; fait

Si vous utilisez une boucle pour dans un script, il vaut mieux le formater comme ceci :

#!/bin/bash pour i dans $(commande); faites la commande $ j'ai terminé

Ainsi, par exemple, si vous devez faire sauvegardes tous les fichiers HTML du répertoire, vous pouvez utiliser la commande suivante :

Pour je dans $(ls *html); do cp $i $i.bak ; fait

Cela crée une variable locale $i, la commande est exécutée ls*html, dont les résultats seront les données qui initialisent la valeur de la variable $ià chaque itération de la boucle (dans notre exemple, ce sera la liste des fichiers retournés par la commande ls, un pour chaque itération). Ensuite, la commande est exécutée CP, auquel une variable est passée parmi les paramètres $i.

Quelqu'un pourrait demander s'il est obligatoire d'utiliser la lettre "je" comme nom de variable ? Non. Vous pouvez utiliser n'importe quel frapper Nom de variable. Bien sûr, il est préférable d'utiliser des noms de variables plus significatifs dans les scripts, comme $entrée ou $html.

J'ai donné un exemple très court et simple d'utilisation d'une boucle pour. Au lieu d'une commande s'exécutant dans un bloc faire,utiliser écho afin de voir les paramètres qui lui sont passés. C'est une pratique très utile au stade des tests de scripts, ainsi que bonne façon vous aider à comprendre votre travail plus en détail pour.

pendant et jusqu'à

Considérons maintenant les constructions alors que Et jusqu'à. De plus, nous utiliserons des conditionnels bash. Dans notre exemple, nous les utiliserons pour déterminer, par exemple, si la valeur d'une variable est supérieure ou inférieure au nombre X ; si le fichier existe et s'il s'agit d'un répertoire. Vous pouvez également utiliser des conditions pour déterminer, par exemple, si un fichier est lisible ou a un bit GID dans ses autorisations.

Essayons de faire quelque chose de simple comme créer des fichiers vides. Dans la vie, il est peu probable que cela vous soit utile, mais à titre d'exemple, c'est la chose même.

#!/bin/bash i=0 while [ $i -lt 22 ] do touch $i i=$[$i+1] done

Ce script créera 22 fichiers avec des noms de 0 à 21. La boucle s'exécutera jusqu'à Au revoir valeur variable $i moins ( -lt) 22.

Maintenant, débarrassons-nous des fichiers générés avec une boucle jusqu'à:

#!/bin/bash i=0 jusqu'à [ $i -eq 22 ] faire rm $i i=$[$i+1] fait

Ici, nous avons remplacé alors que sur jusqu'à, et dans l'expression conditionnelle nous avons remplacé "moins" (-lt) sur "équivaut à" (-eq). Ainsi, notre script fonctionnera tant que la valeur $i n'atteindra pas 22. Et au lieu de touche Nous avons utilisé rm pour supprimer des fichiers au lieu de les créer. Simple, non ?

Les boucles sont une chose extrêmement pratique lors de l'écriture de programmes ou de scripts, ou plutôt une chose nécessaire. Ils nous permettent d'exécuter un morceau de code un certain nombre de fois. Naturellement, bash a plusieurs types de boucles. Nous décrirons les cycles pour dans, pour, pendant que, jusqu'à. Bien que for in et for soient considérés comme des syntaxes différentes pour la même instruction, à mon avis, ils diffèrent plus l'un de l'autre que while from until.

Boucle avec compteur pour in:

Cycle pour dans c'est une boucle avec un compteur. Le bloc de code situé dans le corps de la boucle est répété autant de fois qu'il y a de valeurs dans la liste de l'opérateur for in, tandis qu'à chaque répétition la variable compteur (ici elle s'appelle var, mais bien sûr vous pouvez appelez-le comme vous voulez) a la valeur de l'élément suivant de la liste.
Si le mot-clé do est sur la même ligne que le mot for, alors après la liste des arguments (avant do) vous devez mettre un point-virgule.
Chacun des éléments<список>peut contenir plusieurs arguments. Ceci est utile lors du traitement de groupes de paramètres. Dans ce cas, pour forcer l'analyse de chacun des arguments dans<списке>, vous devez utiliser l'instruction set
Vous pouvez utiliser une variable comme liste dans une boucle for.
DANS<списке>pour les boucles, des noms de fichiers peuvent être utilisés, qui à leur tour peuvent contenir des caractères génériques. Cela peut être très utile lorsque vous travaillez avec un grand nombre de fichiers.
Si<список>n'est pas spécifié dans la boucle for, alors la variable est utilisée telle quelle [courriel protégé]- liste des arguments de la ligne de commande.
Lors de la création d'une liste d'arguments, la substitution de commande peut être utilisée dans la boucle for.
La sortie de la boucle peut être redirigée de stdout vers un fichier ou ailleurs (vous pouvez en savoir plus à ce sujet en analysant la redirection d'E/S).

Syntaxe:
pour var dans<список>
faire
<выполняемые команды>
fait

Exemple:
pour les noms dans nom1 nom2 nom3 nom4
faire
echo $noms
fait

Instruction de boucle pour a une autre façon d'écrire - très similaire à la syntaxe de l'opérateur for dans le langage C. Dans ce cas, lors de l'initialisation des compteurs, les valeurs initiales des variables ou une variable sont définies et après chaque passage du boucle la condition est vérifiée, si la vérification renvoie vrai, alors la prochaine passe de la boucle commence. Dans le bloc<приращение счётчиков>la valeur de nos compteurs variables doit nécessairement changer (pas nécessairement vers le haut) pour que lors de la vérification de la condition, tôt ou tard, nous obtenions la valeur de mensonges, sinon la boucle ne se terminera jamais. Une option très pratique et surtout familière, si une opération doit être répétée un certain nombre de fois.

Avec une syntaxe similaire :
pour ((<инициализация счётчиков>; <проверка условия>; <приращение счётчиков>))
faire
<выполняемые команды>
fait

Exemple:
pour ((var=1; var<= LIMIT ; var++))
faire
echo $var
fait

boucle while :

Il s'agit d'une construction assez simple qui vérifie l'état derrière l'opérateur alors que et si cette condition est vraie, il exécute le bloc de commandes situé entre les mots do et done puis procède à nouveau à la vérification de la condition. Si la vérification renvoie faux, alors la boucle se termine et les commandes suivantes sont exécutées : fait. Il faut s'assurer que<проверка условия>dépendait du code exécuté dans la boucle sinon, si le résultat de la vérification ne change pas, vous obtiendrez une boucle infinie.
L'entrée standard, pendant une boucle while, peut être redirigée vers un fichier à l'aide de la commande redirect< в конце цикла.

Syntaxe:
alors que<Проверка условия>
faire
<Блок команд, обязательно меняющий переменные влияющие на проверку условия>
fait

Exemple:
tandis que [ $var0 -eq 100 ]
faire
echo $var
var++
fait

Opérateur alors que peut avoir plusieurs conditions. Mais seul le dernier d'entre eux détermine la possibilité de poursuivre le cycle. Dans ce cas, la syntaxe de l'instruction de boucle sera différente de celle habituelle.
Syntaxe(Je répète encore une fois que seule la dernière condition affecte l'exécution de la boucle) :
alors que
<условие1>
<условие2>

<условиеN>
faire
<выполняемые команды - тело цикла>
fait

jusqu'à la boucle :

Opérateur jusqu'à très similaire à while, il évalue également la condition, mais exécute le corps de la boucle si le résultat du calcul est faux. Cela peut sembler étrange, mais until évalue la condition avant la première itération de la boucle, comme while, et non après. Comme pour les boucles for/in, lorsque vous placez le mot-clé do sur la même ligne que la déclaration de boucle, vous devez insérer le caractère ";" avant de faire.
Comme dans le cas précédent, il est important de se rappeler que la condition doit dépendre des opérations dans le corps de la boucle, sinon notre script ne se terminera jamais.

Syntaxe:
jusqu'à<Проверка условия>
faire
<Блок команд, обязательно меняющий переменные влияющие на проверку условия>
fait

Exemple:
until [ $var0 -gt 100] # La condition est vérifiée au début de l'itération.
faire
echo $var
var--
fait

Probablement assez pour le moment. :)

  • Dos
  • Avant

Nouveaux articles :

  • La découverte du réseau ne s'active pas sous Windows 7/8/2008/2012
  • Erreur : Cette application n'a pas pu démarrer car elle n'a pas pu trouver ou charger le plug-in de la plate-forme Qt "windows".
  • Configuration du redémarrage automatique des processus de travail Serveur rphost.exe 1C 8.3
  • Comment réduire la taille du journal des transactions (.ldf) dans MS SQL 2008/20012

    MS SQL, comme tout SGBD industriel décent, ainsi que la base de données, conserve des journaux de transactions qui vous permettent de restaurer l'état ...

5

Votre script est codé de manière dangereuse.

Tout d'abord, je suppose que vous utilisez le shell Bash puisque vous l'avez marqué avec "/bash" et "/for".

Dans ma réponse, je citerai cet excellent guide Bash, qui est probablement la meilleure source pour apprendre Bash.

1) Ne jamais utiliser Command Substitution , out ou genre, sans guillemets. Il y a un gros problème ici : utiliser une extension sans guillemets pour diviser la sortie en arguments.

Pour être précis, ce travail $(find$ DIRWORK -type d -name) et $(find$ DIR -type f) subira Word Splitting , donc si find trouve un fichier avec des espaces dans son nom, c'est-à-dire le mot "nom de fichier" divisant le Le résultat de Bash passera 2 arguments à la commande for pour itérer, c'est-à-dire un pour "fichier" et un pour "nom". Dans ce cas, vous voulez espérer obtenir "fichier : aucun fichier ou répertoire de ce type" et "nom : aucun fichier ou répertoire de ce type" plutôt que de les endommager s'ils existent.

2) Par convention, les variables d'environnement (PATH, EDITOR, SHELL, ...) et les variables shell internes (BASH_VERSION, RANDOM, ...) sont entièrement en majuscules. Tous les autres noms de variables doivent être en minuscules. Étant donné que les noms de variables sont sensibles à la casse, cette convention évite la redéfinition accidentelle des variables environnementales et internes.

Il s'agit d'une version plus sûre de votre script que je vous recommande d'utiliser à la place :

My_home="/root/mydir" my_dir=" $my_home/var" dir_work="$ my_home/Local" while IFS= read -r -d "" f; do # Je suppose que vous voulez aussi ignorer stderr; # c'est de là que vient le 2>&1. if lsof -n " ​​​​$f" | grep "" > /dev/null 2> then echo "hey , je "suis plus en sécurité maintenant !" fi fait< <(find "$ dir_work" -type f -print0) while IFS= read -r -d "" f; do echo "2" done < <(find "$dir_work" -type d -name "work" -print0)

Comme vous pouvez le voir, la variable IFS est définie sur vide, empêchant ainsi read de supprimer les espaces de début et de fin de la chaîne. la commande read utilise la chaîne vide (-d "") comme délimiteur pour lire jusqu'à ce qu'elle atteigne un \ 0. find doit être m respectivement, elle utilise donc l'option -print0 pour délimiter ses données avec \ 0 au lieu d'une nouvelle ligne, qui est , étonnamment et malicieusement, peut faire partie du nom de fichier. Diviser un tel fichier en \n en deux parties cassera notre code.

La réponse précédente, qui indique que trouver ... | tandis que readname ; faire ...; done doit être utilisé pour lire find s la sortie peut également être mauvaise. La boucle while s'exécute dans un nouveau sous-shell avec sa copie des variables copiées depuis le parent. Cette copie est ensuite utilisée pour ce que vous voulez. Lorsque la boucle while est terminée, la copie du sous-shell sera supprimée et les variables d'origine du parent ne seront pas modifiées.

Si vous avez l'intention de modifier certaines variables à l'intérieur de cette boucle while et de les utiliser ultérieurement dans le parent, envisagez d'utiliser un script plus sûr qui empêchera la perte de données.

0

"N'utilisez jamais de substitution de commande, de quelque nature que ce soit, sans guillemets." C'est juste du pinaillage, mais il est possible d'utiliser la substitution de commande sans guillemets lorsque vous définissez une variable : "quelque chose = $(nom de base" nom de fichier avec des espaces ")". - Jean Smith 22 avr. 13 2013-04-22 21:43:10

2

For i in $(find$ DIRWORK -type d -name work); faire echo "2" fait

sera le premier à exécuter cette ligne

Trouver $DIRWORK -type d -name travail

attendez que find finisse de s'exécuter, puis prenez la sortie et remettez-la dans la boucle for

For i dans la sortie de find; faire echo "2" fait

ce n'est qu'alors que la boucle for commencera à s'exécuter.

Donc, si find prend beaucoup de temps pour terminer la boucle for, il doit attendre longtemps avant de pouvoir démarrer.

Essayez les commandes de recherche temporaires de manière interactive

$ temps trouver $DIRWORK -type d -nom travail

et voir combien de temps cela prend.

Notez également que vous ne devez pas utiliser une boucle for pour itérer sur les noms de fichiers. Utilisez une boucle while avec read , comme ceci :

Find$ DIRWORK -type d -name work | tandis que readname ; faire echo "2" fait

Bonus : il exécute la boucle while en parallèle avec find . Cela signifie que la boucle while exécutera une itération dès que find imprimera une ligne. Vous n'avez pas besoin d'attendre que find termine l'exécution.

mob_info