Using parameters in batch files at Windows command line

In Windows, how do you access arguments passed when a batch file is run?

For example, let’s say I have a program named hello.bat . When I enter hello -a at a Windows command line, how do I let my program know that -a was passed in as an argument?

5 Answers 5

As others have already said, parameters passed through the command line can be accessed in batch files with the notation %1 to %9 . There are also two other tokens that you can use:

• %0 is the executable (batch file) name as specified in the command line.
• %* is all parameters specified in the command line — this is very useful if you want to forward the parameters to another program.

There are also lots of important techniques to be aware of in addition to simply how to access the parameters.

Checking if a parameter was passed

This is done with constructs like IF «%

1″==»» , which is true if and only if no arguments were passed at all. Note the tilde character which causes any surrounding quotes to be removed from the value of %1 ; without a tilde you will get unexpected results if that value includes double quotes, including the possibility of syntax errors.

Handling more than 9 arguments (or just making life easier)

If you need to access more than 9 arguments you have to use the command SHIFT . This command shifts the values of all arguments one place, so that %0 takes the value of %1 , %1 takes the value of %2 , etc. %9 takes the value of the tenth argument (if one is present), which was not available through any variable before calling SHIFT (enter command SHIFT /? for more options).

SHIFT is also useful when you want to easily process parameters without requiring that they are presented in a specific order. For example, a script may recognize the flags -a and -b in any order. A good way to parse the command line in such cases is

This scheme allows you to parse pretty complex command lines without going insane.

Substitution of batch parameters

For parameters that represent file names the shell provides lots of functionality related to working with files that is not accessible in any other way. This functionality is accessed with constructs that begin with %

For example, to get the size of the file passed in as an argument use

To get the path of the directory where the batch file was launched from (very useful!) you can use

You can view the full range of these capabilities by typing CALL /? in the command prompt.

How to parse a JSON file to variables with the windows command line?

I have this JSON file called test.json which says:

I’d like to be able to read this file in the Windows command line and have these objects parsed as variables.

How would I do this?

3 Answers 3

If you use Windows Powershell as your command line, you can use the ConvertFrom-JSON cmdlet: http://powershelljson.codeplex.com/

Make sure your PowerShell version is above 3.0, as ConvertFrom-JSON is available from that version.

If you use plain old CMD, you’ll need an external tool for it. I like jq: http://stedolan.github.io/jq/. The tutorial uses curl for the examples, but you can just as easily use echo or read the JSON from a file.

PowerShell example. Create from file: $js = Get-Content file.json | ConvertFrom-Json. Get subkey: $js.key.subkey

I’d like to be able to read this file in the Windows command line and have these objects parsed as variables.

I’ll interpret this as, you want to do:

I’d recommend the powerful tool xidel for this task.

Basic command:

Whether you use 2 queries to return each value, or 1 query to return both values, both commands should return:

Export with custom variable-names:

Both commands do:

Export with key-names as variable-names:

How do you loop through each line in a text file using a windows batch file?

I would like to know how to loop through each line in a text file using a Windows batch file and process each line of text in succession.

12 Answers 12

I needed to process the entire line as a whole. Here is what I found to work.

The tokens keyword with an asterisk (*) will pull all text for the entire line. If you don’t put in the asterisk it will only pull the first word on the line. I assume it has to do with spaces.

If there are spaces in your file path, you need to use usebackq . For example.

From the Windows command line reference:

To parse a file, ignoring commented lines, type:

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.

By the way, you can find the command-line help file on most Windows systems at:

In a Batch File you MUST use %% instead of % : (Type help for )

What this does: The «do call :process %%i %%j %%k» at the end of the for command passes the information acquired in the for command from myfile.txt to the «process» ‘subroutine’.

When you’re using the for command in a batch program, you need to use double % signs for the variables.

The following lines pass those variables from the for command to the process ‘sub routine’ and allow you to process this information.

I have some pretty advanced uses of this exact setup that I would be willing to share if further examples are needed. Add in your EOL or Delims as needed of course.

Improving the first «FOR /F..» answer: What I had to do was to call execute every script listed in MyList.txt, so it worked for me:

—OR, if you wish to do it over the multiple line:

Edit: The example given above is for executing FOR loop from command-prompt; from a batch-script, an extra % needs to be added, as shown below:

@MrKraus’s answer is instructive. Further, let me add that if you want to load a file located in the same directory as the batch file, prefix the file name with %

dp0. Here is an example:

NB:: If your file name or directory (e.g. myfile.txt in the above example) has a space (e.g. ‘my file.txt’ or ‘c:\Program Files’), use:

, with the type keyword calling the type program, which displays the contents of a text file. If you don’t want to suffer the overhead of calling the type command you should change the directory to the text file’s directory. Note that type is still required for file names with spaces.

I hope this helps someone!

dp0** before the for loop. This would make sure you are referencing a file in the directory the batch file is in. Thanks for the observation – Marvin Thobejane Jul 18 ’13 at 12:01

The accepted answer is good, but has two limitations.
It drops empty lines and lines beginning with ;

To read lines of any content, you need the delayed expansion toggling technic.

Findstr is used to prefix each line with the line number and a colon, so empty lines aren’t empty anymore.

DelayedExpansion needs to be disabled, when accessing the %%a parameter, else exclamation marks ! and carets ^ will be lost, as they have special meanings in that mode.

But to remove the line number from the line, the delayed expansion needs to be enabled.
set «var=!var:*:=!» removes all up to the first colon (using delims=: would remove also all colons at the beginning of a line, not only the one from findstr).
The endlocal disables the delayed expansion again for the next line.

The only limitation is now the line length limit of

8191, but there seems no way to overcome this.

How to create an empty file at the command line in Windows?

How to create an empty file at the DOS/Windows command-line?

but it always displays that a file was copied.

Is there any other method in the standard cmd?

It should be a method that does not require the touch command from Cygwin or any other nonstandard commands. The command needs to run from a script so keystrokes cannot be used.

33 Answers 33

In the same spirit, Samuel suggests in the comments:

the shortest one I use is basically the one by Nomad:

It does give an error:

But this error is on stderr. And > only redirects stdout, where nothing have been produced.
Hence the creation of an empty file.
The error message can be disregarded here. Or, as in Rain’s answer, redirected to NUL :

(Original answer, November 2009)

( echo «» would actually put «» in the file! And echo without the ‘.’ would put » Command ECHO activated » in the file. )

Note: the resulting file is not empty but includes a return line sequence: 2 bytes.

This discussion points to a true batch solution for a real empty file:

The » » pipes a nul response to the set/p command, which will cause the variable used to remain unchanged. As usual with set/p , the string to the right of the equal sign is displayed as a prompt with no CRLF.

Since here the «string to the right of the equal sign» is empty. the result is an empty file.

The difference with cd. > filename (which is mentioned in Patrick Cuff’s answer and does also produce a 0-byte-length file) is that this «bit of redirection» (the trick) can be used to echo lines without any CR:

The dir command should indicate the file size as 11 bytes: » helloworld! «.

Command Line Parser on .NET5

February 3rd, 2021

Command Line Apps

Today we are going to show you how to get started parsing Command Line arguments, following on from our series on .NET 5 .

Command Line Applications, also known as Console Applications, are programs built to be used from a shell, such as cmd or bash. They have been around since the 1960’s, way before Windows, MacOS, or any other graphical user interface (GUI) came to be.

Usually, when you start learning a programing language, the simplest and most common sample is widely known as a Hello world app. These samples pretty much only print the text “Hello world” on the console, using their built-in APIs. Computer software can do a lot of different things. Sometimes you will have an input which is, somehow, translated to an output. Our Hello world sample doesn’t have any input.

Lets take C#/.Net . Whenever you create a new console app, you start with a Program.cs file with a static Main method that is the entry point of your application:

A very important part of this code is the string[] args definition. That is the parameter definition that contains all the arguments that are passed down to our executable during the initialization of our process. Unlike C and C++, the name of the program is not treated as the first command-line argument in the args array. If you want that value, you can call the Environment.GetCommandLineArgs() .

If you are used to command-line apps, passing arguments to other apps is a very common task. Yes, you can manually parse those values, but once you have multiple parameters it can be a very error-prone code (which is mostly boilerplate anyway). This seems like a problem that someone else might have fixed already, right? So of course we can find a NuGet library that helps us parse these arguments. For this blog post, I’ll focus on CommandLineParser.

CommandLineParser

The CommandLineParser is an open-source library built by Eric Newton and members of the .NET community. It’s been around since 2005 and it has more than 26 million downloads! The CommandLineParser “offers CLR applications a clean and concise API for manipulating command line arguments and related tasks, such as defining switches, options and verb commands”.

Instead of manually parsing the args string array, you can simply define a class that will be parsed for you by the library, based on a set of attributes that you annotate the class with.

Instead of creating yet another sample just for the sake of showing this library, I’ll use the WinML .NET5 console app that I’ve shared on my last blog post. Here is the source code. Lets start with it and add the CommandLineParser NuGet package:

Lets create a new class named CommandLineOptions :

This is pretty much everything we need to use this library. The ValueAttribute and OptionAttribute are both provided by the package. I’m using named parameters to make it very clear what each argument is for. Back to our Program.cs ‘ Main method, lets add the using statement to be able to easily use the package’s classes in this file:

Lets change the return type of our Main method to be a Task . It means that whichever int value we return will be returned to the caller of our process, which usually indicates success/failure. In this example, we’ll simply return 0 on success and something other than 0 on errors:

You can see all the changes from the previous version of the code here.

With these changes in place the app gracefully parses our arguments. There is even a help page generated automatically for us!

So lets say you want to analyze an image, but you want its result even if you are not too sure about it, lets say a confidence of 30%. That can easily be done now using the -c (of the long name —confidence ) argument. With this image:

You can get this result when using the —confidence :

Conclusion

The CommandLineParser NuGet package is a very powerful helper that simplifies this common repetitive task into a simple declarative approach. Also, it is much more customizable than what I’ve demonstrated here. You can find it’s documentation at their GitHub’s Wiki page.

Alexandre Zollinger Chohfi

Senior Software Developer Engineer, Windows & Devices

Read next

8 comments

I hope this does NOT use the Microsoft recommended method of command line parsing where a quote preceded by a back slash is not treated as a quote character.
Even though those recommendations are old, it goes against preexisting behaviour that has been around for decades.
It also means that a back slash is sometimes treated as an escape character which is horribly inconsistent!
That recommended behaviour significantly complicates usage for the average end user.

Hello Mark. First, thanks for reading!

CommandLineParser is one option we have in the .NET ecosystem, and I chose to write about it since it is community driven, highly successful, and widely adopted. If you are having issues with it, please, report it at their Github page. I’m sure that the community would be more than happy to help you. Another option I would also recommend is using the System.CommandLine, which is much newer and might fit your needs.
By the way, I’ve found an interesting discussion on the System.CommandLine GitHub on why this behavior exists: https://github.com/dotnet/command-line-api/issues/354, which I believe is the same reason this issue exists on CommandLineParser.

I like the syscommand library, which I created, it simulates a Mvc and does not need almost any code.

I really don’t like the attribute-based setup, because it’s often too limit. Use a fluent-style commandline parser and it will be much easier and allow for more complex scenarios. I used https://github.com/spf13/cobra for Go and it’s very powerful and easy to use.

This seems like a very abbreviated approach to creating commands if it’s to be considered as technical advice. Many important concerns are unanswered — concerns that the software community at large has already dealt with in much better ways.

I would suggest anyone reading take a look at the CliFx library which has done a great job to go beyond simple parameter parsing.

This is a library Microsoft should look into lending some support to instead.

This post only scratches the surface of features. I would like to see a series of blog posts that talk about the more advanced features required in most command line apps. For example, base the examples on command line parsing to simulate tools we use every day like git or dotnet tool. These apps use verb/command syntax and the parameters for each verb/command vary. Also for a given verb/command there can be different option sets that are required or mutually exclusive. For example an app that makes http requests could have a ‘–url’ parameter, or “–host and –port” parameters. A ‘git push’, you can only optionally have flag ‘–all’ or ‘–mirror’ or ‘–tags’. I have also seen apps that dynamically scan for “Verbs” in the app at start up so you dont have to change the Main(string[] args) function. Thank you for this post. Is a good start. Perhaps a follow up on how one would create some basic git command line type app would help.

I just looked up how the dotnet utility parses it’s command line. It uses the System.CommandLine package – https://github.com/dotnet/command-line-api. Another thing for me to review.

Thank you! I wonder if this could open up a way to get around the 8192 character limit when providing long parameters to Windows command line apps? The only ‘solution’ I found / was advised to so far is to shorten the parameters, which is kind of odd ?!