Partager via

pour

Exécute une commande spécifiée pour chaque fichier, dans un ensemble de fichiers.

Syntaxe

for {%% | %}<variable> in (<set>) do <command> [<commandlineoptions>]

Paramètres

Paramètre Descriptif
{%% \| %}<variable> Obligatoire. Représente un paramètre remplaçable. Utilisez un seul signe de pourcentage (%) pour exécuter la commande à l’invite de commandes. Utilisez des signes de double pourcentage (%%) pour exécuter la commande dans un fichier batch. Les variables respectent la casse et doivent être représentées avec une valeur alphabétique telle que%a, %bou %c.
(<set>) Obligatoire. Spécifie un ou plusieurs fichiers, répertoires ou chaînes de texte, ou une plage de valeurs sur laquelle exécuter la commande. Les parenthèses sont requises.
<command> Obligatoire. Spécifie la commande que vous souhaitez exécuter sur chaque fichier, répertoire ou chaîne de texte, ou sur la plage de valeurs incluses dans le jeu.
<commandlineoptions> Spécifie toutes les options de ligne de commande que vous souhaitez utiliser avec la commande spécifiée.
/? Affiche l'aide à l'invite de commandes.

Remarques

  • Vous pouvez utiliser cette commande dans un fichier de commandes ou directement à partir de l’invite de commandes.

  • Les attributs suivants s’appliquent à la commande :

    • Cette commande remplace % variable ou %% variable par chaque chaîne de texte dans le jeu spécifié jusqu’à ce que la commande spécifiée traite tous les fichiers.

    • Les noms de variables respectent la casse, sont globaux et ne peuvent pas être actifs à la fois.

    • Pour éviter toute confusion avec les paramètres de lot, vous %0pouvez utiliser n’importe quel caractère pour %9, à l’exception des chiffres 0 à 9. Pour les fichiers batch simples, un caractère unique tel que %%f fonctionne.

    • Vous pouvez utiliser plusieurs valeurs pour les variables dans les fichiers batch complexes pour distinguer différentes variables remplaçables.

  • Le paramètre set peut représenter un seul groupe de fichiers ou plusieurs groupes de fichiers. Vous pouvez utiliser des caractères génériques (* et ?) pour spécifier un jeu de fichiers. Voici les jeux de fichiers valides :

    (*.doc)
(*.doc *.txt *.me)
(jan*.doc jan*.rpt feb*.doc feb*.rpt)
(ar??1991.* ap??1991.*)

  • Lorsque vous utilisez cette commande, la première valeur du jeu remplace % variable ou %% variable, puis la commande spécifiée traite cette valeur. Cela se poursuit jusqu’à ce que tous les fichiers (ou groupes de fichiers) qui correspondent à la valeur définie soient traités.

  • Dans et ne sont pas des paramètres, mais vous devez les utiliser avec cette commande. Si vous omettez l’un de ces mots clés, un message d’erreur s’affiche.

  • Si les extensions de commande sont activées (c’est-à-dire la valeur par défaut), les formulaires supplémentaires suivants sont pris en charge :

    • Répertoires uniquement : Si le jeu contient des caractères génériques (* ou ?), la commande spécifiée s’exécute pour chaque répertoire (au lieu d’un ensemble de fichiers dans un répertoire spécifié) qui correspond au jeu. La syntaxe est la suivante :

      for /d {%%|%}<variable> in (<set>) do <command> [<commandlineoptions>]

    • Récursif: Guide l’arborescence de répertoires rooté au niveau de drive :path et exécute l’instruction for dans chaque répertoire de l’arborescence. Si aucun répertoire n’est spécifié après /r, le répertoire actif est utilisé comme répertoire racine. S’il s’agit d’un seul point (.), il énumère uniquement l’arborescence de répertoires. La syntaxe est la suivante :

      for /r [[<drive>:]<path>] {%%|%}<variable> in (<set>) do <command> [<commandlineoptions>]

    • Itération d’une plage de valeurs : Utilisez une variable itérative pour définir la valeur de départ (start#), puis parcourez une plage de valeurs définie jusqu’à ce que la valeur dépasse la valeur de fin définie (end#). /l exécute l’itérative en comparant start# à end#. Si start# est inférieur à end# , la commande s’exécute. Lorsque la variable itérative dépasse la fin#, l’interpréteur de commandes quitte la boucle. Vous pouvez également utiliser une étape négative# pour parcourir une plage dans les valeurs décroissantes. Par exemple, (1,1,5) génère la séquence 1 2 3 4 5 et (5,-1,1) génère la séquence 5 4 3 2 1. La syntaxe est la suivante :

      for /l {%%|%}<variable> in (<start#>,<step#>,<end#>) do <command> [<commandlineoptions>]

    • Itération et analyse des fichiers : Utilisez l’analyse de fichiers pour traiter la sortie de commande, les chaînes et le contenu du fichier. Utilisez des variables itératives pour définir le contenu ou les chaînes que vous souhaitez examiner et utilisez les différentes options d’analyse des mots clés pour modifier davantage l’analyse. Utilisez l’option de jeton parsingkeywords pour spécifier les jetons devant être passés en tant que variables itératives. Lorsqu’il est utilisé sans l’option de jeton, /f examine uniquement le premier jeton.

      L’analyse de fichier consiste à lire la sortie, la chaîne ou le contenu du fichier, puis à le diviser en lignes de texte individuelles et à analyser chaque ligne en zéro ou plusieurs jetons. La boucle for est ensuite appelée avec la valeur de variable itérative définie sur le jeton. Par défaut, /f transmet le premier jeton séparé vide de chaque ligne de chaque fichier. Les lignes vides sont ignorées.

      Les syntaxes sont les suivantes :

      for /f [<parsingkeywords>] {%%|%}<variable> in (<set>) do <command> [<commandlineoptions>]
for /f [<parsingkeywords>] {%%|%}<variable> in (<literalstring>) do <command> [<commandlineoptions>]
for /f [<parsingkeywords>] {%%|%}<variable> in ('<command>') do <command> [<commandlineoptions>]

      L’argument set spécifie un ou plusieurs noms de fichiers. Chaque fichier est ouvert, lu et traité avant de passer au fichier suivant en jeu. Pour remplacer le comportement d’analyse par défaut, spécifiez les mots clés d’analyse. Il s’agit d’une chaîne entre guillemets qui contient un ou plusieurs mots clés pour spécifier différentes options d’analyse.

      Si vous utilisez l’option usebackq , utilisez l’une des syntaxes suivantes :

      for /f [usebackq <parsingkeywords>] {%%|%}<variable> in (<set>) do <command> [<commandlineoptions>]
for /f [usebackq <parsingkeywords>] {%%|%}<variable> in ('<literalstring>') do <command> [<commandlineoptions>]
for /f [usebackq <parsingkeywords>] {%%|%}<variable> in (`<command>`) do <command> [<commandlineoptions>]

      Le tableau suivant répertorie les mots clés d’analyse que vous pouvez utiliser pour analyser les mots clés.

      Mot-clé Descriptif
      EOL=<c> Spécifie une fin de trait (un seul caractère).
      saut=<n> Spécifie le nombre de lignes à ignorer au début du fichier.
      delims=<xxx> Spécifie un jeu de délimiteurs. Cela remplace l’ensemble de délimiteur par défaut de l’espace et de l’onglet.
      jetons=<x,y,m–n> Spécifie les jetons de chaque ligne à passer à la boucle for pour chaque itération. Par conséquent, des noms de variables supplémentaires sont alloués. m-n spécifie une plage, du mth au nth tokens. Si le dernier caractère de la chaîne tokens= est un astérisque (*), une variable supplémentaire est allouée et reçoit le texte restant sur la ligne après le dernier jeton analysé.
      usebackq Spécifie d’exécuter une chaîne entre guillemets précédents en tant que commande, d’utiliser une chaîne entre guillemets simples en tant que chaîne littérale ou, pour les noms de fichiers longs qui contiennent des espaces, autoriser les noms de fichiers dans <set>, à chacun d’eux placé entre guillemets doubles.

    • Substitution de variable : Le tableau suivant répertorie la syntaxe facultative (pour n’importe quelle variable I) :

      Variable avec modificateur Descriptif
      %~I Développe ce qui supprime les guillemets %I environnants.
      %~fI %I S’étend sur un nom de chemin complet.
      %~dI %I S’étend sur une lettre de lecteur uniquement.
      %~pI %I Se développe uniquement sur un chemin d’accès.
      %~nI %I Se développe uniquement sur un nom de fichier.
      %~xI %I Se développe sur une extension de nom de fichier uniquement.
      %~sI Développe le chemin d’accès pour contenir uniquement des noms courts.
      %~aI %I Se développe sur les attributs de fichier du fichier.
      %~tI %I Se développe jusqu’à la date et à l’heure du fichier.
      %~zI %I S’étend à la taille du fichier.
      %~$PATH:I Recherche les répertoires répertoriés dans la variable d’environnement PATH et se développe %I sur le nom complet du premier répertoire trouvé. Si le nom de la variable d’environnement n’est pas défini ou que le fichier est introuvable par la recherche, ce modificateur s’étend sur la chaîne vide.

      Le tableau suivant répertorie les combinaisons de modificateurs que vous pouvez utiliser pour obtenir des résultats composés.

      Variable avec modificateurs combinés Descriptif
      %~dpI %I S’étend sur une lettre de lecteur et un chemin d’accès uniquement.
      %~nxI %I S’étend sur un nom de fichier et une extension uniquement.
      %~fsI %I S’étend sur un nom de chemin d’accès complet avec des noms courts uniquement.
      %~dp$PATH:I Recherche dans les répertoires répertoriés dans la variable %I d’environnement PATH et se développe sur la lettre de lecteur et le chemin d’accès du premier trouvé.
      %~ftzaI %I Se développe sur une ligne de sortie semblable à dir.

      Dans les exemples ci-dessus, vous pouvez remplacer %I et PATH par d’autres valeurs valides. Un nom de variable valide met fin à la %~ syntaxe.

      En utilisant des noms de variables majuscules tels que %I, vous pouvez rendre votre code plus lisible et éviter toute confusion avec les modificateurs, qui ne respectent pas la casse.

  • Analyse d’une chaîne : Vous pouvez utiliser la for /f logique d’analyse sur une chaîne immédiate en encapsulant <literalstring> les guillemets doubles (sans usebackq) ou entre guillemets simples (avec usebackq) (par exemple, (MyString) ou ('MyString'). <literalstring> est traité comme une seule ligne d’entrée à partir d’un fichier. Lors de <literalstring> l’analyse entre guillemets doubles, les symboles de commande tels que (\ & | > < ^) sont traités comme des caractères ordinaires.

  • Sortie d’analyse : Vous pouvez utiliser la for /f commande pour analyser la sortie d’une commande en plaçant un guillemet précédent <command> entre les parenthèses. Elle est traitée comme une ligne de commande, qui est passée à un Cmd.exeenfant. La sortie est capturée en mémoire et analysée comme s’il s’agit d’un fichier.

Exemples

Pour les utiliser dans un fichier batch, utilisez la syntaxe suivante :

for {%%|%}<variable> in (<set>) do <command> [<commandlineoptions>]

Pour afficher le contenu de tous les fichiers du répertoire actif qui ont l’extension .doc ou .txt à l’aide de la variable remplaçable %f, tapez :

for %f in (*.doc *.txt) do type %f

Dans l’exemple précédent, chaque fichier qui a l’extension .doc ou .txt dans le répertoire actif est remplacé par la variable %f jusqu’à ce que le contenu de chaque fichier soit affiché. Pour utiliser cette commande dans un fichier de commandes, remplacez toutes les occurrences de %f par %%f. Sinon, la variable est ignorée et un message d’erreur s’affiche.

Pour analyser un fichier, en ignorant les lignes commentées, tapez :

for /f eol=; tokens=2,3* delims=, %i in (myfile.txt) do @echo %i %j %k

Cette commande analyse chaque ligne dans myfile.txt. Il ignore les lignes qui commencent par un point-virgule et passent le deuxième et le troisième jeton de chaque ligne au corps ( les jetons sont délimités par des virgules ou des espaces). Le corps des références d’instruction%i pour obtenir le deuxième jeton, %j obtenir le troisième jeton et %k obtenir tous les jetons restants. Si les noms de fichiers que vous fournissez contiennent des espaces, utilisez des guillemets autour du texte (par exemple, Nom de fichier). Pour utiliser des guillemets, vous devez utiliser usebackq. Sinon, les guillemets sont interprétés comme définissant une chaîne littérale à analyser.

%i est explicitement déclaré dans l’instruction for . %j et %k sont implicitement déclarés à l’aide de tokens=. Vous pouvez utiliser des jetons = pour spécifier jusqu’à 26 jetons, s’il n’entraîne pas de tentative de déclaration d’une variable supérieure à la lettre z ou Z.

Pour analyser la sortie d’une commande en plaçant le jeu entre les parenthèses, tapez :

for /f "usebackq delims==" %i in (`set`) do @echo %i

Pour effectuer une boucle récursive de tous les fichiers d’un répertoire, y compris les sous-répertoires et faire écho à leur chemin d’accès complet, lorsqu’ils ont été modifiés pour la dernière fois, et leur taille de fichier, tapez :

for /r "C:\My Dir\" %A in (*.*) do echo %~ftzA