pour

  • Article

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 Description
{%% \| %}<variable> Obligatoire. Représente un paramètre remplaçable. Utilise un seul signe de pourcentage (%) pour exécuter la commande for à l’invite de commandes. Utilise deux signes de pourcentage (%%) pour exécuter la commande for dans un fichier de commandes. Les variables respectent la casse et doivent être représentées avec une valeur alphabétique de type %a, %b ou %c.
(<set>) Obligatoire. Spécifie un ou plusieurs fichiers, répertoires ou chaînes de texte, ou une plage de valeurs, sur lesquels exécuter la commande. Les parenthèses sont obligatoires.
<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, compris dans set.
<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.

Notes

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

  • Les attributs suivants s’appliquent à la commande for :

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

    • Les noms de variables respectent la casse, sont globaux et il ne peut pas y en avoir plus de 52 actifs à la fois.

    • Pour éviter toute confusion avec les paramètres de commandes, %0 à %9, vous pouvez utiliser n’importe quel caractère pour variable, sauf les chiffres 0 à 9. Pour les fichiers de commandes simples, un seul caractère de type %%f fonctionne.

    • Vous pouvez utiliser plusieurs valeurs pour variable dans des fichiers de commandes 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 ensemble de fichiers. Voici des ensembles de fichiers valides :

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

  • Quand vous utilisez cette commande, la première valeur de set remplace % variable ou %% variable, puis la commande spécifiée traite cette valeur. Ce processus continue jusqu’à ce que tous les fichiers (ou groupes de fichiers) correspondant à la valeur set soient traités.

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

  • Si les extensions de commande sont activées (valeur par défaut), les formes supplémentaires suivantes de for sont prises en charge :

    • Répertoires uniquement : si set 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 à set. La syntaxe est :

      for /d {%%|%}<Variable> in (<Set>) do <Command> [<CommandLineOptions>]

    • Récursive : parcourt l’arborescence de répertoires à la racine 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 actuel est utilisé comme répertoire racine. Si set est seulement un point (.), il énumère seulement l’arborescence de répertoires. La syntaxe est :

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

    • Itération d’une plage de valeurs : utilise une variable itérative pour définir la valeur de début (start#), puis parcourt une plage de valeurs jusqu’à ce que la valeur dépasse la valeur de fin définie (end#). /l exécute l’itération en comparant start# à end#. Si start# est inférieur à end#, la commande s’exécute. Quand la variable itérative dépasse end#, l’interface de commande quitte la boucle. Vous pouvez également utiliser un step# négatif pour exécuter un pas à pas dans une plage de 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 :

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

    • Itération et analyse de fichiers : utilise 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 parsingkeywords pour modifier l’analyse. Utilisez l’option de jeton parsingkeywords pour spécifier les jetons qui doivent être passés comme variables itératives. Quand il est utilisé sans l’option de jeton, /f examine uniquement le premier jeton.

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

      Les syntaxes sont :

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

      L’argument set spécifie un ou plusieurs noms de fichier. Chaque fichier est ouvert, lu et traité avant de passer au fichier suivant dans set. Pour remplacer le comportement d’analyse par défaut, spécifiez parsingkeywords. 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> [<commandlinepptions>]
for /f [usebackq <parsingkeywords>] {%%|%}<variable> in ('<LiteralString>') do <command> [<commandlinepptions>]
for /f [usebackq <parsingkeywords>] {%%|%}<variable> in (`<command>`) do <command> [<commandlinepptions>]

      Le tableau suivant liste les mots clés d’analyse que vous pouvez utiliser pour parsingkeywords.

      Mot clé Description
      eol=<c> Spécifie un caractère de fin de ligne (un seul caractère).
      skip=<n> Spécifie le nombre de lignes à ignorer au début du fichier.
      delims=<xxx> Spécifie un ensemble de délimiteurs. Remplace l’ensemble de délimiteurs par défaut (espace et tabulation).
      tokens=<x,y,m–n> Spécifie les jetons de chaque ligne qui doivent être passés à la boucle for pour chaque itération. En conséquence, des noms de variables supplémentaires sont alloués. m-n spécifie une plage, du jeton numéro m au jeton numéro n. 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 de la ligne après le dernier jeton analysé.
      usebackq Spécifie d’exécuter une chaîne entre accents graves comme une commande, d’utiliser une chaîne entre guillemets simples comme une chaîne littérale ou, pour les noms de fichier longs qui contiennent des espaces, d’autoriser les noms de fichier dans <set> à être placés chacun entre guillemets doubles.

    • Remplacement de variable : le tableau suivant liste la syntaxe facultative (pour toutes les variables I) :

      Variable avec modificateur Description
      %~I Développe %I, ce qui supprime tous les guillemets environnants.
      %~fI Développe %I pour afficher le nom de chemin complet.
      %~dI Développe %I avec la lettre de lecteur uniquement.
      %~pI Développe %I avec le chemin uniquement.
      %~nI Développe %I avec le nom de fichier uniquement.
      %~xI Développe %I avec l’extension de nom de fichier uniquement.
      %~sI Développe le chemin pour contenir uniquement des noms courts.
      %~aI Développe %I pour afficher les attributs du fichier.
      %~tI Développe %I avec la date et l’heure du fichier.
      %~zI Développe %I avec la taille du fichier.
      %~$PATH:I Fait une recherche dans les répertoires listés dans la variable d’environnement PATH et développe %I pour afficher 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, ce modificateur affiche une chaîne vide.

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

      Variable avec modificateurs combinés Description
      %~dpI Développe %I avec la lettre de lecteur et le chemin uniquement.
      %~nxI Développe %I avec l’extension et le nom de fichier uniquement.
      %~fsI Développe %I pour afficher le nom de chemin complet avec des noms courts uniquement.
      %~dp$PATH:I Fait une recherche dans les répertoires listés dans la variable d’environnement PATH pour %I, puis affiche la lettre de lecteur et le chemin du premier répertoire trouvé.
      %~ftzaI Développe %I pour afficher 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 for valide met fin à la syntaxe %~.

      En utilisant des noms de variable en majuscules comme %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 logique d’analyse for /f sur une chaîne immédiate en plaçant <literalstring> entre 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 d’un fichier. Dans l’analyse de <literalstring> entre guillemets doubles, les symboles de commande comme (\ & | > < ^) sont traités comme des caractères ordinaires.

  • Sortie d’analyse : vous pouvez utiliser la commande for /f pour analyser la sortie d’une commande en plaçant un accent grave <command> entre parenthèses. Il est traité comme une ligne de commande, qui est passée à un Cmd.exe enfant. La sortie est capturée en mémoire et analysée comme un fichier.

Exemples

Pour utiliser for dans un fichier de commandes, utilisez la syntaxe suivante :

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

Pour afficher le contenu de tous les fichiers du répertoire actuel qui ont l’extension .doc ou .txt en utilisant 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 actuel 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 chaque occurrence 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 de myfile.txt. Elle ignore les lignes qui commencent par un point-virgule, et passe le deuxième et le troisième jeton de chaque ligne au corps de for (les jetons sont délimités par des virgules ou des espaces). Le corps de l’instruction for référence %i pour obtenir le deuxième jeton, %j pour obtenir le troisième jeton et %k pour obtenir tous les jetons restants. Si les noms de fichier que vous fournissez contiennent des espaces, utilisez des guillemets autour du texte (par exemple, File Name). Pour utiliser des guillemets, vous devez utiliser usebackq. Sinon, les guillemets sont interprétés comme s’ils définissaient une chaîne littérale à analyser.

%i est explicitement déclaré dans l’instruction for. %j et %k sont déclarés implicitement en utilisant tokens=. Vous pouvez utiliser tokens= pour spécifier jusqu’à 26 jetons, si ce paramètre n’entraîne pas la tentative de déclaration d’une variable au-dessus de la lettre z ou Z.

Pour analyser la sortie d’une commande en plaçant set entre 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