Call 语句

将控制权传递给 Sub 或 Function 过程。

Call 语法格式如下：

[Call] 过程名 [参数]

参数

参数	描述
Call	可选关键字。如果指定此关键字，则必须用括号把 argumentlist 括起来。例如：Call MyProc(0)
过程名	必选。要调用的过程名。
参数	可选。传递给过程的变量、数组或表达式列表，用逗号分隔每一项。

说明

  在调用过程时，不必使用 Call 关键字。然而，如果使用 Call 关键字调用要求参数的过程，则必须用括号将 参数 括起来。如果省略 Call 关键字，那么必须也同时省略参数两边的括号。使用 Call 语法调用内部函数或使用用户自定义函数，函数返回值都会被放弃。

示例

Call MyFunction("Hello World")
Function MyFunction(text)
   MsgBox text
End Function

Class 语句

声明一个类的名称，以及组成该类的变量、属性和方法的定义。

Class...End Class 语法格式如下：

Class 类名
  语句
End Class

参数

参数	描述
类名	必选项。Class 的名称；遵照标准的变量命名约定。
语句	必选项。一个或多个语句，定义了 Class 的变量、属性和方法。

说明

  在 Class 块中，成员通过相应的声明语句被声明为 或 Public。被声明为 的将只在 Class 块内是可见的。被声明为 Public 不仅在 Class 块的内部是可见的，对 Class 块之外的代码也是可见的。没有使用 或 Public 明确声明的被默认为 Public。 在类的块内部被声明为 Public 的过程 (Sub 或 Function)将成为类的方法。Public 变量将成为类的属性，同使用 Property Get、Property Let 和 Property Set 显式声明的属性一样。 类的缺省属性和方法是在它们的声明部分用 Default 关键字指定的。关于如何使用该关键字，请参考单独的声明语句主题。

Const 语句

声明用于代替文字值的常数。

Const 语法格式如下：

[Public | Private] Const 常量名 = 值

参数	描述
Public	可选项。该关键字用于在 Script 级中声明可用于所有脚本中所有过程的常数。不允许在过程中使用。
	可选项。该关键字用于在脚本级中声明只可用在声明所在的脚本中的常数。不允许在过程中使用。
常量名	必选项。常数的名称，根据标准的变量命名约定。
值	必选项。文字或其他常数，或包括除 Is 外的所有算术运算符和逻辑运算符的任意组合。

说明

• 在默认情况下常数是公用的。过程中的常数总是专有的，其可见性无法改变。Script 中，可用 关键字来改变脚本级常数可见性的默认值。
• 要在同一行中声明若干个常数，可用逗号将每个常数赋值分开。用这种方法声明常数时，如果使用了 Public 或 关键字，则该关键字对该行中所有常数都有效。
• 常数声明中不能使用变量、用户自定义的函数或 VBScript 内部函数（如 Chr)。按定义，它们不能是常数。另外也不能从含有运算符的表达式中创建常数，即只允许使用简单常数。在 Sub 或 Function 过程中声明的常数是该过程的局部常数。在过程外声明的常数是声明所在的脚本中的全局常数。可以在任何使用表达式的地方使用常数。

示例

下面代码举例说明如何使用 Const 语句:

Const MyVar = 459               ' 常数默认为 公有。
Const MyString = "HELP"         ' 定义私有常数。
Const MyStr = "Hello", MyNumber  = 3.4567   '在一行上定义多个常数。 

注意:常数能使脚本自己支持并且容易修改。不像变量，脚本在运行时，常数不能被无意中修改。

Dim 语句

声明变量并分配存储空间。

Dim 语法格式如下：

Dim 变量1[([维数])] [, 变量2[([维数])]] . . .

参数	描述
变量	变量的名称，符合标准变量命名约定。
维数	数组变量的维数，最多可以声明 60 维的数组。subscripts 参数使用以下语法：   upperbound [,upperbound] . . .  数组下界总是 0。

说明

• 用 Dim 声明的 Script 级变量可用于脚本中的所有过程，过程级变量只能用于过程中。

• 也可用带空圆括号的 Dim 语句来声明动态数组。声明动态数组后，可在过程内使用 ReDim 语句来定义该数组的维数和元素。如果试图重新定义在 Dim 语句中已经显式指定维数的数组，则会发生错误。

注意 在过程中使用 Dim 语句时，通常将 Dim 语句放在过程的开始处。

示例

下面例子举例说明如何使用 Dim 语句:

Dim Names(9)     '声明一个具有 10 个元素的数组。
Dim Names()      ' 声明动态数组。
Dim MyVar, MyNum ' 声明两个变量。

Do...Loop 语句

当条件为 True 时或条件变为 True 之前重复执行某语句块。

Do...Loop 语法格式如下：

Do [{While | Until} 条件]
 [循环体1]
 [Exit Do]
 [循环体2]
Loop

也可以使用下面的语法：

Do
 [循环体1]
 [Exit Do]
 [循环体2]
Loop [{While | Until} 条件]

参数	描述
条件	数值或字符串表达式，其值为 True 或 False。如果 condition 为 Null，则 condition 被当作 False。
循环体	当 条件为 True 时被重复执行的一条或多条命令。

说明

• Exit Do 仅可以用在 Do...Loop 控制语句中，提供另一种退出 Do...Loop 的方法。可以在 Do...Loop 语句中的任何位置放置任意个 Exit Do。Exit Do 通常与条件判断语句（如 If...Then ）一起使用，将控制传递给紧随在 Loop 语句后面的语句。

• 当用于嵌套 Do...Loop 中的时候，Exit Do 将控制传递给其所在循环的上一层嵌套循环。

示例

下面例子举例说明如何使用 Do...Loop 语句:

可以使用 Do...Loop 语句多次（次数不定）运行语句块。当条件为 True 时或条件变为 True 之前，重复执行语句块。

While关键字用于 Do...Loop 语句

• 有两种方式检查条件：在进入循环之前检查条件
• 在循环至少运行完一次之后检查条件.

'在进入循环之前检查条件
Sub ChkFirstWhile()
   Dim counter, myNum
   counter = 0
   myNum = 20             '如果 myNum 的初始值被设置为9,而不是20.则永远不会执行循环体中的语句.
   Do While myNum > 10
      myNum = myNum - 1
      counter = counter + 1
   Loop
   MsgBox "循环重复了 " & counter & " 次。"
End Sub

'循环至少运行完一次之后检查条件
Sub ChkLastWhile()
   Dim counter, myNum
   counter = 0
   myNum = 9

'循环体中的语句只会执行一次，因为条件在检查时已经为 False
   Do
      myNum = myNum - 1
      counter = counter + 1
   Loop While myNum > 10
   MsgBox "循环重复了 " & counter & " 次。"
End Sub

Dim Check, Counter
Check = True: Counter = 0      ' 初始化变量。
Do            ' 外层循环。
  Do While Counter < 20      ' 内层循环。
    Counter = Counter + 1      ' 增加计数器。
    If Counter = 10 Then      ' 如果条件为 True...
      Check = False         ' 将标志值设置为 False。
      Exit Do         ' 终止内层循环。
    End If
  Loop
Loop Until Check = False      ' 立即终止外层循环。

Until 关键字用于检查 Do...Loop 语句

• 有两种方式检查条件：在进入循环之前检查条件
• 在循环至少运行完一次之后检查条件. 有两种方式检查条件：

'在进入循环之前检查条件
Do Until DefResp = vbNo
  MyNum = Int (6 * Rnd + 1)      '  产生 1 到 6 之间的随机数。
  DefResp = MsgBox (MyNum & " 想要另一个数吗？", vbYesNo)
Loop

'在循环至少运行完一次之后检查条件。只要条件为 False，就会进行循环。
Sub ChkFirstUntil()
   Dim counter, myNum
   counter = 0
   myNum = 20
   Do Until myNum = 10
      myNum = myNum - 1
      counter = counter + 1
   Loop
   MsgBox "循环重复了 " & counter & " 次。"
End Sub

Sub ChkLastUntil()
   Dim counter, myNum
   counter = 0
   myNum = 1
   Do
      myNum = myNum + 1
      counter = counter + 1
   Loop Until myNum = 10
   MsgBox "循环重复了 " & counter & " 次。"
End Sub

退出循环

Exit Do语句用于退出 Do...Loop循环。因为通常只是在某些特殊情况下要退出循环（例如要避免死循环），所以可在 If...Then...Else 语句的 True 语句块中使用 Exit Do 语句。如果条件为False，循环将照常运行。

在下面的示例中，myNum 的初始值将导致死循环。If...Then...Else 语句检查此条件，防止出现死循环。

Sub ExitExample()
   Dim counter, myNum
      counter = 0
      myNum = 9
      Do Until myNum = 10
         myNum = myNum - 1
         counter = counter + 1
         If myNum < 10 Then Exit Do
      Loop
      MsgBox "循环重复了 " & counter & " 次。"
End Sub

Erase 语句

重新初始化固定大小数组的元素，并释放动态数组的存储空间。

Dim 语法格式如下：

Erase array

判断数组是固定长度数组（常规）还是动态数组是很重要的，这是因为 Erase 要根据数组的类型进行不同的操作。Erase 无需为固定大小的数组还原内存。Erase 按照下表设置固定数组的元素：

参数	描述
array	参数是要清除的数组变量的名称。Erase 按照下表设置固定数组的元素：  固定数值数组: 将每个元素设置为 0。  固定字符串数组:将每个元素设置为零长度字符串 ("")。   对象数组,将每个元素设置为特殊值 Nothing。

说明

Erase 释放动态数组所使用的内存。在程序再次引用该动态数组之前，必须使用 ReDim 语句来重新定义该数组变量的维数。

示例

下面例子举例说明如何使用 Erase 语句。

Dim NumArray(9)     
Dim DynamicArray()
ReDim DynamicArray(9)  '分配存储空间。
Erase NumArray         ' 每一元素都被重新初始化。
Erase DynamicArray     '释放数组占用的内存。

Execute 语句

执行一个或多个指定的语句。

Dim 语法格式如下：

Execute statements

参数

参数	描述
statements	是一个字符串表达式，其中包含一个或多个要执行的语句。 如果要在 statements 参数中包含多条语句，应使用分号或嵌入的分行将其分隔开。

说明

• 在 VBScript 中，x = y 可以有两种解释。首先是作为赋值语句，将 y 的值赋予 x。其次是作为表达式，测试x 和 y 的值是否相等。如果相等，结果为 True；否则，结果为 False。Execute 语句总是使用第一种解释，而 Eval 方法总是使用第二种。

注意 在 Microsoft(R) Visual Basic Scripting Edition 中并不存在赋值与比较之间的混淆，因为赋值运算符(=)与比较运算符(==)是不同的。

• 调用 Execute 语句的上下文确定了要运行的代码可以使用的对象和变量。作用域内的对象和变量是 Execute 语句中运行的代码可以使用的。不过，必须明白的一点是，如果被执行的代码创建了过程，那么该过程将不会继承它所在的过程的作用域。

• 与其他过程类似，新的过程的作用域是全局的，它继承了全局作用域的全部东西。与其他过程不同的是，它的上下文不是全局作用域，因此它只能在发生 Execute 语句的过程内的上下文中执行。不过，如果相同的 Execute 语句是在过程之外(例如在全局作用域)的作用域中被调用，那么它将不仅继承全局作用域中的所有东西，而且它还可以在任何地方被调用，因为它的上下文是全局的。 下面的例子说明了这种特点：

示例

Dim X            ' 在全局作用域中声明 X。
X = "Global"         ' 将全局的 X 赋值。
Sub Proc1            ' 声明过程。
  Dim X            ' 在局部作用域中声明 X。
  X = "Local"         ' 对局部的 X 赋值。
            ' 此处的 Execute 语句建立了一个过程，
            ' 在调用该过程时它将打印 X。
            ' 它打印的将是全局 X，因为 Proc2
            ' 继承了全局作用域中的一切。
  Execute "Sub Proc2: Print X: End Sub"
  Print Eval("X")      ' 打印本地 X。
  Proc2            ' 在 Proc1 的作用域中调用 Proc2。
End Sub
Proc2            ' 本行将导致一个错误，因为
            ' Proc2 在 Proc1 之外是不可使用的。
Proc1            ' 调用 Proc1。
  Execute "Sub Proc2: Print X: End Sub"
Proc2            ' 这句话可以成功，因为 Proc2
            ' 现在是全局可用的。

'下面的例子显示了如何将 Execute 语句改写，免于将整个过程包含在引号内：
S = "Sub Proc2" & vbCrLf
S = S & "  Print X" & vbCrLf 
S = S & "End Sub"
Execute S

ExecuteGlobal 语句

执行一个功多个在脚本全局名字空间中指定的语句。

Dim 语法格式如下：

ExecuteGlobal statement

statement 参数是一个包含一个或多个可执行语句的字符串表达式 。在statement 参数中可以包含多条语句, 使用冒号将其分开。

说明

• 在 VBScript 中, x = y 有两种解释方法。第一种方法是作为一条赋值语句, 将 y 的值赋给 x。第二种方法是作为一个表达式 ，用于测试 x 和 y 是否具有相同的值。如果它们相等,则结果为 True; 如果他们不相等,其结果为 False.ExecuteGlobal 语句总是使用第一种方法,而 Eval 方法总是使用第二种方法。

注意 在 Microsoft? Visual Basic Scripting Edition?中, 赋值与比较之间不存在混消，因为赋值运算符(=) 不同于比较运算符。

• 在脚本的全局名字空间中，ExecuteGlobal 中的所有语句都有是可执行的。因此，允许您将代码添加到程序中，以便于任何 过程 能够对其进行访问。例如,一个 VBScript Class 语句在运行时可以执行。随之函数创造此类的一个新实例。

• 在运行时添加过程和类是非常有用的,但是也可能导致在运行时覆盖已有的全局 变量 和函数。因为这可能导致非常严重的程序问题,因此，当使用 ExecuteGlobal 语句时一定得非常谨慎。如果您无需访问过程之外的变量或函数,最好使用Execute 语句，因为它只影响主调函数的名字空间。

下面的例子解释了 ExecuteGlobal 语句的用法。

Dim X         ' 声明 X 为全局变量。
X = "Global"      ' 给全局变量 X 赋值。
Sub Proc1   ' 声明过程。
  Dim X      ' 在局部变量中声明 X。
  X = "Local"   ' 给局部变量 X 赋值。
         ' 此处的可执行语句
         ' 创建一个过程, 当被调用时, 打印 X。
         ' 此处将打印全局变量 X 的值，因为 Proc2
         ' 继承了全局变量中的一切。
  ExecuteGlobal "Sub Proc2: 打印 X: End Sub"
  Print Eval("X")   ' 打印局部 X。
  Proc2      ' 在全局作用区域中调用 Proc2 
         ' 将打印 "Global" 。
End Sub
Proc2         ' 此行将导致错误 
         ' 因为 Proc2 在 Proc1 之外是不可用的。
Proc1         ' 调用 Proc1。
  Execute "Sub Proc2: 打印 X: End Sub"
Proc2         ' 此行调用成功，因为 Proc2
         ' 在全局作用区域中是可用的。

'下面的例子演示了 ExecuteGlobal 语句可以被重写，因此您无需将下面的整个过程都包括在引用标记之内。
S = "Sub Proc2" & vbCrLf
S = S & "  Print X" & vbCrLf 
S = S & "End Sub"
ExecuteGlobal S

Exit 语句

退出 Do...Loop、For...Next、Function 或 Sub 代码块。

Exit 语法格式如下：

Exit Do
Exit For
Exit Function
Exit Property
Exit Sub

Exit 语句的语法有以下几种形式：

语句	描述
Exit Do	提供一种退出 Do...Loop 语句的方法。只能在 Do...Loop 语句中使用。Exit Do 将控制权转移到 Loop 语句之后的语句。在嵌套的 Do...Loop 语句中使用时，Exit Do 将控制权转移到循环所在位置的上一层嵌套循环。
Exit For	提供一种退出 For 循环的方法。只能在 For...Next 或 For Each...Next 循环中使用。Exit For 将控制权转移到 Next 之后的语句。在嵌套的 For 循环中使用时，Exit For 将控制权转移到循环所在位置的上一层嵌套循环。
Exit Function	立即从出现的位置退出 Function 过程。继续执行调用 Function 的语句后面的语句。
Exit Property	立即从所在的 Property 过程中退出。继续执行下面调用 Property 过程的语句。
Exit Sub	立即从出现的位置退出 Sub 过程，继续执行调用 Sub 的语句后面的语句。

下面例子举例说明如何使用 Exit 语句:

Sub RandomLoop
  Dim I, MyNum
  Do                           ' 设置死循环。
    For I = 1 To 1000          ' 循环 1000 次。
      MyNum = Int(Rnd * 100)   '产生随机数。
      Select Case MyNum        '求随机数的值。
        Case 17: MsgBox "Case 17"
          Exit For             ' 如果是 17，退出 For...Next。
        Case 29: MsgBox "Case 29"
          Exit Do              ' 如果是 29，退出 Do...Loop。
        Case 54: MsgBox "Case 54"
          Exit Sub             ' 如果是 54，退出 Sub 过程。
        End Select
    Next
  Loop
End Sub

For Each...Next 语句

对数组或集合中的每个元素重复执行一组语句。

For Each...Next 语法格式如下：

For Each 数组或集合的元素 In 数组或集合
 [循环体]
 [Exit For]
 [循环体]
Next [数组或集合中元素]

参数	描述
数组或集合的元素	用来枚举集合或数组中所有元素的变量。对于集合，element 可能是 Variant 变量、通用 Object 变量或任意指定的 Automation 对象变量。对于数组，element 只能是 Variant 变量。
数组或集合	对象集合或数组的名称。
循环体	对于 group 中的每一项执行的一条或多条语句。

说明

• 如果 集合或数组 中有至少一个元素，就会进入 For Each 块执行。一旦进入循环，便首先对 集合或数组 中第一个元素执行循环中的所有语句。只要 集合或数组 中还有其他的元素，就会对每个元素执行循环中的语句。当 集合或数组 中的没有其他元素时退出循环，然后从 Next 语句之后的语句继续执行。

• Exit For 只能用于 For Each...Next 或 For...Next 控制结构中，提供另一种退出循环的方法。可在循环的任意位置放置任意个 Exit For 语句。Exit For 经常和条件判断语句一起使用（例如 If...Then），并立即将控制权转移到 Next 之后的语句。

• 可以将一个 For Each...Next 循环放置在另一个之中，组成嵌套式 For Each...Next 循环。但是每个循环的 数组或集合的元素 必须是唯一的。

注意

如果省略 Next 语句中的 数组或集合的元素，则程序仍会象已包含它一样继续执行。如果 Next 语句在其相应的 For 语句之前出现，则会产生错误。

下面例子举例说明如何使用 For Each...Next 语句:

Function ShowFolderList(folderspec)
  Dim fso, f, f1, fc, s
  Set fso = CreateObject("Scripting.FileSystemObject")
  Set f = fso.GetFolder(folderspec)
  Set fc = f.Files
  For Each f1 in fc
    s = s & f1.name 
    s = s & "<BR>"
  Next
  ShowFolderList = s
End Function

For...Next 语句

用于将语句块运行指定的次数。在循环中使用计数器变量，该变量的值随每一次循环增加或减少。

For...Next 语法格式如下：

For counter = start To end [Step step]
 [statements]
 [Exit For]
 [statements]
Next

参数

参数	描述
counter	用做循环计数器的数值变量。这个变量不能是数组元素或用户自定义类型的元素。
start	counter 的初值。
end	counter 的终值。
step	counter 的步长。如果没有指定，则 step 的默认值为 1。 step 参数可以是正数或负数。step 参数值决定循环的执行情况 step=正数或 0时，counter <= end step=负数,counter >= end
statements	For 和 Next 之间的一条或多条语句，将被执行指定次数。

说明

• 当循环启动并且所有循环中的语句都执行后，step 值被加到 counter 中。这时，或者循环中的语句再次执行（基于循环开始执行时同样的测试），或者退出循环并从 Next 语句之后的语句继续执行。

注意

在循环体内改变 counter 的值，将会使程序代码的阅读和调试变得更加困难。

• Exit For 只能用于 For Each...Next 或 For...Next 结构中，提供另一种退出循环的方法。可在语句中的任意位置放置任意个Exit For 语句。Exit For 经常和条件判断语句一起使用（例如 If...Then），并立即将控制权转移到 Next 之后的语句。

• 可以将一个 For...Next 循环放置在另一个 For...Next 循环中，组成嵌套循环。每个循环中的 counter 要使用不同的变量名。下面的结构是正确的：

For I = 1 To 10
    For J = 1 To 10
        For K = 1 To 10
        . . .
        Next
    Next
Next

示例

例如，下面的示例将过程 MyProc 重复执行 50 次。For 语句指定计数器变量 x 及其起始值与终止值。Next 语句使计数器变量每次加 1。

Sub DoMyProc50Times()
   Dim x
   For x = 1 To 50
      MyProc
   Next
End Sub

关键字 Step 用于指定计数器变量每次增加或减少的值。在下面的示例中，计数器变量 j 每次加 2。循环结束后，total 的值为 2、4、6、8 和 10 的总和。

Sub TwosTotal()
  Dim j, total
  For j = 2 To 10 Step 2
    total = total + j
  Next
  MsgBox "总和为 " & total & "。"
End Sub

要使计数器变量递减，可将 Step 设为负值。此时计数器变量的终止值必须小于起始值。在下面的示例中，计数器变量 myNum 每次减 2。循环结束后，total 的值为 16、14、12、10、8、6、4 和 2 的总和。

Sub NewTotal()
   Dim myNum, total
   For myNum = 16 To 2 Step -2
      total = total + myNum
   Next
   MsgBox "总和为 " & total & "。"
End Sub

Exit For 语句用于在计数器达到其终止值之前退出 For...Next 语句。因为通常只是在某些特殊情况下（例如在发生错误时）要退出循环，所以可以在 If...Then...Else 语句的 True 语句块中使用 Exit For 语句。如果条件为 False，循环将照常运行。

Function 语句

声明 Function 过程的名称、参数以及构成其主体的代码。

Function 语法格式如下：

[Public [Default]| Private] Function name [(arglist)]
 [statements]
 [name = expression]
 [Exit Function]
 [statements]
 [name = expression]
Next

参数

参数	描述
Public	表示 Function 过程可被所有脚本中的所有其他过程访问。
Default	只与 Class 块中的 Public 关键字一起使用 来表示 Function 过程是类的默认方法。如果在一个类中指定了不止一个 Default 过程，就有错误发生。
	表示 Function 过程只可被声明它的脚本中的其他过程访问或者如果函数是一个数据类，那么 Function 过程只能被该类中的其他过程访问。
name	Function 的名称，遵循标准的变量命名约定。
arglist	代表调用时要传递给 Function 过程的参数的变量列表。用逗号隔开多个变量。
statements	在 Function 过程的主体中执行的任意语句组。
expression	Function 的返回值。
arglist	参数包含下列语法和部分： [ByVal | ByRef] varname[( )]   ByVal=表示该参数是按值方式传递的。  ByRef=表示该参数按引用方式传递。  varname 代表参数变量的名称；遵循标准的变量命名约定。

说明

• 如没有显式指定使用 Public或 Private，则 Function 过程默认为公用，即它们对于脚本中的所有其他过程是可见的。Function 中局部变量的值在对 过程的调用中不被保留。

• 不能在任何其他过程（例如，Sub 或 Property Get）中定义 Function 过程。

• 使用 Exit Function 语句可以从 Function 过程中立即退出。程序继续执行调用 Function 过程的语句之后的语句。可在 Function 过程的任何位置出现任意个 Exit Function 语句。

• 与 Sub 过程类似，Function 过程是可以获取参数、执行一系列语句并改变其参数值的独立过程。与 Sub 过程的不同之处是：当要使用由函数返回的值时，可以在 表达式的右边使用 Function 过程，这与内部函数的使用方式一样，例如 Sqr、Cos 或 Chr。

• 在表达式中，可以通过使用函数名，并在其后用圆括号给出相应的参数列表来调用 Function 过程。有关调用 Function 过程的详细信息，请参阅 Call 语句。

• 小心 Function 过程可以是递归的，即该过程可以调用自身以完成某个给定的任务。但是，递归可能会导致堆栈溢出。

• 要从函数返回一个值，只需将值赋给函数名。在过程的任意位置都可以出现任意个这样的赋值。如果没有给 name 赋值, 则过程将返回一个默认值：数值函数返回 0，字符串函数返回零长度字符串 ("")。如果在 Function 中没有对象引用被指定给 name（使用 Set），则返回对象引用的函数将返回 Nothing。

下面的样例说明如何给一个名为 BinarySearch 的函数赋返回值。在此样例中，将 False 赋给了该函数名，表示没有找到某个值。

Function BinarySearch(. . .)
    . . .
    ' 未找到该值。返回 False 值。
    If lower > upper Then
        BinarySearch = False  
        Exit Function 
    End If
    . . .
End Function

在 Function 过程中使用的变量分为两类：一类是在过程内显式声明的，另一类则不是。在过程内显式声明的变量（使用 Dim 或等效方法）总是过程的局部变量。被使用但没有在过程中显式声明的变量也是局部变量，除非在该过程外更高级别的位置显式声明它们。

小心 Function 过程可以是递归的，即该过程可以调用自身以完成某个给定的任务。但是，递归可能会导致堆栈溢出。

小心 VBScript 可能会重新排列数学表达式以提高内部效率。当 Function 过程修改数学表达式中变量的值时，应避免在同一表达式中使用该函数。

If...Then...Else 语句

根据表达式的值有条件地执行一组语句。

If...Then...Else 语法格式如下：

If condition Then  statements [Else elsestatements ]

或者
If condition Then
 [statements]
[ElseIf condition-n Then
 [elseifstatements]]...
[ Else
 [elsestatements]]
End If

参数

参数	描述
condition	一个或多个数值或字符串表达式，其运算结果是 True 或 False。如果 condition 是 Null，则 condition 被视为 False。形如 TypeOf objectname Is objecttype 的表达式。objectname 是任何对象的引用，而 objecttype 则是任何有效的对象类型。如果 objectname 是 objecttype 所指定的一种对象类型，则表达式为 True；否则为 False。
Statements	如果 condition 为 True 时，执行的一条或多条（以冒号分开）语句。
condition-n	同 condition。
elseifstatements	如果相关的 condition-n 为 True时，执行的一条或多条语句。
elsestatements	如果前面没有 condition 或 condition-n 表达式为 True 时，执行的一条或多条语句。

说明

对于短小简单的测试，可以使用单行形式（第一种语法）。但块形式（第二种语法）提供了比单行形式更强的结构化与适应性，比较容易阅读、维护及调试。

• 在单行语法中，可以执行多条语句作为 If...Then 判断的结果，但所有语句必须在同一行上并且以冒号分开，如下列语句所示： 不推荐

If A > 10 Then A = A + 1 : B = B + A : C = C + B

• 当程序运行到 If 块（第二种语法）时，将判断 condition。如果 condition 是 True，则执行 Then 之后的语句。如 condition 是 False，则每个 ElseIf 部分的条件式（如果有的话）会依次计算并加以测试。当找到某个为 True 的条件时，则其相关的 Then 之后的语句会被执行。如没有一个 ElseIf 语句是 True（或没有 ElseIf 子句），则将执行 Else 之后的语句。执行 Then 或 Else 之后的语句以后，将继续执行 End If 之后的语句。

• Else 和 ElseIf 子句都是可选项的。在 If 块中可以放置任意多个 ElseIf 子句，但是都必须在 Else 子句之前。If 块语句可以被嵌套，即被包含在另一个 If 块语句之中。

• 要判断某个语句是否是一个 If 块，可检查 Then 关键字之后是什么。如果在 Then 的同一行之后还有其他非注释的内容，则此语句就是单行形式的 If 语句。

• If 块语句必须是某一行的第一条语句，并且必须以 End If 语句结束。

示例

使用 If...Then...Else 进行判断

If...Then...Else 语句用于计算条件是否为 True 或 False，并且根据计算结果指定要运行的语句。通常，条件是使用比较运算符对值或变量进行比较的表达式。有关比较运算符的详细信息，请参阅比较运算符。If...Then...Else 语句可以按照需要进行嵌套。

条件为 True 时运行语句

要在条件为 True 时运行单行语句，可使用 If...Then...Else 语句的单行语法。下例示范了单行语法。请注意此例省略了关键字 Else。

Sub FixDate()
    Dim myDate
    myDate = #2/13/95#
    If myDate < Now Then myDate = Now
End Sub

要运行多行代码，必须使用多行（或块）语法。多行（或块）语法包含 End If 语句，如下所示：

Sub AlertUser(value)
   If value = 0 Then
      AlertLabel.ForeColor = vbRed
      AlertLabel.Font.Bold = True
      AlertLabel.Font.Italic = True
   End If
End Sub

条件为 True 和 False 时分别运行某些语句

可以使用 If...Then...Else 语句定义两个可执行语句块：条件为 True 时运行某一语句块，条件为 False 时运行另一语句块。

Sub AlertUser(value)
   If value = 0 Then
      AlertLabel.ForeColor = vbRed
      AlertLabel.Font.Bold = True
      AlertLabel.Font.Italic = True
   Else
      AlertLabel.Forecolor = vbBlack
      AlertLabel.Font.Bold = False
      AlertLabel.Font.Italic = False
   End If
End Sub

对多个条件进行判断

If...Then...Else 语句的一种变形允许您从多个条件中选择，即添加 ElseIf 子句以扩充 If...Then...Else 语句的功能，使您可以控制基于多种可能的程序流程。例如：

Sub ReportValue(value)
  If value = 0 Then
    MsgBox value
  ElseIf value = 1 Then
    MsgBox value
  ElseIf value = 2 then
    Msgbox value
  Else
    Msgbox "数值超出范围！"
  End If
End Sub

可以添加任意多个 ElseIf 子句以提供多种选择。使用多个 ElseIf 子句经常会变得很累赘。在多个条件中进行选择的更好方法是使用 Select Case 语句。

On Error 语句

启用或禁用错误处理程序。

On Error 语法格式如下：

On Error Resume Next
On Error GoTo 0

On Error Resume Next On Error GoTo 0

说明

• 如果在您的代码中未使用 On Error Resume Next 语句, 所发生的运行时错误 将显示错误信息，同时，代码的执行也随之终止。但是具体操作由运行代码的主机决定。主机有时可有选择地处理各类错误。在有些情况下，它可以在出错的地方激活脚本调试器。而在另一些情况下, 由于主机无法通知用户，因此对所发生的错误没有明确说明。至于如何处理错误则完全取决于主机的功能。

• 在任意一个特殊过程中，只要在调用堆栈的地方启用错误处理程序，所发生的错误一般不会是致命性的。如果在一个过程中没有启用局部错误处理程序，当发生错误时，控制可通过堆栈调用转移，直到找到一个具有错误处理程序的过程，并在出错的地方处理错误。如果在调用堆栈的过程中没有找到错误处理程序，则在出错的地方显示错误信息，同时终止代码执行，或者通过主机来正确处理错误。

• On Error Resume Next 会使程序按照产生错误的语句之后的语句继续执行，或是按照最近一次所调用的过程（该过程含有 On Error Resume Next 语句）中的语句继续运行。这个语句可以不顾运行时错误，继续执行程序，之后您可以在过程内部建立错误处理例程。在调用另一个过程时，On Error Resume Next 语句变为非活动的。所以，如果希望在例程中进行内部错误处理，则应在每一个调用的例程中执行 On Error Resume Next 语句。

• 当调用另一过程时，禁止使用On Error Resume Next 语句，因此如果您想在例程中嵌入错误处理程序，则需要在每次调用例程时都应执行 On Error Resume Next 语句。当退出一个过程时，错误处理程序可恢复到它在进入所退出过程之前的状态。

• 如果您已启用 On Error Resume Next 错误处理程序，则可使用 On Error GoTo 0禁用错误处理程序。

下面例子举例说明如何使用 On Error Resume Next 语句:

On Error Resume Next
Err.Raise 6  '产生溢出错误。
MsgBox ("Error # " & CStr(Err.Number) & " " & Err.Description)
Err.Clear    '清除错误。

Option Explicit 语句

强制要求显式声明脚本中的所有变量。

Option Explicit 语法格式如下：

Option Explicit

说明

• 如果使用 Option Explicit，该语句必须出现在脚本的任何其他语句之前。
• 使用 Option Explicit 语句时，必须使用 Dim、Private、Public 或 ReDim 语句显式声明所有变量。如果试图使用未经声明的变量名，则会出现错误。
• 提示 可用 Option Explicit 避免拼错已存在的变量名称。对于作用范围不清楚的变量，使用此语句可避免发生混淆。

下面例子举例说明如何使用 Option Explicit 语句:

Option Explicit    ' 强制显示声明变量。
Dim MyVar          '声明变量。
MyInt = 10         '未声明变量产生错误。
MyVar = 10         '声明变量不产生错误。

语句

定义私有变量并分配存储空间。在 Class块中定义私有变量。

语法格式如下：

varname[([subscripts])][， varname[([subscripts])]] . . .

varname[([subscripts])][， varname[([subscripts])]] . . .

参数	描述
varname	变量的名称；遵循标准变量命名约定。
subscripts	数组变量的维数，最多可以声明 60 维的数组。subscripts 参数使用下列语法： upper [, upper] . . . 数组的下界总是 0

说明

• 语句变量只能在声明该变量的脚本中使用。

• 在使用引用对象的变量之前，必须用 Set 语句将某个现有对象赋予此变量。在赋值之前，所声明的对象变量被初始化Empty。

• 也可用带空圆括号的 语句声明动态数组。声明动态数组后，可在过程内使用 ReDim 语句定义该数组的维数和元素。如果在 Private、Public 或 Dim 语句中已显式指定数组大小，却试图重新声明数组维数，就会发生错误。

注意 在过程中使用 语句时，通常将 语句放在过程的开始处。

• 下面例子举例说明如何使用 语句:

MyNumber   ' Variant variable.
MyArray(9)   ' array variable.
   ' Multiple declarations of Variant variables.
MyNumber, MyVar, YourNumber

Property Get 语句

在 Class 块中，声明构成用来取得（返回）的值的属性过程的主体的名称、参数和代码。

Property Get 语法格式如下：

[Public [Default]| Private] Property Get name [(arglist)]
  [statements]
 [[Set] name = expression]
 [Exit Property]
 [[Set] name = expression]
End Property

[Public [Default]| Private] Property Get name [(arglist)] [statements] [[Set] name = expression] [Exit Property] [statements] [[Set] name = expression] End Property

参数	描述
Public	表明Property Get 过程可以被所有脚本中的其他过程访问。
Default	只与 Public 关键字一起使用，表明 Property Get 过程中定义的属性为类的缺省属性。
	表明 Property Get 过程只对定义它的 Class 块中的其他过程是可以访问的。
name	Property Get 过程的名称；遵守标准的变量命名规则，区别仅仅在于它可以与同一Class块中的Property Let 或 Property Set过程。
arglist	该变量列表代表了 Property Get 过程被调用时传递给它的参数。多个参数之间用逗号分隔开。Property Get 过程中的每个参数的名称必须与 Property Let 过程中的相应参数相同(如果有的话)。
statements	任意的一组语句，将在 Property Get 过程的主体中执行。
Set	在将对象作为 Property Get 过程的返回值时使用的关键字。
expression	Property Get 过程的返回值。

说明

• 如果未使用 Public 或 Private明确声明，则 Property Get 过程被缺省为公有的，即它们对于脚本中的其他所有过程都是可见的。Property Get过程中的局部变量的值在不同的过程调用之间是不保存的。

• 在其他任何过程(例如 Function 或 Property Let) 内部都不能定义 Property Get 过程。

• Exit Property 语句将导致立即从 Property Get 过程中退出。程序将继续执行调用 Property Get 过程的语句之后的程序。Exit Property 语句可以出现在 Property Get 过程中的任何位置，次数不限。

• 与Sub 和 Property Let 过程类似，Property Get 过程是能够接受参数的过程，可以执行一系列的语句，以及改变参数的值。然而，与Sub 和 Property Let 不同的是，Property Get 过程可以被用于表达式的右侧，用与使用Function 或属性名称相同的方式来返回属性的值。

Property Let 语句

在 Class 块中，声明名称、参数和代码等，它们构成了赋值（设置）的 Property 过程的主体。

Property Let 语法格式如下：

[Public | Private] Property Let name [(arglist) ,] value)
 [statements]
 [Exit Property]
 [statement]
End Property

[Public | Private] Property Let name ( [arglist,] value ) [statement] [Exit Property] [statement] End Property

参数

参数	描述
Public	表明 Property Let 过程可以被所有脚本中的其他所有过程访问。
	表明 Property Let 过程只能被定义之的 Class 块内的其他过程访问。
Property Let	过程的名称；遵守标准的变量命名规则，区别仅仅在于其名称可以与相同 Class 块中的 Property Get 或 Property Set 过程相同。
arglist	该变量列表代表了在调用时被传递到 Property Let 过程的参数。多个参数之间用逗号隔开。Property Let 过程的每个参数的名字必须与 Property Get 过程中的相应参数相同。此外， Property Let 过程的参数比相应的 Property Get 过程总要多一个。该参数为被赋予属性的值。
value	该变量中包含要赋予属性的值。当过程被调用时，该参数将出现在调用表达式的右侧。
statement	任意的一组语句，将在 Property Let 过程的主体内执行。

注意每个 Property Let 语句必须为所定义的属性定义至少一个参数。该参数（在存在多个参数时的最后一个参数）包含了当 Property Let 语句被调用时要赋予属性的值。该参数在前面的语法中被称为value。

说明

• 如果未明确地使用 Public 或 Private进行指定，Property Let 过程被缺省设置为公有的，即它们对于脚本内的其他所有过程都是可见的。Property Let过程中的局部变量的值在不同的过程调用之间是不被保存的。

• 在其他任何过程（例如 Function 或 Property Get）的内部不能够定义 Property Let 过程。

• Exit Property 语句将导致立即从 Property Let 过程中退出。程序将从调用 Property Let 过程的语句之后的点继续执行。Exit Property 语句可以出现在 Property Let 过程中的任何位置，次数不限。

• 与 Function 和 Property Get 过程类似，Property Let 过程是一个单独的过程，它可以接受参数，执行一系列的语句，还可以改变参数的值。不过，与Function 和 Property Get 过程不同的是，它们两者都返回一个值，而Property Let过程只能用于属性赋值表达式的左侧。

Property Set 语句

在 Class 块中，声明名称、参数和代码，这些构成了将引用设置到对象的 Property 过程的主体。

Property Set 语法格式如下：

[Public | Private] Property Set name [(arglist) ,] reference)
 [statements]
 [Exit Property]]
 [Exit Property]
 [statement]
End Property

[Public | Private] Property Set name([arglist,] reference) [statement] [Exit Property] [statement] End Property

参数

参数	描述
Public	表明 Property Set 过程可以被所有脚本中的其他所有过程访问。
	表明 Property Set 过程只能被声明之的同一 Class 块中的其他过程访问。
name	Property Set 过程的名称；遵守标准的变量命名规则，不过该名称可以与同一个 Class 块中的 Property Get 或 Property Let 过程相同。

| arglist | 变量列表，代表在 Property Set 过程被调用时传递给它的参数。多个参数之间用逗号分隔开。此外，Property Set 过程将总是比它相应的 Property Get 过程多一个参数。这个多出来的参数是被赋予的对象。| | reference | 变量，其中包含被用于对象引用赋值的右侧的对象引用。| | statement | 将要在 Property Set 过程主体中执行的任何一组语句。|

注意每个 Property Set 语句都必须为所定义的过程定义至少一个参数。当 Property Set 语句所定义的过程被调用时，该必需参数（在多个参数时为最后一个参数）中将为属性提供实际的对象引用。在前面的语法中，该参数被称为引用。

说明

• 除非使用 Public 或 明确地进行指定，否则 Property Set 过程被设置为缺省的公有模式，即脚本中的其他所有过程都是可见的。在不同的过程调用时，Property Set 过程中的局部变量是不保存的。

• 在其他任何过程（例如Function或Property Let）中都不能够定义Property Set过程。

• Exit Property 语句将导致立即从 Property Set 过程中退出。程序将继续执行调用 Property Set 过程之后的语句。Exit Property 语句的数量不受限制，可以出现在 Property Set 过程中的任何位置。

• 与 Function 和 Property Get 过程类似，Property Set 过程是一个单独的过程，它可以有若干参数，执行一系列的语句，还可以改变参数的值。然而，与 Function 和 Property Get 过程不同的是，函数和过程都可以返回值，而 Property Set 过程对象引用赋值（Set 语句）的左侧。

Public 语句

定义公有变量并分配存储空间。在 Class 块中定义私有变量。

Public 语法格式如下：

varname[([subscripts])][, varname[([subscripts])]] . . .

参数	描述
varname	变量的名称，遵循标准变量命名约定。
subscripts	数组变量的维数；最多可以声明 60 维的数组。 subscripts 参数使用下列语法： upper [,upper] . . . 数组的下界总是 0。

说明

• Public语句变量可用于全部脚本中的所有过程。

• 在使用引用对象的变量之前，必须用 Set 语句将某个已有对象赋予该变量。在赋值之前，所声明的对象变量被初始化为 Empty。

• 也可用带空圆括号的 Public 语句来声明动态数组。声明动态数组后，可在过程内使用 ReDim 语句来定义该数组的维数和元素。如果试图重新声明数组变量的维数，且此数组变量的大小已在 Private、Public 或 Dim 语句中显式地指定，则会发生错误。

示例

下面例子举例说明如何使用 Public 语句:

Public MyNumber   ' Public Variant variable.
Public MyArray(9)   ' Public array variable.
   ' Multiple Public declarations of Variant variables.
Public MyNumber, MyVar, YourNumber

Randomize 语句

初始化随机数生成器。

Randomize 语法格式如下：

Randomize [ number]

参数	描述
number	可以是任何有效的数值表达式。

说明

• Randomize 使用 number 参数初始化 Rnd 函数的随机数生成器，赋给它新的种子值。如果省略 number，则使用系统计时器返回的值作为新的种子值。

• 如果不使用 Randomize，则第一次调用 Rnd 函数（无参数）时，它将使用相同的数字作为种子值，随后使用最后生成的数值作为种子值。

注意 要重复随机数的序列，请在使用数值参数调用 Randomize 之前，立即用负值参数调用 Rnd。使用相同的 number 值的 Randomize 不能重复先前的随机数序列。

下面例子举例说明如何使用 Randomize 语句:

Dim MyValue, Response
Randomize '初始化随机数生成器。
Do Until Response = vbNo
   MyValue = Int((6 * Rnd) + 1)' 产生 1 到 6 之间的随机数。
   MsgBox MyValue
   Response = MsgBox ("Roll again? ", vbYesNo)
Loop

ReDim 语句

在过程级中声明动态数组变量并分配或重新分配存储空间。 ReDim 语法格式如下：

ReDim [Preserve] varname(subscripts) [, varname(subscripts)] . . .

参数	描述
Preserve	当更改现有数组最后一维的大小时保留数据。
varname	变量名，遵循标准变量命名约定。
subscripts	数组变量的维数，最多可以声明 60 维数组。subscripts 参数语法格式如下： upper [,upper] . . . 数组的下界总是零。

说明

• ReDim 语句通常用于指定或修改动态数组的大小，这些数组已用带有空括号的 Private、Public 或 Dim 语句（没有维数下标）正式声明过。可以重复使用 ReDim 语句更改数组维数和元素数目。

• 如果使用了 Preserve 关键字，就只能调整数组最后维的大小，并且不能改变数组的维数。例如，如果数组只有一维，就可以修改该数组的大小，因为该维是最后的也是仅有的一维。但是，如果数组有两个或更多维，就只能改变末维的大小并保留数组内容。

这个例子说明如何不擦掉该数组中存在的数据，而增加动态数组的终止维数。

ReDim X(10, 10, 10)
. . .
ReDim Preserve X(10, 10, 15)

小心 如果减小数组的大小，则将丢失被排除的元素中的数据。

变量初始化时，数值变量初始化为 0，字符串变量初始化为零长度字符串 ("")。在使用引用对象的变量前，必须使用 Set 语句将某个现有对象赋予该变量。在进行对象赋值以前，已声明的对象变量有特定值 Nothing。

Rem 语句

包含程序中的解释性注释。

Rem comment

Rem 语法格式如下：

Rem comment
或者
  comment

参数	描述
comment	需要包含的注释文本。在 Rem 关键字和 comment 之间应有一个空格。

说明

• 正如“语法”部分所示，可以用单引号 (') 代替 Rem 关键字。如果 Rem 关键字和语句在同一行，需要用分号来分隔它们。但如果使用单引号，则不需要在单引号和语句之间使用分号。

下面例子举例说明如何使用 Rem 语句:

Dim MyStr1, MyStr2
MyStr1 = "Hello" : Rem 语句和注释用冒号隔开。
MyStr2 = "Goodbye"     ' 这同样是注释不需要冒号。
Rem 在没有代码的行上加注释不必用冒号。

Select Case 语句

根据表达式的值执行几组语句之一。

Select Case 语法格式如下：

Select Case testexpression
 Case expressionlist-n
  [statements-n]. . .
 Case Else expressionlist-n
  [elsestatements-n]. . .
End Select

参数	描述
testexpression	任意数值或字符串表达式。
expressionlist-n	如 Case 出现则必选项。一个或多个表达式的分界列表。
statements-n	当 testexpression 与 expressionlist-n 中的任意部分匹配时，执行的一条或多条语句。
elsestatements-n	当 testexpression 与 Case 子句的任何部分不匹配时，执行的一条或多条语句。

说明

使用 Select Case 进行判断 Select Case 结构提供了 If...Then...ElseIf 结构的一个变通形式，可以从多个语句块中选择执行其中的一个。Select Case 语句提供的功能与 If...Then...Else 语句类似，但是可以使代码更加简练易读。

Select Case 结构在其开始处使用一个只计算一次的简单测试表达式。表达式的结果将与结构中每个 Case 的值比较。如果匹配，则执行与该 Case 关联的语句块,示例代码如下： 下面例子举例说明如何使用 Select Case 语句:

Select Case Document.Form1.CardType.Options(SelectedIndex).Text
   Case "MasterCard"
      DisplayMCLogo
      ValidateMCAccount
   Case "Visa"
      DisplayVisaLogo
      ValidateVisaAccount
   Case "American Express"
      DisplayAMEXCOLogo
      ValidateAMEXCOAccount
   Case Else
      DisplayUnknownImage
      PromptAgain
End Select

请注意 Select Case 结构只计算开始处的一个表达式（只计算一次），而 If...Then...ElseIf 结构计算每个 ElseIf 语句的表达式，这些表达式可以各不相同。仅当每个 ElseIf 语句计算的表达式都相同时，才可以使用 Select Case 结构代替 If...Then...ElseIf 结构。

Dim Color, MyVar
Sub ChangeBackground (Color)
   MyVar = lcase (Color)
      Select Case MyVar
           Case "red"    document.bgColor = "red"
           Case "green"  document.bgColor = "green"
           Case "blue"   document.bgColor = "blue"
           Case Else     MsgBox "选择另一种颜色"
      End Select
End Sub

Set 语句

将对象引用赋给一个variable或property，或者将对象引用与事件关联。

Rem 语法格式如下：

Set objectvar ={objectexpression | New classname | Nothing}
或者
Set object.eventname=GetRef(procname)

参数	描述
objectvar	必选项，变量或属性名称;符合标准变量命名约定。
objectexpression	可选项，与对象名称一致的Expression,另一个相同object type、函数或方法的已声明变量，它们返回相同对象类型的对象。
New	用于创建一个类的新实例的Keyword。如果 objectvar 包含一个对某个对象的引用，当一个新的引用被赋给这个对象之后，则这个引用将被释放。New 关键仅用于创建一个class的实例。
classname	可选项. 创建的类名称。使用 Class 语句定义类及其语句。
Nothing	可选项。断开 objectvar 与任何指定对象或类的关联。当没有其他变量引用前面的引用对象时，将 objectvar 赋值为 Nothing 以释放与前面的引用对象相关联的系统或内存资源。
object	必选项。与 event 相关联的对象名称。
event	必选项。函数作用域的事件名称。
procname	必选项。包含与event 相关联的 Sub 或 Function 名称的字符串。

说明

• 为了使其有效，objectvar 必须与赋值的对象类型相一致。

• Dim, Private, Public, 或 ReDim 语句仅声明一个引用对象的变量。在使用. Set 语句为一个具体对象赋值之前，没有实际对象可以引用。

• 通常, 当您使用 Set 语句将一个对象引用赋给一个变量之前,不会创建那个变量的对象的副本。实际上,只创建了一个对象的引用。多个引用对象变量可以引用相同的对象。因为这些变量都是对象的引用，而不是对对象副本的引用，因此对象中所作的任何变化都可以在引用该对象的所有变量中反映出来。

Function ShowFreeSpace(drvPath)
   Dim fso, d, s
   Set fso = CreateObject("Scripting.FileSystemObject")
   Set d = fso.GetDrive(fso.GetDriveName(drvPath))
   s = "Drive " & UCase(drvPath) & " - " 
   s = s & d.VolumeName  & "<BR>"
   s = s & "Free Space: " & FormatNumber(d.FreeSpace/1024, 0) 
   s = s & " Kbytes"
   ShowFreeSpace = s
End Function

利用 New 关键词，您可以随时创建一个类的实例，并将一个对象引用变量赋值给它。赋给类的实例的变量一定利用 Dim (或相似的语句)语句事先已经声明。

有关使用 Set 语句关联一个过程与对象的详细信息，请参考 GetRef 函数的文档。

Sub 语句

声明 Sub 过程的名称、参数以及构成其主体的代码。 Sub 语法格式如下：

[Public [Default]| Private] Sub name [(arglist)]
 [statements]
 [Exit Sub]
 [statements]
End Sub

[Public [Default]| Private] Sub name [( arglist )] [statements] [Exit Sub] [statements] End Sub

参数	描述
Public	表示 Sub 过程可被所有脚本中的所有其他过程访问。
Default	只与 类块中的Public 关键字连用，用来表示 Sub 过程是类的默认方法。 如果在类中指定了不止一个Default过程，就会出错。
	表示 Sub 过程只可被声明该过程的脚本中的其他过程访问。
name	Sub 的名称，遵循标准变量命名约定。
arglist	代表在调用时要传递给 Sub 过程的参数的变量列表。用逗号隔开多个变量。
statements	在 Sub 过程主体内所执行的任何语句组。
arglist	参数包含下列语法和部分： [ByVal

说明

• 如没有显式地指定使用 Public 或 Private，则 Sub 过程默认为公用，即它们对于脚本中的所有其他过程都是可见的。Sub 过程中局部变量的值在调用过程中不被保留。

• 不能在任何其他过程（例如，Function 或 Property Get）中定义 Sub 过程。

• 使用 Exit Sub 语句可以立即从 Sub 过程中退出。程序继续执行调用 Sub 过程的语句之后的语句。可以在 Sub 过程中任意位置出现任意个 Exit Sub 语句。

• 与 Function 过程相似之处是：Sub 过程是一个可以获取参数，执行一系列语句以及可改变其参数的值的独立过程。而与 Function 过程不同之处是：Function 过程可以返回值，而 Sub 过程不能用于表达式中。

• 可以使用过程名并跟随相应的参数列表来调用 Sub 过程。关于如何调用 Sub 过程的详细说明信息，请参阅 Call 语句。

• 小心 Sub 过程可以是递归的，即该过程可以调用自己来完成某个给定的任务。但是递归可能会导致堆栈溢出。

• 在 Sub 过程中使用的变量分为两类：一类是在过程内显式声明的，另一类则不是。在过程内显式声明的变量（使用 Dim 或等效方法）总是局部变量。对于那些没有在过程中显式声明的变量也是局部的，除非在该过程外更高级别的位置显式地声明它们。

• 小心 过程可以使用没有在过程内显式声明的变量，但只要有任何 script 级定义的名称与之同名，就会产生名称冲突。如果过程中引用的未声明的变量与其他的过程、常数或变量的名称相同，则会认为过程引用的是脚本级的名称。要避免这类冲突，请使用 Option Explicit 语句可强制显式声明变量。

While...Wend 语句

当指定的条件为 True 时，执行一系列的语句。 While...Wend 语法格式如下：

While condition
 [statements]
Wend

While condition &nbsp； Version [statements] Wend

参数	描述
condition	数值或字符串表达式，其计算结果为 True 或 False。如果 condition 为 Null，则 condition 被当作 False。
statements	在条件为 True 时执行的一条或多条语句。

说明

• 如果 condition 为 True，则 statements 中所有 Wend 语句之前的语句都将被执行，然后控制权将返回到 While 语句，并且重新检查 condition。如果 condition 仍为 True，则重复执行上面的过程。如果不为 True，则从 Wend 语句之后的语句继续执行程序。

• While...Wend 循环可以是多层嵌套结构。每个 Wend 与最近的 While 语句对应。

注意 Do...Loop 语句提供一种结构化与适应性更强的方法以执行循环。

示例

下面例子举例说明如何使用 While...Wend 语句:

Dim Counter
Counter = 0                '初始化变量。
While Counter < 20         ' 测试计数器的值。
   Counter = Counter + 1   ' 增加计数器。
   Alert Counter
Wend                       ' 计数器大于 19 时终止循环。

使用 While...Wend While...Wend 语句是为那些熟悉其用法的用户提供的。但是由于 While...Wend 缺少灵活性，所以建议最好使用 Do...Loop 语句。

With 语句

对一个对象执行一系列的语句。

With 语法格式如下：

With object
 statements
End With

参数	描述
object	必需的部分。可以是一个对象名称，也可以是返回值为对象的一个函数。
statements	必需的部分。将要对 object 执行的一个或多个命令。

说明

• With 语句可以用来对指定的对象执行一系列的语句，但不需要重复地说明对象的名称。例如，如果要修改一个对象的多个属性，可以将所有属性赋值语句放在 With 控制结构中，这样对对象的引用就只需要一次，而不是在每个赋值语句中都引用。下面的例子说明如何使用 With 语句对同一个对象的几个属性进行赋值。

With MyLabel
  .Height = 2000
  .Width = 2000
  .Caption = "这是MyLabel"
End With

尽管属性操作是使用 With 语句最多的情况，它的用法并不仅限于此。With 块中可以使用任何合法的语句。

注意 一旦进入了 With 块，object是不可改变的。因此，不能使用一个With语句去改变若干对象的值。

可以嵌套使用 With 语句，将一个 With 块写在另一个块中。然而，由于外部的 With 块的成员被内部的 With 块掩盖，无论内部的 With 块要引用外部的 With 块中的某个对象的什么成员，都必须使用完全限定的对象引用。

重点 不要跳入或跳出 With 块。如果执行了 With 块中的语句却没有执行 With 或 End With 语句，结果将引发错误或其他难以预见的行为。