1. What is delayed environment variable extension?
The full name of delay variable is "delay environment variable extension". To understand this thing, we must first understand what variable extension is!
When CMD interprets our command, it will first read a complete command and then perform some command format matching operations to see if the command format you enter meets its requirements. If we want to refer to some variables in the command, how can we let CMD recognize this variable when interpreting our command? At this time, we can add a % number on both sides of the variable name, such as %name%. When CMD reads our entire command for format matching, it will find that the name character has a % number on both sides, and it will not treat it as a normal character, but will use it. Treat it as a variable, the variable name is name. Then CMD will find the value corresponding to the variable name, replace the variable name (name) with this value (if the variable name does not have a value, return a null value). Then replace this and match the command! This process of replacing the value is called variable expansion. To put it bluntly, it is to replace the name of the variable with its value and then execute it! That is, how to identify a variable through batch processing. (Note: This is just the meaning of the expansion of the variable, not the delayed environment variable expansion. To understand the delayed environment variable expansion, you must first understand what the expansion of the variable is) That is, the process of how batch processing recognizes a variable.
Example 1,
@echo off set var=test echo %var% pause
After CMD reads the command echo %var%, it will perform a matching operation. It will immediately find that there is a % number on both sides of the var character. At this time, CMD will treat it as a
Processing variables, check whether the var variable name has a value. If there is one, use this value to replace the variable name var. Here our var is set in the previous command
In var=test, assign the value to var as test, so CMD will use test to replace the variable name %var% and the result after the replacement is echo test. These steps
The steps are all the steps of CMD performing matching operations. After the match is completed, it executes the echo test statement. At this time, a test will be echoed in our CMD.
What is environment variable extension? What is delayed environment variable extension?
When understanding the expansion of environment variables, we know that when CMD interprets commands, it will first read a complete command, and then perform a matching operation.
It will replace the variable in the command with the value of the variable, and then execute the replaced command. The problem lies in "a complete command", in BAT, IF
Commands like FOR can be added with brackets and nested some commands inside to execute. In this way, for a command that can add a number extension and embed other commands, its end
The whole format is a whole for %%i in (......). At this time, if we embed some commands to set variable values in brackets, it will appear
There is a problem!
Example 2,
@echo off for /l %%i in (1,1,5) do ( set var=%%i echo %var% ) pause
After execution, 5 blank lines will be displayed error prompts! Why? Understand it based on the knowledge we mentioned above.
Through these two examples, you should have understood that if only the environment variable expansion process is used, if we perform the assignment operation in a command that can nest commands, our BAT will cause the problem of assigning values to the variables. Then at this time, the concept of "delaying environment variable expansion" is proposed.
In batch processing, we can use the setloacl enabledelayedexpansion command to enable "delayed environment variable extension". After we enable "delayed environment variable extension", when CMD interprets commands containing nested formats, it will execute the nested commands one by one, and then perform matching operations, so that our assignment operation will be completed. And after "delayed environment variable extension" is enabled, CMD will use the ! sign to determine whether this is a variable. If the variable is judged using the format of %name% before it is enabled, use the format of !name! after it is judged using the format of !name! We need to pay attention to this symbol!
Example 3,
@echo off setlocal enabledelayedexpansion set var=1 for /l %%i in (1,1,5) do ( set /a var =%%i echo !var! ) pause
In this way, everyone should understand what delay environment variables are expanded. Let's take another example
Example 4,
@echo off set var=test & echo %test% pause
This command is placed in one line, indicating that it is a complete command. If "delayed environment variable extension" is not enabled, the above assignment error will occur! Change it to
OK:
@echo off setlocal enabledelayedexpansion set var=test & echo !var! pause
2. Detailed explanation of batch variable delay
Regarding the delayed expansion of environment variables, you can view some instructions using set /?, but considering its rough translation level, it is recommended that before viewing, first switch chcp 437 to English to view the original English instructions. Given that the article has been explained in detail and there are several code examples, it should not be difficult to understand. Only a little addition is made here.
In many visible official documents, a pair of percent signs are used to close environment variables to complete the replacement behavior of their values, called "expansion". This is actually a first-party concept, called from the perspective of the command interpreter, and from the perspective of our users, we can think of it as a reference, call, or get.
The behavior of the command interpreter extends the environment variable is roughly as follows: First, read a complete statement on the command line. After some preprocessing is performed, before the command is interpreted and executed, the string closed with a percent sign will be matched. If an environment variable matching the string is found in the environment space, the original string and the percent sign themselves will be replaced with its value. If it is not matched, it will be replaced with an empty string. This process is the "extension" of the environment variable, which still belongs to the preprocessing category of the command line.
A "complete statement" is interpreted in the command interpreter CMD of NT as a statement containing statement blocks such as "for if else" and a compound statement connected with "& | && ||", etc.
Therefore, when CMD reads the for statement, all statements closed with a pair of circular expansions will be read together and the necessary preprocessing work will be completed, including the expansion of environment variables. Therefore, before all statements in for are executed, all environment variables have been replaced with the value set before for, thus becoming a string constant, not a variable anymore. No matter how those environment variables are modified in for, what is really affected is the environment variable space, not the inside of the for statement.
In order to be able to perceive the dynamic changes of environment variables within the for statement, CMD designed the delayed environment variable expansion feature. That is, after CMD reads a complete statement, it will not immediately execute the variable's expansion behavior, but will expand before a single statement is executed, that is, this expansion behavior is "delayed".
The delayed environment variable expansion feature is turned off by default in CMD. There are currently two ways to enable it: one is CMD /v:off (the statement here is incorrect, it should be CMD /v:on—namejm Note), which will open a new command line shell. Before exiting this shell with exit, the extension feature is always valid and is often used in the command line environment; the other is setlocal EnableDelayedExpansion, which will limit the modification of environment variables to local space. After endlocal, the extension feature and previous modification of environment variables will disappear together, which is often used in batch statements.
The above is a post written by Willsort, which is difficult for novices to understand. But it doesn't matter. Let's analyze an example first, which is also quoted from Willsort boss.
This example enables variable delay, which is a correct example!
Example 1,
@echo off & setlocal EnableDelayedExpansion
for /f "tokens=* delims=" %%i in ("Hello world.") do (
set n=%%i
set n=!n:ld.=t!
set n=!n:o w= S!
set n=!n:He=Wi!
echo !n!
)
PauseSave the above code as .bat and double-click to execute, the "Will Sort" string will be displayed. The following will explain the meaning of each statement:
1.@echo off & setlocal EnableDelayedExpansion
Turn off command echo and enable variable delay
/f "tokens=* delims=" %%i in ("Hello world.") do ( )
For the use of the for command and its parameters, please search for relevant words in the forum. Due to space limitations, no discussion will be made here. If you don't understand its meaning at this time
Think, then you think that its function is to assign the string "Hello world." to %%i. Of course, this is just a stopgap measure. You must learn for in the future.
Use!
n=%%i
Assign the value of %%i (i.e. Hello world.) to the variable n, everyone knows this
n=!n:ld.=t!
Here we will talk about the function of set replacing characters. The meaning of this statement is to first obtain the value of the variable n (at this time the value of n is "Hello world."), and then
Replace the character "t" with the character "ld." and then assign the replaced result to the variable n again (the value of n becomes "Hello mistake" at this time). As for
Set replacement characters are written in the format. You can type "set/?" in CMD to find the paragraph "%PATH:str1=str2%" and explain it.
n=!n:o w= S!
The meaning is the same as the previous sentence, except that the content of the replacement and the replaced content is different. It replaces "S" with "o w" (note that there are spaces before S and w)
The boss of the real willsort wants to prove that the set replacement character supports periods and spaces (there is one after the fourth sentence "ld".). At this time, the value of n is "Hell Sort"
n=!n:He=Wi!
Needless to say, the value of n after executing this sentence is "Will Sort"
!n!
Display the value of variable n
It should be noted that once variable delay is enabled, use it! The number encloses the variables, but cannot use the % number.
Okay, the meaning of each sentence has been finished. The following is a discussion of the issue of variable delay that this post really wants to discuss.
Here we will quote the explanation from Will Sort boss: When CMD reads the for statement, all statements closed with a pair of parentheses will be read together and completed
Necessary preprocessing work, which includes the extension of environment variables, so before all statements in for are executed, all environment variables have been replaced.
Change to the value set before for, so it becomes a string constant, not a variable anymore.
In order to be able to perceive the dynamic changes of environment variables inside the for statement, CMD designed delayed environment variable expansion characteristics, that is, when CMD reads
After a complete statement, it will not immediately perform the extension behavior of the variable, but will expand before a single statement is executed, that is, this
The extension behavior is "delayed".
In general, without enabling variable delay, any variables in brackets (i.e., do) are already before executing the for statement.
Replace the value assigned to the variable by other commands before the for statement. It doesn’t matter if you don’t understand this sentence. Let’s take a look at another example below and you will understand after reading it.
Example 2,
@echo off
for /f "tokens=* delims=" %%i in ("Hello world.") do (
set n=%%i
set n=%n:ld.=t%
set n=%n:o w= S%
set n=%n:He=Wi%
echo %n%
)
PauseThis is similar to the previous example, just all! All numbers are changed to % numbers, which is an example of error. Because it does not enable variable delay and is not used!
The number encloses the variables. We see that its execution result is showing "ECHO is off".
Why is this happening? The reason is that without enabling variable delay, any variable in parentheses (i.e., do) has been replaced with the value assigned to the variable by other commands before executing the for statement.
That is to say the following sentences in this example
set n=%%i set n=%n:ld.=t% set n=%n:o w= S% set n=%n:He=Wi% echo %n%
The first sentence can be executed normally and achieve its purpose, because it simply assigns the value of %%i to the variable n, so there is no problem. The other sentences are like this: long before the for statement was executed, CMD was anxious to perform the replacement behavior of all variable n in these sentences, and replaced it with the value set by other commands before for, so that n becomes a constant. But in this example, before the for statement, there is only the @echo off sentence, and no other commands have done any assignment to n, so before for, the value of the variable n is empty.
That is to say, after the variable n in set n=%n:ld.=t% is read (note that it is reading but not executing) the complete for statement (it is not set's turn to perform its own task at this time), it is immediately replaced with a null value. There is nothing in a null value, so there is no such thing as a character replacing another character (how to replace nothing?). Finally, when the set n=%n:ld.=t% statement is executed, it just gets a null value and then assigns a null value to the variable n. The other sentences have the same principle.
Therefore, when echo %n% is finally echo, the variable n is still a null value, and the echo command has nothing to display, so it can only display the sentence "ECHO is in a closed state" to illustrate your state
Through this example, I believe everyone already knows the role of variable delay! Let’s look back at Example 1.
After enabling variable delay, execute
set n=!n:ld.=t! set n=!n:o w= S! set n=!n:He=Wi! echo !n!
Before these statements, the variable n in them will not be replaced immediately by CMD (after delay is enabled, CMD becomes patient ^_^), and if it is not replaced, then n is still a variable, not a constant. The variable n is not replaced until the sentences are executed by setting n=!n:ld.=t! This way each set command can perceive any change in variable n, thereby making the correct substitution behavior. This is the variable delay!
Don't think that only for requires variable delay. The following example also requires
Example 3, This is a wrong example
@echo off set mm=girl&echo %mm% pause
"ECHO is closed" is still displayed after execution.
The reason is that delay is not enabled, and there is no other command to assign mm before the set mm=girl&echo %mm% statement. At this time, before CMD executes the set mm=girl&echo %mm% statement, it is already anxious to replace the value of the variable mm. Because mm is not assigned a value before, mm is replaced with a null value and becomes a constant. When the echo command is executed, it is actually an echo constant that will not change, which in this case is a null value.
Some people may ask, hasn’t echo assigned a value to mm before?
This is related to the steps of CMD explaining the commands. You can refer to the willsort post at the beginning of this post.
In general, if variable delay is not enabled, in this case, echo will not pay attention to it or know whether there are other commands in front of it (referring to the same line statement) to assign values to mm. It will only get the content of the variable it wants to display from the above statement set mm=girl&echo %mm%. That is to say, the echo command will display the value of the previous line or the previous line command.
Everyone will understand:
@echo off set mm=boy set mm=girl&echo %mm% pause
Just look at what results are displayed!
This is the correct way to write Example 3:
@echo off&setlocal EnableDelayedExpansion set mm=girl&echo !mm! pause
After variable delay is enabled, the variable expansion (replacement) behavior is postponed until the echo command is executed. At this time, echo can perceive the command before it (set in this example)
What "bad things" did the variable mm to make the correct judgment and execute it
3. Batch delay variables (common explanation)
Variable Delay setlocal EnableDelayedExpansion
A problem that makes most beginners have headaches. Although there are many online tutorials, most of them cannot be understood. There are too many professional terms in it.
Take this tutorial from the willsort of the cn-dos alliance as an example (I personally think it is an authoritative and professional explanation)
But it may be because of my major that I can’t understand it, because those who study cmd batch processing are not necessarily computer majors. This ghost thing is indeed not easy to understand. I have been working hard for a long time and have summarized a little experience and explained it in a popular way. I hope it can help novices. The old birds laughed and if there is anything wrong, please point it out.
Back to the topic
When is the need for delay variables, and how to reference delay variables, I think this is the question that most newbies are eager to know.
After reading the following patiently, I think it should be helpful to you.
To understand the delay variable, first of all, you need to understand what "compound statement" is, it seems that there is another "professional" term. Don't worry, this is very easy to understand. The so-called "compound statement" refers to all commands in a pair of (). For example, behind the do
like:
for /f "delims=" %%i in () do ( set var=%%i echo %%i set num=%%i )
The three commands after do here are in a pair of (), which is called "compound statement", of course not only for but also if, etc. . .
like:
if "%var%"=="abc" ( echo ok set lis=123 )
Anyway, all commands in () are called "compound statements".
In addition: this is also a compound statement set abc=123&echo %abc% Yes, the command connected through pipeline commands & is also a compound statement.
OK, after understanding the compound statement, I will start talking about delay variables now, that is, delay variables must be used in compound statements.
We don’t understand what “variable extension” is called too professional. I still don’t understand it very well. We only need to know when to use delay variables and how to correctly extract the variables we need. This is our purpose. When cmd is processing "compound statements", if a variable is used in the "compound statement", the value of the variable will be referenced as the value of the variable before the compound statement. If the variable has not been assigned before this, treat it as a null value.
Example 1,
@echo off for /l %%i in (1 1 10) do ( set var=%%i echo %var% ) Pause
Run the above code and what to display? Shows that 10 echoes are in the off state. According to logic, the values of var should be 1, 2, 3,......10 in sequence
yes!
This is because the delay variable is not enabled. cmd refers to the value of var as the value before the compound statement.
In this example, the compound statement is not defined before, so the value of var is empty, so 10 echoes will be displayed in the closed state.
Example 2,
@echo off set var=abc for /l %%i in (1 1 10) do ( set var=%%i echo %var% ) Pause
What will be displayed when running the above code? You should know?
Example 3,
@echo off set var=abc for /l %%i in (1 1 5) do ( set var%%i=%%i echo %var% ) echo %var1% %var2% %var3% %var4% %var5% pause
After running the above code, all the values assigned in the compound statement are displayed. What does this mean?
Explanation: In compound statements, it is not that the variable is not assigned a value, but if you do not enable the delay variable, you cannot extract it from the compound statement. You must wait until the compound statement is completed before it can be extracted.
The representation methods of variables: two types: 1. %var% 2. !var!
As we all know, the second is to refer to delayed variables.
When the delay variable is turned on, if it is outside the compound statement, it is OK to use any method to express it. But if you want to refer to variables obtained instantly by compound statements in compound statements, you need to use the second method. See examples
Example 4,
@echo off setlocal EnableDelayedExpansion set var=abc for /l %%i in (1 1 10) do ( set var=%%i echo %var% echo !var! ) Pause
Note: In the example, there are two echos, one is to display %var% and the other is to display !var!
The result is very clear. %var% shows the value of the variable var before the compound statement, while !var! shows the value obtained instantly in the compound statement.
Example 5,
@echo off setlocal EnableDelayedExpansion for /l %%i in (1 1 5) do ( set var%%i=%%i ) echo %var1% %var2% %var3% %var4% %var5% echo !var1! !var2! !var3! !var4! !var5! pause
What does this example mean? No need to explain it anymore?
This shows that when the delay variable is turned on, and outside the compound statement, variables can be represented by both methods. That's all. The above explanation is entirely based on personal understanding and is also for the convenience of non-professional people. There must be errors in the explanation, just like when learning English, the pronunciation of Chinese characters is used to explain it for the convenience of memory. Haha, it is a kind of "partial gate". Novice should not regard what is said above as "truth", otherwise it will become "misleading".
4. When to use delay variables? How to use it?
When to use delay variables? How to use it? These have always been the things that confuse novices, so what exactly is it like? Then please see the example below, we will guide you step by step.
Example 1,
@echo off set /a num=0 for /l %%i in (1 1 3) do ( Rem ================================ set /a num =1 Rem The original meaning is variablenumThe value of1 Rem ================================ echo %num% ) pause>nul
Guess what the result will be after running? Do you think it will show: 1 2 3? I think most people think so. You can save the above code as a batch file, run it and see the results.
You will see that the result displayed is not the expected 1 2 3 but 0 0 0. Why is this?
It turns out that this is because when batch processing variables in for or if statements, it must first preprocess. The variables enclosed with %% are replaced with the variables before the statement (such as the above code, %num% in the for statement has long been replaced with the value before the statement: 0). Therefore, although 1 has been added to the variable when the for statement is run, the value remains unchanged (because %num% in echo %num% has long been replaced with: 0).
So, what should I do to achieve real-time changes in variables in (for or if) statements (such as here, I will display 1 2 3)? Then you need to use the delay variable, first declare in the batch process: setlocal enabledelayedexpansion, and then change the statement: echo %num% to !num! (that is, change "%" to "!"), so that the effect can be achieved. Demo code:
Example 2,
@echo off
Rem ''''//////////////////////////////////////setlocal enabledelayedexpansion
set /a num=0
for /l %%i in (1 1 3) do (
Rem =========================================
set /a num =1
Rem variable num value is added 1 each time
Rem =========================================
Rem '''''''/////////////////////////// The following variables cannot be enclosed with "%", but should be "!"//////////////////////////////////////////////////////////////////////////// echo !num!
)
pause>nulSummary:
1. Why use delay variables?
Let the variables in if statements and for statements change in real time;
2. When to use delay variables?
It is generally used in for statements and if statements;
3. How to use delay variables?
First declare the use of delay variable in batch processing: setlocal enabledelayedexpansion
Then enclose the variables in the for statement and if statement in two "!"
4. In fact, when using variable nested variables, you can also use variable delays.
Example 3,
@echo off set a=1 set b1=10 echo %b%a%% pause
Execution shows that %b1% is obtained
Actually, what I want is to assign the value to b1, that is, 10. So how to implement it? Modify the above example as follows,
Example 4,
@echo off set a=1&set b1=10 call,echo %%b%a%%% pause>nul
call This is actually reorganizing and expanding the command line, first expanding %a% in %%b%a%% to make %a% the value of a 1, and then use cal to expand %b1%.
It can also be implemented using variable delay, as follows:
Example 5,
@echo off set /a a=1,b1=10 Setlocal EnableDelayedExpansion echo:!b%a%! ... pause
The usage of call here is actually a shortcut to variable delay, which is generally used in the for loop body.
call,%%b%a%%% The comma here is actually a separator. Like spaces, there are many separators available, such as echo:!b%a%! in the above example,
Of course not all commands can be used like this, depending on the situation...
Example 6,
@echo off&setlocal enabledelayedexpansion set a=1000 set b=dd set a%b%=9000 set c=!a%b%! echo %c% pause
Execute it and see what will be displayed? Why is this so? I believe that you can also analyze it through Example 4 and Example 5, right?