batman

　　caruko很有研究和较真的精神，先在这里赞一个！的确，我们在平常一直要求新手写代码的执行效率要高。

这只是为了大家养成一个好的习惯而已。而其实我们在实际中处理问题都是现写现用，有时根本没有去考虑代码

执行效率的问题，只求能把问题解决了就好。毕竟程序再怎么慢也要比人手动快n倍，说句俏皮话：让代码飞一会

儿。当然，在学习研究的时候我们还是要注重这个代码执行效率的问题。

　　当代码运行时产生大量的变量肯定是对运行时间有影响的，因为变量是储存在内存中的，也就是说变量越多

程序消耗的内存就越大，大家都知道当内存占用率接近100%时，用电脑做任何事情都是很慢很慢的，在这里

是一个道理，当程序运行时产生足够多的变量时，它就会占去绝大部分的内存空间而导致电脑变慢甚至死机（

不信的话就用批去定义一亿个变量）。大家注意在这里变量所影响的并不是程序的执行效率而是电脑的运算处

理速度，所以个人认为只要电脑的内存足够大，大量的变量的存在是不会对程序的执行效率带来多大的影响的。

batman

大家是不是对代码执行效率有了误解？如对一个变量操作的时间为一个单位，同时对10000个变量操作的时间小于或等于一万个单位，这样的执行效率则是正常。但如对一个变量操作的时间为一个单位，而对10000个变量操作的时间远远大于一万个单位，这样的执行效率就不是正常的，也才能说因为大量的变量的存在让代码执行效率有了改变。
    至于caruko所提出的读取_1和_9999的速度不一样，我认为存在误区，以下面的代码来证明：

@echo off
for /l %%a in (1,1,10000) do set "_%%a=a"
echo %time%
echo %_1%
echo %time%
echo %_9999%
echo %time%
pause>nul
复制代码

我本机上一次运行结果如下（几乎都是不需要时间的，何来的差距很大）：
18:59:59.82
a
18:59:59.82
a
18:59:59.82

batman

13# caruko
代码：

@echo off
echo %time%
for /l %%a in (1,1,10000) do set /a _9+=1
echo %time%
for /l %%a in (1,1,10000) do set /a _10000+=1
echo %time%
pause>nul
复制代码

运行结果：
19:12:49.35
19:12:49.57
19:12:49.79
哪来的巨大的相差？

batman

16# caruko
看我13楼是不是10000次？

batman

真的是没有调查就没有发言权，我之前有点想当然了。。。

但是按理来说，变量在内存中的存储应该是堆栈，先入的后出，也就是说在定义_1-_10000的变量时，_1变量

在堆栈中应该是放在堆栈的最下面的，而_10000变量是在堆栈的顶部，如果遵循先入后出的原则，则读取_10

000变量的时间是最短的，而读取_1变量的时间是最长的。

但是从caruko的测试中我们可以看出读取_1和_10000变量的时间是差不多的，而读取_9和_9999变量的时

间也是差不多的，但是读取_1和_9以及读取_9999和_10000的时间却出现了很大的相差。这不得不让我们

从cmd默认排序机制上猜想，在内存中变量_1至_10000的排列是_9999置于最底部，接着是_9998.......

_9990,_999,_9989....._9980,_998,_9979......._10000,_1000,_100,_10,_1，_1是置于最顶部。

这一猜测几乎可以推翻开始堆栈的设想，除非在堆栈中变量名也存在排序的机制。真的希望有牛人能找到变量

在内存的存放地址，这样真相才能大白于天下。

batman

可能以下代码能说明一点问题：

@echo off&setlocal enabledelayedexpansion
for /l %%a in (1,1,1000) do set /a "_%%a=1"
for /l %%a in (1,1,100) do (
    set "t=!time!"
    for /l %%b in (1,1,10000) do set /a _%%a+=1
    set "t1=!time!"&set "a="
    if "!t:~,2!" lss "!t1:~,2!" set "a=+24"
    set /a ".%%a=(!t1:~,2!-!t:~,2!!a!)*360000+(1!t1:~3,2!%%100-1!t:~3,2!%%100)*6000+(1!t1:~6,2!%%100-1!t:~6,2!%%100)*100+(1!t1:~-2!%%100-1!t:~-2!%%100)" 
)
set .
pause>nul
复制代码

这是将_1到_100变量计算10000次的时间（ms）用.1到.100变量储存然后列出，本机上运行结果如下：

.1=50
.10=54
.100=69
.11=54
.12=57
.13=57
.14=59
.15=63
.16=62
.17=66
.18=67
.19=70
.2=62
.20=68
.21=70
.22=72
.23=73
.24=75
.25=78
.26=78
.27=80
.28=85
.29=82
.3=78
.30=83
.31=85
.32=87
.33=88
.34=89
.35=90
.36=96
.37=93
.38=97
.39=100
.4=91
.40=97
.41=100
.42=101
.43=103
.44=105
.45=108
.46=109
.47=111
.48=114
.49=116
.5=106
.50=112
.51=114
.52=118
.53=118
.54=119
.55=123
.56=124
.57=126
.58=127
.59=128
.6=119
.60=130
.61=128
.62=133
.63=133
.64=134
.65=137
.66=138
.67=140
.68=141
.69=144
.7=131
.70=143
.71=146
.72=146
.73=147
.74=152
.75=151
.76=154
.77=154
.78=156
.79=159
.8=145
.80=158
.81=160
.82=161
.83=166
.84=175
.85=194
.86=178
.87=174
.88=173
.89=177
.9=159
.90=173
.91=175
.92=176
.93=180
.94=180
.95=182
.96=185
.97=184
.98=191
.99=187
复制代码

从这个运行结果可以看出确实变量名的存储和读取是按照cmd默认序列进行的。

batman

再测试（这下等得我。。。。）
代码：

@echo off&setlocal enabledelayedexpansion
for /l %%a in (1,1,10000) do set /a "_%%a=1"
for /l %%a in (1,1,100) do (
    set "t=!time!"
    for /l %%b in (1,1,10000) do set /a _%%a+=1
    set "t1=!time!"&set "a="
    if "!t:~,2!" lss "!t1:~,2!" set "a=+24"
    set /a ".%%a=(!t1:~,2!-!t:~,2!!a!)*360000+(1!t1:~3,2!%%100-1!t:~3,2!%%100)*6000+(1!t1:~6,2!%%100-1!t:~6,2!%%100)*100+(1!t1:~-2!%%100-1!t:~-2!%%100)" 
)
set .
pause>nul
复制代码

运行结果：

.1=389
.10=390
.100=413
.11=406
.12=426
.13=439
.14=466
.15=473
.16=502
.17=514
.18=520
.19=546
.2=528
.20=520
.21=537
.22=555
.23=577
.24=590
.25=606
.26=625
.27=647
.28=652
.29=677
.3=654
.30=657
.31=678
.32=697
.33=717
.34=736
.35=738
.36=758
.37=786
.38=799
.39=810
.4=782
.40=791
.41=804
.42=823
.43=841
.44=855
.45=872
.46=887
.47=906
.48=926
.49=943
.5=918
.50=918
.51=961
.52=969
.53=978
.54=992
.55=1011
.56=1018
.57=1033
.58=1059
.59=1067
.6=1050
.60=1052
.61=1071
.62=1085
.63=1107
.64=1118
.65=1136
.66=1154
.67=1176
.68=1200
.69=1216
.7=1179
.70=1192
.71=1206
.72=1224
.73=1242
.74=1254
.75=1280
.76=1302
.77=1322
.78=1324
.79=1345
.8=1330
.80=1356
.81=1372
.82=1366
.83=1387
.84=1395
.85=1425
.86=1444
.87=1452
.88=1461
.89=1483
.9=1455
.90=1473
.91=1486
.92=1520
.93=1522
.94=1536
.95=1549
.96=1566
.97=1586
.98=1644
.99=1646
复制代码

batman

接着测试（又是一次头大的等待）
代码：

@echo off&setlocal enabledelayedexpansion
for /l %%a in (1,1,10000) do set /a "_%%a=1"
for /l %%a in (1,1,9) do (
    set "num="
    for /l %%b in (1,1,4) do ( 
        set "num=!num!%%a"
        for %%a in (!num!) do (
            set "t=!time!"
            for /l %%b in (1,1,10000) do set /a _%%a+=1
            set "t1=!time!"&set "a="
            if "!t:~,2!" lss "!t1:~,2!" set "a=+24"
            set /a ".%%a=(!t1:~,2!-!t:~,2!!a!)*360000+(1!t1:~3,2!%%100-1!t:~3,2!%%100)*6000+(1!t1:~6,2!%%100-1!t:~6,2!%%100)*100+(1!t1:~-2!%%100-1!t:~-2!%%100)" 
       )
    )
)
set .
pause>nul
复制代码

运行结果：

.1=393
.11=440
.111=409
.1111=411
.2=525
.22=559
.222=566
.2222=562
.3=657
.33=711
.333=717
.3333=722
.4=796
.44=866
.444=877
.4444=876
.5=928
.55=1019
.555=1036
.5555=1028
.6=1065
.66=1166
.666=1181
.6666=1183
.7=1191
.77=1317
.777=1336
.7777=1342
.8=1353
.88=1483
.888=1490
.8888=1507
.9=1476
.99=1633
.999=1655
.9999=1656
复制代码

batman

上面的三次数据测试基本可以证明：

    cmd对变量的储存和读取是遵循其默认的序列机制的，即cmd会将当前设置的变量+=号+值的所有字符放在

一起进行正序排列（ansi编码序列），排前的字符放入内存中靠前的地址，而将排后的字符放入内存中靠后的地

址。然后在后面的读取寻址中则是一个遍历的过程，即首先查找比对存入最前地址中的字符，如果相符则取出

，如不相符则对下一个地址进行比对，一直到找到完全的匹配。也就是说当内存中储存的变量越多时，而要取

出后面地址中储存的变量所要消耗的时间越长（如在前面地址中则无明显时间的变化），也就是说当出现大量

变量时，对于排序在前的变量在程序中的运算影响并不是很大，而对排序在后的变量在程序中的运算这个影响

将是巨大的。由此可见cmd无论从哪个方面都逃不开其根本的序列机制（字符的ansi编码序列）。

batman

hanyeguxing的debug变量储存展示已经力证了变量存储是按照变量名+=号+值全字符的ansi序列先后进行的，为什么还要强调变量的读取又不是按照这一基本序列机制呢？

batman

hanyeguxing的debug变量储存展示已经力证了变量存储是按照变量名+=号+值全字符的ansi序列先后进行的，为什么还要强调变量的读取又不是按照这一基本序列机制呢？

batman

加入debug的测试
代码：

@echo off&setlocal enabledelayedexpansion
call :lp 1 10 random
call :lp 11 100 random
del /q db
goto :eof
:lp
for /l %%a in (%1,1,%2) do set "_%%a=!%3!"
(echo d2cl2
echo q
echo,
)>db
(for /f "skip=1 tokens=2,3" %%a in ('debug^<db') do (
     echo d%%b%%a:0380&echo q&echo,
))>tem
del /q db&ren tem db
debug<db>%1.txt
start %1.txt
复制代码

1.txt

-d0D96:0380

0D96:0380  00 5F 31 3D 36 31 33 35-00 5F 31 30 3D 32 38 36   ._1=6135._10=286
0D96:0390  31 32 00 5F 32 3D 32 39-36 38 30 00 5F 33 3D 32   12._2=29680._3=2
0D96:03A0  33 30 36 39 00 5F 34 3D-33 31 32 32 37 00 5F 35   3069._4=31227._5
0D96:03B0  3D 38 34 37 37 00 5F 36-3D 32 33 39 38 38 00 5F   =8477._6=23988._
0D96:03C0  37 3D 33 32 36 31 36 00-5F 38 3D 32 39 35 38 00   7=32616._8=2958.
0D96:03D0  5F 39 3D 32 37 37 32 31-00 42 4C 41 53 54 45 52   _9=27721.BLASTER
0D96:03E0  3D 41 32 32 30 20 49 35-20 44 31 20 50 33 33 30   =A220 I5 D1 P330
0D96:03F0  20 54 33 00 00 01 00 43-3A 5C 57 49 4E 44 4F 57    T3....C:\WINDOW
-q
复制代码

11.txt

-d0E0D:0380

0E0D:0380  00 5F 31 3D 36 31 33 35-00 5F 31 30 3D 32 38 36   ._1=6135._10=286
0E0D:0390  31 32 00 5F 31 30 30 3D-31 34 36 31 34 00 5F 31   12._100=14614._1
0E0D:03A0  31 3D 35 33 30 37 00 5F-31 32 3D 33 30 32 38 37   1=5307._12=30287
0E0D:03B0  00 5F 31 33 3D 31 30 35-31 00 5F 31 34 3D 35 39   ._13=1051._14=59
0E0D:03C0  36 37 00 5F 31 35 3D 32-37 34 37 38 00 5F 31 36   67._15=27478._16
0E0D:03D0  3D 31 35 33 37 33 00 5F-31 37 3D 31 37 30 31 33   =15373._17=17013
0E0D:03E0  00 5F 31 38 3D 32 36 38-31 37 00 5F 31 39 3D 38   ._18=26817._19=8
0E0D:03F0  31 33 31 00 5F 32 3D 32-39 36 38 30 00 5F 32 30   131._2=29680._20
-q
复制代码

由此可见cmd在变量有变化的情况下会重新分配内存的储存地址，1.txt和11.txt中开始的地址分别为0D96:0380和0E0D:0380，而这一存储过程是按变量名+=号+值的全字符(实际上就是变量名，因为cmd是不会允许有同名变量的存在的)的ansi序列先后进行的。

batman

再次测试（测试前猜想变量减少时，变量的内存存储开始地址不会改变）
代码：

@echo off&setlocal enabledelayedexpansion
del /q db-*.txt
call :lp 1 100 random
call :lp 10 20
del /q db
goto :eof
:lp
for /l %%a in (%1,1,%2) do set "_%%a=!%3!"
(echo d2cl2
echo q
echo,
)>db
(for /f "skip=1 tokens=2,3" %%a in ('debug^<db') do (
     echo d%%b%%a:0380&echo q&echo,
))>tem
del /q db&ren tem db
debug<db>db-%1.txt
start db-%1.txt
复制代码

db-1.txt

-d0DCC:0380

0DCC:0380  00 5F 31 3D 31 34 37 36-32 00 5F 31 30 3D 35 35   ._1=14762._10=55
0DCC:0390  37 37 00 5F 31 30 30 3D-32 31 31 35 33 00 5F 31   77._100=21153._1
0DCC:03A0  31 3D 37 37 35 35 00 5F-31 32 3D 31 35 35 38 36   1=7755._12=15586
0DCC:03B0  00 5F 31 33 3D 31 30 38-31 00 5F 31 34 3D 38 38   ._13=1081._14=88
0DCC:03C0  34 39 00 5F 31 35 3D 34-34 35 31 00 5F 31 36 3D   49._15=4451._16=
0DCC:03D0  31 32 39 34 35 00 5F 31-37 3D 32 35 37 33 35 00   12945._17=25735.
0DCC:03E0  5F 31 38 3D 31 33 30 31-31 00 5F 31 39 3D 32 37   _18=13011._19=27
0DCC:03F0  39 39 35 00 5F 32 3D 31-37 31 31 33 00 5F 32 30   995._2=17113._20
-q
复制代码

db-10.txt

-d0DCC:0380

0DCC:0380  00 5F 31 3D 31 34 37 36-32 00 5F 31 30 30 3D 32   ._1=14762._100=2
0DCC:0390  31 31 35 33 00 5F 32 3D-31 37 31 31 33 00 5F 32   1153._2=17113._2
0DCC:03A0  31 3D 32 37 37 36 30 00-5F 32 32 3D 33 37 36 35   1=27760._22=3765
0DCC:03B0  00 5F 32 33 3D 31 33 30-37 35 00 5F 32 34 3D 37   ._23=13075._24=7
0DCC:03C0  35 38 38 00 5F 32 35 3D-31 31 31 30 36 00 5F 32   588._25=11106._2
0DCC:03D0  36 3D 32 33 36 38 35 00-5F 32 37 3D 31 32 37 38   6=23685._27=1278
0DCC:03E0  39 00 5F 32 38 3D 32 30-33 30 31 00 5F 32 39 3D   9._28=20301._29=
0DCC:03F0  32 31 39 35 31 00 5F 33-3D 31 35 32 32 00 5F 33   21951._3=1522._3
-q
复制代码

可见当变量减少时（部分变量被清空），其实就是对已有变量进行读取操作时，内存确实不会重新洗牌。

batman

还是测试说明问题，但也带来了新问题。。。。
代码：

@echo off&setlocal enabledelayedexpansion
for /l %%a in (1,1,100) do set "d=!d!&echo d"
call :lp _str a
call :lp _str b setlocal endlocal
call :lp _str s
del /q db&pause
goto :eof
:lp
%3
if "%2" neq "s" set "%1=%2"
(echo d2cl2
echo q
echo,
)>db
(for /f "skip=1 tokens=2,3" %%a in ('debug^<db') do (
     echo d%%b%%a:0000%d%&echo q&echo,
))>tem
del /q db&ren tem db
for /f "delims=" %%a in ('debug^<db^|findstr /i "%1="') do echo %%a
echo,
%4
复制代码

结果：

0DBD:0640  5F 53 54 52 3D 61 00 42-4C 41 53 54 45 52 3D 41   _STR=a.BLASTER=A

0DBD:0640  5F 53 54 52 3D 62 00 42-4C 41 53 54 45 52 3D 41   _STR=b.BLASTER=A

0DBD:0640  5F 53 54 52 3D 61 00 42-4C 41 53 54 45 52 3D 41   _STR=a.BLASTER=A

Press any key to continue . . .
复制代码

上面的测试表明，setlocal前以及setlcoal-endlocal中以及endlocal后_str变量在内存中储存的地址没有改变（至少是开始值没有改变）。同时说明了cmd中为什么变量名不分大小写，因为不管变量中的字符是不是大小写，内存中统一是以大写的字符储存的变量。但这里又有一个问题了，既然内存中只会储存一个名为_str的变量，那么endlocal后这个变量的值又是怎么恢复为前面的值的，难道还有一个临时储存变量的地方？

batman

测试系统变量：

@echo off&setlocal enabledelayedexpansion
for /l %%a in (1,1,100) do set "d=!d!&echo d"
call :lp os
call :lp os a setlocal endlocal
call :lp os
del /q db&pause
goto :eof
:lp
%3
if "%2" neq "" set "%1=%2"
(echo d2cl2
echo q
echo,
)>db
(for /f "skip=1 tokens=2,3" %%a in ('debug^<db') do (
     echo d%%b%%a:0000%d%&echo q&echo,
))>tem
del /q db&ren tem db
for /f "delims=" %%a in ('debug^<db^|findstr /i "%1="') do echo %%a
echo,
%4
复制代码

0DBD:03F0  52 4F 43 45 53 53 4F 52-53 3D 32 00 4F 53 3D 57   ROCESSORS=2.OS=W

0DBD:03F0  52 4F 43 45 53 53 4F 52-53 3D 32 00 4F 53 3D 61   ROCESSORS=2.OS=a

0DBD:03F0  52 4F 43 45 53 53 4F 52-53 3D 32 00 4F 53 3D 57   ROCESSORS=2.OS=W

Press any key to continue . . .
复制代码

系统变量os在setlcoal-enlocal中去哪里了？，假如将os改成path，运行结果如下：

0DBD:0400  69 6E 64 6F 77 73 5F 4E-54 00 50 41 54 48 3D 43   indows_NT.PATH=C

'debug' is not recognized as an internal or external command,
operable program or batch file.
'debug' is not recognized as an internal or external command,
operable program or batch file.

0DBD:0400  69 6E 64 6F 77 73 5F 4E-54 00 50 41 54 48 3D 43   indows_NT.PATH=C

Press any key to continue . . .
复制代码

在重新设定path后，debug命令变得无效。