plp626

:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:: 这个代码可以根据设定，比较出以下因素：
:: 1、 垃圾变量数
:: 2、 set赋值方式（是否带/a参数）
:: 3、 待赋值变量是否已经包含在垃圾变量集合内
:: 对赋值操作耗时的影响
:::::::::::::::::::::::::::::::::::::::::::::::::::::::
@echo off&setlocal EnableDelayedExpansion

:: loop值不能过小，便于比较出差异
set/a loop=6000
set/a p=500
set/a num=loop/p
:: 测试变量为已储存变量数的5百分之一
:: 能看出均匀增加，但测试结果和loop值的千分之一有直接关系

set "pre1=_"      :: 垃圾变量前缀
set "pre2=_"      :: 待赋值变量前缀
set "med=set "  :: 赋值方式

======================%测试开始%=========================

if "%pre1%"=="%pre2%" (
	echo “垃圾变量名”中【含有】待赋值变量的测试
) else (
	echo “垃圾变量名”中【不含有】待赋值变量的测试
)
:: 生成“垃圾变量”
for /l %%a in (1,1,%loop%) do set %pre1%%%a=1

:: 测试赋值耗时变化
for /l %%z in (1 1 %num%)do (set/a tp=tt,tt=0
	set t1=!time!
	for /l %%a in (1 1 %loop%)do %med% %pre2%%%z=1
	set t2=!time!
set/a tt=1!t2:~-5,2!!t2:~-2!-1!t1:~-5,2!!t1:~-2!,tt+="-6000*(tt>>31)"
set /a cc=tt-tp
echo  执行%loop%次%med% %pre2%%%z=1耗时：!tt!，阶差：!cc!
)

pause
复制代码

plp626

昨晚的测试代码含有call，运行后比较不出来，但把语句放在一个复合语句里却可以，

原因分析
1、垃圾变量设定太少；
2、call的堆栈也占用空间；

plp626

@echo off
:: loop值不能过小（大于2000即可），便于看出差异
set/a loop=6000
set/a p=500
set/a num=loop/p
:: 测试变量为已储存变量数的5百分之一，
:: 能看出均匀增加，但测试结果和loop值的千分之一有直接关系

echo “垃圾变量名”中【含有】待赋值变量的测试

for /l %%a in (1,1,%loop%) do set _%%a=1

setlocal EnableDelayedExpansion

for /l %%z in (1 1 %num%)do (set/a tp=tt,tt=0
	set t1=!time!
	for /l %%a in (1 1 %loop%)do set _%%z=1
	set t2=!time!
set/a tt=1!t2:~-5,2!!t2:~-2!-1!t1:~-5,2!!t1:~-2!,tt+="-6000*(tt>>31)"
set /a cc=tt-tp
echo  执行%loop%次set _%%z=1耗时：!tt!，阶差：!cc!
)

pause
复制代码

运行结果：

“垃圾变量名”中【含有】待赋值变量的测试
 执行6000次set _1=1耗时：125，阶差：125
 执行6000次set _2=1耗时：148，阶差：23
 执行6000次set _3=1耗时：183，阶差：35
 执行6000次set _4=1耗时：215，阶差：32
 执行6000次set _5=1耗时：252，阶差：37
 执行6000次set _6=1耗时：286，阶差：34
 执行6000次set _7=1耗时：289，阶差：3
 执行6000次set _8=1耗时：290，阶差：1
 执行6000次set _9=1耗时：291，阶差：1
 执行6000次set _10=1耗时：122，阶差：-169
 执行6000次set _11=1耗时：125，阶差：3
 执行6000次set _12=1耗时：128，阶差：3
复制代码

plp626

为什么要用 set /a 呢？set /a 能代表单纯的变量读写吗?
hanyeguxing 发表于 2011-4-23 03:04

你考虑的也挺全面的呵。。。，

hanyeguxing

环境变量名是按字符逐字顺序排列的，例如2排在17的后面，下面两图是系统环境变量在内存中的存储
.


.
为什么要用 set /a 呢？set /a 能代表单纯的变量读写吗？使用 set a=%#10000% 这样的形式更合适吧？
测试代码：

@echo off
rem set n=10000 1 39999
rem set n=39999 -1 10000
echo %time%开始%n%
for /l %%a in (%n%) do set #%%a=1
echo %time%赋值完成
for /l %%a in (%n%) do set a=%#10000%
echo %time%第一批完成
for /l %%a in (%n%) do set a=%#39999%
echo %time%第二批完成
pause
复制代码

第一次set n=39999 -1 10000倒序两个差距千分之1.3，第二次set n=10000 1 39999正序（没关第一个cmd）差距千分之2.17
.

.
怎么就没得出有那么大的差距呢？
.

.
命令解释器在读写变量时是按照变量名逐个顺序匹配的的。
1，变量名顺序，以上图本地化变量组为例。
2，特例。特殊情况也是存在的，例如变量 %COMSPEC% 就单独排在整个变量的最前面。这个破规则从MS-DOS时代就开始了，因为那个时候他是核心，到今天的系统依然作如此保留。
3，两个变量之间由 00 空字符分隔
4，逐字匹配。先以变量名的第一个字符在本地变量存储空间顺序匹配变量名的第一个字符；如果匹配到，则继续在以第一字符开头的区间内继续匹配第二个字符，如果没有就直接返回为空...以此类推，而不是遍历整个变量存储空间。
这样做的好处是大大加快变量的读写速度。
如果变量存储的顺序是按照赋值的先后排列的话，那么每次读取都需要完整遍历一次整个本地变量空间，那是很没效率的，微软也不会这么设计。

batman

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

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

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

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

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

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

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

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

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
复制代码

neorobin

懒人关注: 等各位阶段性的研究成果, 支持!

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
复制代码

caruko

50# batman


似乎，只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默认序列进行的。

plp626

你这样，应该还有很多CALL的耗时在内。
caruko 发表于 2011-4-23 00:24

call的耗时不会计算在内。都是开始时间和结束时间存到变量，然后结束后计算的，再保存到变量内。

plp626

上面那个代码是用set/a定义_?，下面用直接用set，不带参数定义，看看运行结果：

[code]@echo off
for /l %%a in (900 1 999)do call:xp %%a _ 已定义_[1-1000]再定义_?的耗时与直接定义_?变量
echo -------------------
for /l %%a in (900 1 999)do call:xp %%a # 已定义#[1-1000]再定义_?的耗时与直接定义_?变量
pause
:xp
setlocal enabledelayedexpansion
        call:tt
        call:etime t1 t2 one
        for /l %%a in (1,1,1000) do set %2%%a=1
        call:tt
        call:etime t1 t2 two
set/a pp=two/one,r=(two%%one)*10/one
echo 变量: _%1 %3耗时比: !pp!.%r%
endlocal&goto:eof

:tt -------------------------- sub -----------------------------
set t1=%time%
for /l %%a in (1 1 1000)do set _%1=1
set t2=%time%
goto:eof
:etime
setlocal enabledelayedexpansion
set/a rt=1!%2:~-5,2!!%2:~-2!-1!%1:~-5,2!!%1:~-2!,%3+=-6000*("%3>>31")
endlocal&set %3=%rt%&goto:eof
复制代码

[/code]

caruko

你这样，应该还有很多CALL的耗时在内。

plp626

做了一个变量赋值除了与已有变量数量有关外还和字符串的数据有关，但不是单纯的按ascii码顺序，还没找到规律，大家运行这个代码看看合字符串的顺序

_900到_999这样的变量是按照ascii码顺序的，耗时比值不是单调的。暂对规律不做猜想

@echo off

for /l %%a in (900 1 999)do call:xp %%a _ 已定义_[1-1000]再定义_?的耗时与直接定义_?

变量
echo -------------------
for /l %%a in (900 1 999)do call:xp %%a # 已定义#[1-1000]再定义_?的耗时与直接定义_?

变量

pause
:xp
setlocal enabledelayedexpansion
        call:tt
        call:etime t1 t2 one
        for /l %%a in (1,1,1000) do set %2%%a=1
        call:tt
        call:etime t1 t2 two
set/a pp=two/one,r=(two%%one)*10/one
echo 变量: _%1 %3耗时比: !pp!.%r%
endlocal&goto:eof

:tt -------------------------- sub -----------------------------
set t1=%time%
for /l %%a in (1 1 1000)do set/a _%1=1
set t2=%time%
goto:eof
:etime
setlocal enabledelayedexpansion
set/a rt=1!%2:~-5,2!!%2:~-2!-1!%1:~-5,2!!%1:~-2!,%3+=-6000*("%3>>31")
endlocal&set %3=%rt%&goto:eof
复制代码