Share via


Runs a specified command for each file in a set of files.


for {**%variable|%%**variable} in (set) do command [ CommandLineOptions]


{ % variable | %% variable } : Required. Represents a replaceable parameter. Use **%**variable to carry out for from the command prompt. Use **%%**variable to carry out the for command within a batch file. Variables are case-sensitive and must be represented with an alpha value, such as %A, %B, or %C.

( set )   : Required. Specifies one or more files, directories, range of values, or text strings that you want to process with the specified command. The parentheses are required.

command   : Required. Specifies the command that you want to carry out on each file, directory, range of values, or text string included in the specified (set).

CommandLineOptions   : Specifies any command-line options that you want to use with the specified command.

/? : Displays help at the command prompt.


  • Using for 

    You can use the for command within a batch file or directly from the command prompt.

  • Using batch parameters

    The following attributes apply to the for command:

    • The for command replaces **%**variable or **%%**variable with each text string in the specified set until the command processes all of the files.

    • For variable names are case-sensitive, global, and no more than 52 total can be active at any one time.

    • To avoid confusion with the batch parameters %0 through %9, you can use any character for variable except the numerals 0 through 9. For simple batch files, a single character such as %%f works.

    • You can use multiple values for variable in complex batch files to distinguish different replaceable variables.

  • Specifying a group of files

    The set parameter can represent a single group of files or several groups of files. You can use wildcards (that is, * and ?) to specify a file set. The following are valid file sets:


    (*.doc *.txt *.me)

    (jan*.doc jan*.rpt feb*.doc feb*.rpt)

    (ar??1991.* ap??1991.*)

    When you use the for command, the first value in set replaces **%**variable or **%%**variable, and then the specified command processes this value. This continues until all of the files (or groups of files) that correspond to the set value are processed.

  • Using the in and do keywords

    In and do are not parameters, but you must use them with for. If you omit either of these keywords, an error message appears.

  • Using additional forms of for 

    If command extensions are enabled (that is, the default), the following additional forms of for are supported:

    • Directories only

      If set contains wildcards (* and ?), the specified command executes for each directory (instead of a set of files in a specified directory) that matches set. The syntax is:

      for /D {%% | %}variable in (set) do command [CommandLineOptions]

    • Recursive

      Walks the directory tree rooted at [Drive**:**]Path, executing the for statement in each directory of the tree. If no directory is specified after /R, the current directory is assumed. If set is just a single period (.), it only enumerates the directory tree. The syntax is:

      for /R [[Drive :]Path] {%% | %}variable in (set) do command [CommandLineOptions]

    • Iterating a range of values

      Use an iterative variable to set the starting value (start#) and then step through a set range of values until the value exceeds the set ending value (end#). /L will execute the iterative by comparing start# with end#. If start# is less than end# the command will execute. When the iterative variable exceeds end# the command shell exists the loop. You can also use a negative step# to step through a range in decreasing values. For example, (1,1,5) generates the sequence 1 2 3 4 5 and (5,-1,1) generates the sequence (5 4 3 2 1). The syntax is:

      for /L {%% | %}variable in (start#,step#,end#) do command [CommandLineOptions]

    • Iterating and file parsing

      Use file parsing to process command output, strings and file content. Use iterative variables to define the content or strings you want to examine and use the various ParsingKeywords options to further modify the parsing. Use the ParsingKeywords token option to specify which tokens should be passed as iterator variables. Note that when used without the token option, /F will only examine the first token.

      File parsing consists of reading the output, string or file content, breaking it up into individual lines of text and then parsing each line into zero or more tokens. The for loop is then called with the iterator variable value set to the token. By default, /F passes the first blank separated token from each line of each file. Blank lines are skipped. The different syntaxes are:

      for /F ["ParsingKeywords"] {%% | %}variable in (filenameset) do command [CommandLineOptions]

      for /F ["ParsingKeywords"] {%% | %}variable in ("LiteralString") do command [CommandLineOptions]

      for /F ["ParsingKeywords"] {%% | %}variable in ('command') do command [CommandLineOptions]

      The filenameset argument specifies one or more file names. Each file is opened, read and processed before going on to the next file in filenameset. To override the default parsing behavior, specify "ParsingKeywords". This is a quoted string that contains one or more keywords to specify different parsing options.

      If you use the usebackq option, use one of the following syntaxes:

      for /F ["usebackqParsingKeywords**"] {%%** | %}variable in ("filenameset") do command [CommandLineOptions]

      for /F ["usebackqParsingKeywords**"] {%%** | %}variable in ('LiteralString') do command [CommandLineOptions]

      for /F ["usebackqParsingKeywords**"] {%%** | %}variable in (`command`) do command [CommandLineOptions]

      The following table lists the parsing keywords that you can use for ParsingKeywords.




      Specifies an end of line character (just one character).


      Specifies the number of lines to skip at the beginning of the file.


      Specifies a delimiter set. This replaces the default delimiter set of space and tab.


      Specifies which tokens from each line are to be passed to the for body for each iteration. As a result, additional variable names are allocated. The m-n form is a range, specifying the mth through the nth tokens. If the last character in the tokens= string is an asterisk (*), an additional variable is allocated and receives the remaining text on the line after the last token that is parsed.


      Specifies that you can use quotation marks to quote file names in filenameset, a back quoted string is executed as a command, and a single quoted string is a literal string command.

    • Variable substitution

      Substitution modifiers for for variable references have been enhanced. The following table lists optional syntax (for any variable I).

      Variable with modifier



      Expands %I which removes any surrounding quotation marks ("").


      Expands %I to a fully qualified path name.


      Expands %I to a drive letter only.


      Expands %I to a path only.


      Expands %I to a file name only.


      Expands %I to a file extension only.


      Expands path to contain short names only.


      Expands %I to the file attributes of file.


      Expands %I to the date and time of file.


      Expands %I to the size of file.


      Searches the directories listed in the PATH environment variable and expands %I to the fully qualified name of the first one found. If the environment variable name is not defined or the file is not found by the search, this modifier expands to the empty string.

      The following table lists modifier combinations that you can use to get compound results.

      Variable with combined modifiers



      Expands %I to a drive letter and path only.


      Expands %I to a file name and extension only.


      Expands %I to a full path name with short names only.


      Searches the directories listed in the PATH environment variable for %I and expands to the drive letter and path of the first one found.


      Expands %I to an output line that is like dir.

      In the above examples, you can replace %I and PATH by other valid values. A valid for variable name terminates the %~ syntax.

      By use uppercase variable names such as %I, you can make your code more readable and avoid confusion with the modifiers, which are not case-sensitive.

  • Parsing a string

    You can use the for /F parsing logic on an immediate string, by wrapping the filenameset between the parentheses in single quotation marks (that is, 'filenameset'). Filenameset is treated as a single line of input from a file, and then it is parsed.

  • Parsing output

    You can use the for /F command to parse the output of a command by making the filenameset between the parenthesis a back quoted string. It is treated as a command line, which is passed to a child Cmd.exe and the output is captured into memory and parsed as if it were a file.


To use for in a batch file, use the following syntax:

for %% variable in (set) do command [CommandLineOptions]

To display the contents of all the files in the current directory that have the extension .doc or .txt using the replaceable variable %f, type:

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

In the preceding example, each file that has the .doc or .txt extension in the current directory is substituted for the %f variable until the contents of every file are displayed. To use this command in a batch file, replace every occurrence of %f with %%f. Otherwise, the variable is ignored and an error message is displayed.

To parse a file, ignoring commented lines, type:

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

This command parses each line in Myfile.txt, ignoring lines that begin with a semicolon and passing the second and third token from each line to the FOR body (tokens are delimited by commas or spaces). The body of the FOR statement references %i to get the second token, %j to get the third token, and %k to get all of the remaining tokens. If the file names that you supply contain spaces, use quotation marks around the text (for example, "File Name"). To use quotation marks, you must use usebackq. Otherwise, the quotation marks are interpreted as defining a literal string to parse.

%i is explicitly declared in the FOR statement, and %j and %k are implicitly declared by using tokens=. You can specify up to 26 tokens using tokens=, provided that it does not cause an attempt to declare a variable higher than the letter 'z' or 'Z'.

To parse the output of a command by placing filenameset between the parentheses, type:

for /F "usebackq delims==" %i IN (`set`) DO @echo %i 

This example enumerates the environment variable names in the current environment.

Formatting legend




Information that the user must supply


Elements that the user must type exactly as shown

Ellipsis (...)

Parameter that can be repeated several times in a command line

Between brackets ([])

Optional items

Between braces ({}); choices separated by pipe (|). Example: {even|odd}

Set of choices from which the user must choose only one

Courier font

Code or program output



Command-line reference A-Z