关于vba：可变的自身迭代-不同类型的不同行为

Variable iterating on itself - different behavior with different types

请查看帖子末尾的最新更新。

特别是，请参阅更新4：变体比较诅咒

我已经见过同伴撞墙撞头，以了解变体的工作原理，但从未想象过自己会遇到麻烦。

我已成功使用以下VBA构造：

For i = 1 to i

当i是Integer或任何数字类型(从1迭代到i的原始值)时，此方法非常适用。我有时会在i是ByVal参数的情况下执行此操作-您可能会说是懒惰的-以免自己声明新变量。

然后，当此构造按预期"停止"工作时，我遇到了一个错误。经过一番艰苦的调试，我发现当i不是声明为显式数字类型，而是声明为Variant时，它的工作方式不同。问题是双重的：

1- For和For Each循环的确切语义是什么？我的意思是编译器按照什么顺序执行动作序列？例如，限制的评估是否在计数器初始化之前进行？循环开始之前，此限制是否已复制并"固定"在某个地方？等等，同样的问题适用于For Each。

2-如何解释变量和显式数值类型的不同结果？有人说变量是(不可变的)引用类型，这个定义可以解释观察到的行为吗？

我已经为涉及For和For Each语句的不同(独立)方案(结合了整数，变量和对象)准备了MCVE。令人惊讶的结果促使人们明确地定义语义，或者至少检查那些结果是否确实符合所定义的语义。

欢迎所有见解，包括部分见解，这些见解可以解释某些令人惊讶的结果或其矛盾。

谢谢。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

Sub testForLoops()
Dim i As Integer, v As Variant, vv As Variant, obj As Object, rng As Range

Debug.Print vbCrLf &"Case1 i --> i ",
i = 4
For i = 1 To i
Debug.Print i, ' 1, 2, 3, 4
Next

Debug.Print vbCrLf &"Case2 i --> v ",
v = 4
For i = 1 To v ' (same if you use a variant counter: For vv = 1 to v)
v = i - 1 ' <-- doesn't affect the loop's outcome
Debug.Print i, ' 1, 2, 3, 4
Next

Debug.Print vbCrLf &"Case3 v-3 <-- v",
v = 4
For v = v To v - 3 Step -1
Debug.Print v, ' 4, 3, 2, 1
Next

Debug.Print vbCrLf &"Case4 v --> v-0",
v = 4
For v = 1 To v - 0
Debug.Print v, ' 1, 2, 3, 4
Next

' So far so good? now the serious business

Debug.Print vbCrLf &"Case5 v --> v ",
v = 4
For v = 1 To v
Debug.Print v, ' 1 (yes, just 1)
Next

Debug.Print vbCrLf &"Testing For-Each"

Debug.Print vbCrLf &"Case6 v in v[]",
v = Array(1, 1, 1, 1)
i = 1
' Any of the Commented lines below generates the same RT error:
'For Each v In v '"This array is fixed or temporarily locked"
For Each vv In v
'v = 4
'ReDim Preserve v(LBound(v) To UBound(v))
If i < UBound(v) Then v(i + 1) = i + 1 ' so we can alter the entries in the array, but not the array itself
i = i + 1
Debug.Print vv, ' 1, 2, 3, 4
Next

Debug.Print vbCrLf &"Case7 obj in col",
Set obj = New Collection: For i = 1 To 4: obj.Add Cells(i, i): Next
For Each obj In obj
Debug.Print obj.Column, ' 1 only ?
Next

Debug.Print vbCrLf &"Case8 var in col",
Set v = New Collection: For i = 1 To 4: v.Add Cells(i, i): Next
For Each v In v
Debug.Print v.column, ' nothing!
Next

' Excel Range
Debug.Print vbCrLf &"Case9 range as var",
' Same with collection? let's see
Set v = Sheet1.Range("A1:D1") ' .Cells ok but not .Value => RT err array locked
For Each v In v ' (implicit .Cells?)
Debug.Print v.Column, ' 1, 2, 3, 4
Next

' Amazing for Excel, no need to declare two vars to iterate over a range
Debug.Print vbCrLf &"Case10 range in range",
Set rng = Range("A1:D1") '.Cells.Cells add as many as you want
For Each rng In rng ' (another implicit .Cells here?)
Debug.Print rng.Column, ' 1, 2, 3, 4
Next
End Sub

更新1

一个有趣的发现可以帮助您理解其中的一些内容。关于案例7和案例8：如果我们对要迭代的集合持有另一个引用，则行为将完全改变：

1
2
3
4
5
6

Debug.Print vbCrLf &"Case7 modified",
Set obj = New Collection: For i = 1 To 4: obj.Add Cells(i, i): Next
Dim obj2: set obj2 = obj ' <-- This changes the whole thing !!!
For Each obj In obj
Debug.Print obj.Column, ' 1, 2, 3, 4 Now !!!
Next

这意味着在最初的情况7中，正好在将变量obj分配给集合的第一个元素之后，才对要迭代的集合进行垃圾回收(由于引用计数)。但是，这仍然很奇怪。编译器应该在要迭代的对象上保留一些隐藏的引用！将此与情况6进行比较，其中要迭代的数组被"锁定" ...

更新2

由MSDN定义的For语句的语义可以在此页面上找到。您可以看到明确声明了end-value应该只被评估一次，并且在执行循环之前进行评估。我们是否应该将此奇怪行为视为编译器错误？

更新3

有趣的案例7。 case7的违反直觉的行为不仅限于变量本身的(例如不寻常的)迭代。它可能发生在看似"无辜"的代码中，该代码错误地删除了要迭代的集合上的唯一引用，从而导致其垃圾回收。

1
2
3
4
5
6
7
8
9
10
11

Debug.Print vbCrLf &"Case7 Innocent"
Dim col As New Collection, member As Object, i As Long
For i = 1 To 4: col.Add Cells(i, i): Next
Dim someCondition As Boolean ' say some business rule that says change the col
For Each member In col
someCondition = True
If someCondition Then Set col = Nothing ' or New Collection
' now GC has killed the initial collection while being iterated
' If you had maintained another reference on it somewhere, the behavior would've been"normal"
Debug.Print member.Column, ' 1 only
Next

凭直觉，人们希望在集合上保留一些隐藏的引用，以便在迭代期间保持活动状态。不仅如此，而且程序运行平稳，没有运行时错误，可能会导致硬错误。虽然规范没有说明有关在迭代中操作对象的任何规则，但该实现恰好是保护并锁定了迭代数组(案例6)，但忽略了-甚至没有保存伪引用-在集合上(既不在Dictionary上，我在ve也测试过)。

程序员有责任关心引用计数，这不是VBA / VB6的"精神"和引用计数背后的体系结构动机。

更新4：变式比较诅咒

Variant在许多情况下都表现出怪异的行为。特别是，比较不同亚型的两个变体会产生不确定的结果。考虑以下简单示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Sub Test1()
Dim x, y: x = 30: y ="20"
Debug.Print x > y ' False !!
End Sub

Sub Test2()
Dim x As Long, y: x = 30: y ="20"
' ^^^^^^^^
Debug.Print x > y ' True
End Sub

Sub Test3()
Dim x, y As String: x = 30: y ="20"
' ^^^^^^^^^
Debug.Print x > y ' True
End Sub

如您所见，当两个变量(数字和字符串)都声明为变量时，比较是不确定的。当至少其中之一被显式键入时，比较成功。

比较相等时也会发生同样的情况！例如，?2="2"返回True，但是如果您定义两个Variant变量，将它们分配给它们并进行比较，则比较将失败！

1
2
3
4
5
6
7

Sub Test4()
Debug.Print 2 ="2" ' True

Dim x, y: x = 2: y ="2"
Debug.Print x = y ' False !

End Sub

相关讨论

文档中的描述非常接近Variant的"正式"定义。如果您想要更正式的信息，请访问MSDN的链接。我还不太清楚数据类型，参数类型和循环退出条件在问题中相互之间有什么关系。
一个非常有趣的问题……测试感到"肮脏"，因为它们都在相同的范围内，并且一次又一次地重复使用/重新分配相同的变量，这感觉并不正确-拥有单独的测试方法会很好每个测试用例..只有一个Assert调用... Rubberduck样式:-)
@Comintern感谢您的链接。老实说，我看过该页面，并且知道一个变体的结构。我的问题集中在它的行为上。
Variant是数据类型，因此根据定义，它不具有"行为"。也许这就是为什么我对您的问题感到困惑。您是在问反汇编的VBA循环是什么样吗？
@MatsMug感谢您的评论。我确保每个测试都完全独立于其他测试，并努力缩短MCVE。但是，如果您发现任何错误，请随时通知我。您也可以根据需要编辑帖子：)
@Comintern可以说，我对For和ForEach的语义最感兴趣，并解释了与基本数据类型和对象类型相比，涉及变体时它们的不同行为。
提示：这与在退出条件下使用循环计数器有关。如果我是您，则ID会为心理上的心理准备做好心理准备=)
@MatsMug，谜是VBA如何处理此退出条件...它是否复制到某处？情况1和2表示是这样，但情况5却没有...
为了使问题更突出，我对案例4做了一些改动。 For v = 1 to v与For v = 1 to v-0不同...
有点奇怪：如果您定义的函数Echo(v)的唯一代码行是Echo = v，并且在情况5中将For v = 1 to v替换为For v = 1 To Echo(v)，则它将最终输出1,2,3,4。
@MatsMug您可以更具体地断言吗？抱歉，我想补充一点，但是还没有完全理解。有什么例子吗？
@JohnColeman是的，案例4实际上也是如此：For v = 1 to v-0。奇怪的是，它产生的结果与For v = 1 to v不同。
这看起来很有希望：github.com/bontchev/pcodedmp。您可以进行有根据的猜测，但可能需要查看并理解生成的p代码才能真正了解正在发生的事情(即使那样，由于p代码解释器不是开源的，因此仍会有一些猜测的工作)。
哦，我的意思是像这样的隔离测试方法。 Assert实际上只是一个测试框架API工件，例如Assert.IsTrue expected, actual ;-)
在两种情况下，@ JohnColeman都强制编译器创建v的副本。问题是它是否会自动执行(如情况1)或不执行(如情况5)。这是一个错误，还是定义这个的简洁语义？除了感谢您的链接，我还将看一看。
To v-0的情况必须分配到v位置以外的其他地方，因为它是一个需要求值的表达式(如函数调用结果)。
您可以定义MCVE吗？
@DaveInCaz我尽我所能遵守这个定义:)
在现有答案之外，我只会验证运行时中的实际代码是否符合规范。昨晚我拆解了运行时，但还没有时间进行研究。基本上可以归结为将Variant结构的指针推入堆栈还是将Variant数据区域的指针推入堆栈。相关的事实是，循环是通过msvbvm6库中的函数调用执行的，因此Variant将被装箱两次。
@Comintern在case7中特别令我着迷的是如何在迭代集合时对其进行垃圾回收，但是，我们什至没有任何运行时问题，只是迭代在垃圾回收之后停止了！我可以想象这会导致崩溃，而不仅仅是停止迭代...
没错...但是它们是相关的。但是，您知道，case7(相比于经修改的case7)确实是最吸引我的那个。对我来说，这已经成为"整个事情"。我只是不明白这个GC如何如此顺利地进行而没有任何麻烦，也没有崩溃。
关于case5的另一种说法：我认为它与Variant如何存储在内存中有关-对于数字子类型，分配了16个字节来存储数据子类型和数据的存储位置。初始化For循环时，将v的副本推入堆栈(或其子存储位置)，该堆栈为子类型+内存位置。迭代v时，存储位置的值将更新-v的循环终端值副本所指向的值，因此终端值已更改，循环终止！
感谢@chrisneilsen的评论。问题在于，此链接建议，当嵌入的值为数字时，数据将存储在变量结构本身中，而不是通过指向该数据的指针存储。你怎么看？
但是顺便说一下，您的分析对于case8似乎是完美的。我的意思是与案例7的区别。
@ASH谢谢。我对您提供的链接的理解是，一种变体可以将数字数据存储为值或指针-问题是VBA使用哪个？ (顺便说一下，我对此没有明确的答案)
嗯，确实有两种方法可以存储数字...即LONGLONG llVal或LONGLONG *pllVal(指针)。嗯VBA植入选择了后者！ @chrisneilsen

请在下面查看编辑！

好。

对于每个编辑，也在Edit2下添加了以下内容

好。

在Edit3上对ForEach和Collections进行更多编辑

好。

在Edit4上关于ForEach和集合的最后编辑

好。

关于Edit5的迭代行为的最后说明

好。

当用作循环控制变量或终止条件时，变体评估的语义中这种奇怪行为的部分微妙之处。

好。

简而言之，当变量是终止值或控制变量时，运行时自然会在每次迭代时重新评估终止值。但是，将值类型(例如Integer)压入directly，因此不会重新求值(并且其值不会更改)。如果控制变量是Integer，但是终止值是Variant，则在第一次迭代中，将Variant强制转换为Integer，并进行类似的推送。当终止条件是包含Variant和Integer的表达式时，也会发生相同的情况-将其强制为Integer。

好。

在此示例中：

好。

1
2
3
4
5

Dim v as Variant
v=4
for v= 1 to v
Debug.print v,
next

变量v的整数值为1，并且由于终止变量是变量，因此重新评估了循环终止条件-运行时会识别变量参考的存在，并在每次迭代时强制重新评估。结果，由于回路内重新分配，回路完成。因为变量现在的值为1，所以满足了循环终止条件。

好。

考虑下一个示例：

好。

1
2
3
4
5

Dim v as variant
v=4
for v=1 to v-0
Debug.Print v,
next

当终止条件是一个表达式，例如" v-0"时，该表达式将被求值并强制为正则整数，而不是变量，因此其硬值在运行时被压入堆栈。结果，该值不会在每次循环迭代时重新评估。

好。

另一个有趣的例子：

好。

1
2
3
4
5
6
7

Dim i as Integer
Dim v as variant
v=4
For i = 1 to v
v=i-1
Debug.print i,
next

行为之所以如此，是因为控制变量是Integer，因此终止变量也被强制为整数，然后被压入堆栈进行迭代。

好。

我不能保证这些是语义，但是我相信终止条件或值只是被压入堆栈，因此压入了整数值，或者压入了Variant的对象引用，从而在编译器实现变体时触发了重新评估持有终值。当变量在循环中重新分配，并且在循环完成时重新查询该值时，将返回新值，并且循环终止。

好。

抱歉，这有点泥泞，但是有点晚了，但是我看到了，不禁为答案出手。希望这有道理。啊，好的VBA :)

好。

编辑：

好。

在MS的VBA语言规范中找到了一些实际信息：

好。

The expressions [start-value], [end-value], and [step-increment] are evaluated once, in order, and prior to any of the following computations. If the value of [start-value], [end-value], and [step-increment] are not Let-coercible to Double, error 13 (Type mismatch) is raised immediately. Otherwise, proceed with the following algorithm using the original, uncoerced values.

Ok.

Execution of the [for-statement] proceeds according to the following
algorithm:

Ok.

If the data value of [step-increment] is zero or a positive number,
and the value of [bound-variable-expression] is greater than
the value of [end-value], then execution of the [forstatement]
immediately completes; otherwise, advance to Step 2.

Ok.

If the data value of [step-increment] is a negative number, and the
value of [bound-variable-expression] is less than the value of
[end-value], execution of the [for-statement] immediately completes;
otherwise, advance to Step 3.

Ok.

The [statement-block] is executed. If a [nested-for-statement] is
present, it is then executed. Finally, the value of
[bound-variable-expression] is added to the value of [step-increment]
and Let-assigned back to [bound-variable-expression]. Execution then
repeats at step 1.

Ok.

我从中得到的是，目的是要一次评估一次终止条件值。如果我们看到有证据表明更改该值会从其初始状态改变循环的行为，则几乎可以肯定是由于它是变体，因此可以非正式地称为意外重新评估。如果不是故意的，我们可能只能使用轶事证据来预测其行为。

好。

如果在运行时评估循环的开始/结束/步骤值，并将这些表达式的"值"压入堆栈，则Variant值会将" byref扳手"扔到进程中。如果运行时不首先识别变体，请对其进行评估，然后将该值作为终止条件，那么几乎可以肯定会发生奇怪的行为(如您所示)。正如其他人所建议的那样，在这种情况下，VBA究竟如何处理变体将是pcode分析的一项艰巨任务。

好。

编辑2：前瞻

好。

VBA规范再次提供了对对集合和数组进行ForEach循环评估的见解：

好。

在进行以下任何计算之前，都会对表达式[collection]进行一次评估。

好。

如果[collection]的数据值是一个数组：

好。

如果数组没有元素，则执行[for-each-statement]
立即完成。

好。

如果数组的声明类型为Object，则
[bound-variable-expression]被设置为> array中的第一个元素。否则，将[bound-variable-expression]分配给数组中的> first元素。

好。

设置[bound-variable-expression]后，执行[statement-block]>。如果存在[嵌套声明]，则将其执行。

好。

一旦[statement-block]和(如果存在)[nested-for-statement]已完成执行，就将[bound-variable-expression]分配给>数组中的下一个元素(或者Set-assigned它是> Object的数组)。当且仅当数组中没有其他元素时，[for-each-statement]的执行立即完成。否则，再次执行> [statement-block]，如果> present，则执行[nested-forstatement]，然后重复此步骤。

好。

[for-each-statement]完成执行后，> [bound-variable-expression]的值是> array的最后一个元素的数据值。

好。

如果[collection]的数据值不是数组：

好。

[collection]的数据值必须是对>外部对象的对象引用，该对象支持实现定义的枚举>接口。 [bound-variable-expression]以> implementation-> defined的方式被Let分配或Set分配给[collection]中的第一个元素。

好。

设置[bound-variable-expression]后，执行[statement-block]>。如果存在[嵌套声明]，则将其执行。

好。

一旦[statement-block]和(如果存在)[nested-for-statement]已完成执行，就将[bound-variable-expression]设置为>定义为实现中[collection]中的下一个元素方式。如果[collection]中没有更多元素，则[for-each-> statement]的执行立即完成。否则，将再次执行[statement-block]，然后执行[nested-for-statement](如果存在)，然后重复此步骤。

好。

[for-each-statement]完成执行后，> [bound-variable-expression]的值是> [collection]中最后一个元素的数据值。

好。

以此为基础，我认为很明显，在此示例中，分配给变量的Variant然后变为bound-variable-expression会生成" Array is locked"错误：

好。

1
2
3
4
5
6
7
8
9
10
11
12
Dim v As Variant, vv As Variant
v = Array(1, 1, 1, 1)
i = 1
' Any of the Commented lines below generates the same RT error:
For Each v In v '"This array is fixed or temporarily locked"
'For Each vv In v
'v = 4
'ReDim Preserve v(LBound(v) To UBound(v))
If i < UBound(v) Then v(i + 1) = i + 1 ' so we can alter the entries in the array, but not the array itself
i = i + 1
Debug.Print vv, ' 1, 2, 3, 4
Next

使用'v'作为[bound-variable-expression]会创建一个向V的Let-assignment，它在运行时被阻止，因为它是正在进行枚举的目标，以支持ForEach循环本身。也就是说，运行时将锁定变体，从而避免循环为变体分配不同的值(这必然会发生)。

好。

这也适用于" Redim Preserve"-调整大小或更改数组，从而更改变量的分配，将违反在循环初始化时放置在枚举目标上的锁定。

好。

关于基于范围的分配/迭代，请注意非对象元素的单独语义；"外部对象"提供特定于实现的枚举行为。 excel Range对象具有_Default属性，仅在通过对象名称引用时才被调用，在这种情况下，当用作ForEach的迭代目标时，它不会使用隐式锁定(因此不会生成锁定错误，因为它的语义不同于Variant变量)：

好。

1
2
3
4
5
Debug.Print vbCrLf &"Case10 range in range",
Set rng = Range("A1:D1") '.Cells.Cells add as many as you want
For Each rng In rng ' (another implicit .Cells here?)
Debug.Print rng.Column, ' 1, 2, 3, 4
Next

(可以通过突出显示范围对象，右键单击并选择"显示隐藏的成员"来检查VBA对象浏览器中的Excel对象库来标识_Default属性)。

好。

EDIT3：集合

好。

涉及集合的代码变得有趣并且有些毛躁:)

好。

1
2
3
4
5
6
7
8
9
10
11
Debug.Print vbCrLf &"Case7 obj in col",
Set obj = New Collection: For i = 1 To 4: obj.Add Cells(i, i): Next
For Each obj In obj
Debug.Print obj.Column, ' 1 only ?
Next

Debug.Print vbCrLf &"Case8 var in col",
Set v = New Collection: For i = 1 To 4: v.Add Cells(i, i): Next
For Each v In v
Debug.Print v.column, ' nothing!
Next

在这里，只需要考虑真正的错误即可。当我第一次在VBA调试器中运行这两个示例时，它们的运行与最初问题中提供的OP完全相同。然后，在经过几次测试后重新启动例程，然后将代码恢复为其原始形式(如此处所示)，后一种行为随即开始匹配其上方的基于对象的前任行为！只有在我停止Excel并重新启动它之后，才返回后者循环的原始行为(不打印任何内容)。除了编译器错误外，实际上没有其他方法可以解释。

好。

EDIT4具有变体的可复制行为

好。

注意到我已经在调试器中完成了一些操作，以强制通过Collection的基于变体的迭代至少循环一次(与Object版本一样)，我终于找到了一种可代码重现的更改行为的方式

好。

考虑以下原始代码：

好。

1
2
3
4
5
6
7
Dim v As Variant, vv As Variant

Set v = New Collection: For x = 1 To 4: v.Add Cells(x, x): Next x
'Set vv = v
For Each v In v
Debug.Print v.Column
Next

这本质上是OP的原始情况，并且ForEach循环无需一次迭代即可终止。现在，取消注释" Set vv = v"行，然后重新运行：现在，For Each将迭代一次。我认为毫无疑问，我们在VB运行时的Variant评估机制中发现了一些非常(非常！)细微的错误；等于循环变量的另一个"变量"的任意设置将强制执行一个在For Each评估中不会发生的评估-我怀疑这与以下事实有关：Collection在Variant中表示为Variant / Object / Collection 。添加这个伪造的"集合"似乎可以解决问题，并使循环像基于对象的版本那样运行。

好。

EDIT5：关于迭代和集合的最终想法

好。

这可能是我对该答案的最后修改，但是我不得不强迫自己确保观察到奇数循环行为时将变量用作" bound-variable-expression"，并且极限表达式为特别是在涉及"变量"时，有时是通过迭代来更改"绑定变量表达式"的内容而引起的。也就是说，如果您具有：

好。

1
2
3
4
5
6
7
Dim v as Variant
Dim vv as Variant
Set v = new Collection(): for x = 1 to 4: v.Add Cells(x,x):next
Set vv = v ' placeholder to make the loop"kinda" work
for each v in v
'do something
Next

重要的是要记住(至少对我而言)要记住，在For Each中，通过迭代会更改在'v'中保留的'bound-variable-expression'。也就是说，当我们开始循环时，v拥有一个Collection，并且枚举开始。但是，当该枚举开始时，v的内容现在就是该枚举的乘积-在这种情况下，是一个Range对象(来自Cell)。可以在调试器中看到此行为，因为您可以看到" v"从Collection到Range；表示迭代中的下一个踢返回的是Range对象的枚举上下文所提供的内容，而不是" Collection"。

好。

这是一项很棒的研究，我感谢您的反馈。它帮助我比我想象的更好地理解了事情。除非对此有更多评论或问题，否则我怀疑这将是我对答案的最后修改。

好。

好。

相关讨论

谢谢，感谢您的努力:)。但是，这种尝试性的解释似乎在case2上失败了，不是吗？请再次检查。

不-我试图解决这种情况。情况2是控制变量是一个显式整数的实例，该整数又将限制变量强制转换为整数，从而使循环表现为"正确"(不受循环内控制变量更改的束缚)。

尝试用变量计数器(vv)而不是整数计数器(i)的case2，它将显示出相同的：D

Dim v, vv: v = 5: For vv = 1 To v: v = 2: Debug.Print vv: Next ----> 1, 2, 3, 4, 5。看，即使使用变量控制变量，它也能做到相同。谜底是为什么For v = 1 to v时它没有做同样的事情的原因？

不能解释前者，但要小心后者作为参考-那不是纯粹的苹果对苹果的比较！ :) For v = 1 to v行为的关键区别在于控制变量和极限变量相同！当第一次迭代发生，然后重新检查极限条件时，循环仅在第一次执行。这使您以前的示例仍然处于边缘情况，很抱歉，目前我没有任何解释！但是，我确实相信强制性的基本规则正在发挥作用-我只是不明白为什么这个实例(显然)是个例外。

我将不得不考虑我的答案。我只是看了一下VBA语言规范，发现了关于循环控件的这个小地方："表达式，和的计算一次，按顺序进行，并且先于任何一个进行。以下计算。"这倾向于解释为什么在循环内更改最终值不会影响迭代次数，但与此相反，这种想法是要重新评估变量作为最终条件的条件(除非偶然重新评估，因为运行时会推入该值-无论是什么(例如变体)-堆栈)。

我必须再次感谢您的努力。我认为我必须在"问题"中添加指向该页面的链接，以便进行进一步的调查。对我来说，很明显，编译器不符合For v = 1 to v语句中的语义。

我们将其视为编译器错误吗？

@灰。欢迎您-享受研究！我认为它至少是运行时的错误。就pcode而言，编译器可能正在做应有的工作，但是循环中变量的运行时评估可能是个问题。无论哪种方式，对我来说，气味都像个虫子。

这似乎是对旧代码库的向后兼容性，因为VBScript表现出相同的古怪行为。我的猜测是，这必须是故意的。

@wqw您是否同意这种行为违反了语义？如果是这样，我不知道有任何理由要这样做。您不能留下错误，因为它最终可以纠正以前的编程错误。补充一点是，这种构造很少使用，预期会由知道他们在做什么的人使用，因此应避免指望这种错误。你怎么看？

是的，显然，即使将VB6代码编译为可执行文件，该漏洞仍然存在。您可以在VBForums中发布线程，并且用户The trick可能可以通过检查(错误地)生成的x86程序集来解释错误之处。

@DavidW您的回答的质量很好，但到目前为止，它没有解决For Each的情况。如果您不介意，我也有兴趣解决这些问题：)

病态尝试，但今天下午时间有限:)

感谢@DavidW的添加。您肯定会因您付出的努力而获得赏金。既然赏金所施加的时间限制已经过去，我们再也没有时间压力了，但是我认为仍然有一些东西可以用来标记答案。我希望您有兴趣将其保留下来。以下是一些评论。

是的，我将在今晚或明天下午尝试更多地解决问题。感谢您的悬赏。

你应得的。请不要在没有时间压力的情况下，只有在您愿意时才这样做。 :)

到目前为止，规范中没有任何关于迭代对象的规则，似乎只有实现可以保护迭代数组，而完全忽略了集合。这种麻烦不是在其自身上迭代变量的结果，而是在任何时候取消引用要迭代的集合而没有在其上保留另一个引用的情况。就像程序员有责任关心引用计数不是BBA / VB6的"精神"一样。

请查看"更新3"以了解更多详细信息。

范围的情况非常简单，即IMO，范围在请求迭代器时派生了一个隐式.cells集合。有时，它会根据范围的定义来分叉行或列的集合。只有剩下的问题确实是案例7，我们只需要"判断"即可。

"在经过几次测试后重新启动例程，然后将代码恢复为原始格式"是什么意思？那是可重现的场景吗？

我只是说我已经修改了一些源代码-将Variant设置为数值(然后将其设置为Collection)(尝试将其设置为Collection)，试图引出一些可能暗示为什么该Variant变为Empty并在没有一次迭代的情况下失败的提示最后一个循环。我已经到达停止和重新启动VBA调试器并没有改变任何事情的程度，但是重新启动Excel并重新打开VBA环境却没有改变。

我什至安装了VBA pcode反汇编程序，但它表明基于对象的行和基于Variant的行解析相同；没有任何迹象表明代码的一般解释因变量与对象而异。 Wed需要在调试器级别(不仅仅是VBA)上查看运行时发生的情况，以真正了解发生了什么。

我确实找到了可重现的东西-当我在VBA调试的"监视"窗口中获取变量时，变量迭代将模仿对象迭代(打印一次)。在"对于v中的每个v"行上有一个断点，我认为Watch会强制对Variant进行评估，以某种方式(也许是额外的拆箱操作)导致对集合进行评估，而不是立即返回Empty并掉进去！可疑多数民众赞成绑在变量持有一个对象多数民众赞成然后集合...

是的，我转载了它。那很好笑。

@ A.S.H我终于能够将监视窗口的行为转换为可在代码中复制的行为。显然，变体评估中存在一个问题。思想ID修改答案以分享。

使用Set vv = v可以为我打印1 2 3 4。我在update1中提到过，我自己的结论是，在集合上保留一个附加的ref可以防止在迭代过程中对其进行垃圾回收，这很重要。在更新4中，我还显示了一个类似的奇怪情况，它甚至没有涉及对其自身进行迭代的变量...该错误现在对我来说很清楚：VB允许GC在迭代集合时销毁它们。它应该为整个循环中存在的隐藏引用提供参考。

无论如何，很遗憾，不允许在公开场合继续此讨论...因此，我们可以在"评论"部分保留该标题，但我很高兴关注您的编辑"无声" :) ..和mods感谢您的宽容到目前为止：D