七.编写语句
语句说明程序如何发挥运算作用。本章内容有：1、了解指令和运算；2、赋值；3、算法；4、比较；5、条件；6、运算顺序；7、成组运算。
1、了解指令和运算
指令用运算作用或比较数据。有四种运算类型：
--赋值
--运算
--比较
--条件
大部分运算使用一个值在运算的左边，一个值在右边。如果这两个值的类型不同，如果可能，一个值将被转换为另一个值。
运算在同类间进行。
2、赋值
赋值运算用等号(=)表达。左边的变量将被赋予右边的值：
float $counter = 5.3;
声明一个浮点变量，赋给它一个值5.3。
赋值运算的结果是类型和值赋予等号左边的变量。其结果可被当作同值同类型的常数。
float $owl;
float $hotdog = ($owl = 5.3) + 6;
第而行中浮点$owl被赋值为5.3而$hotdog被赋值为11.3。
赋值链
int $i1, $i2, $i3, $i4;
$i1 = $i2 = $i3 = $i4 = 6; // 所有变量都被赋值为6
3、算法
可以使用以下运算符号进行加、减、乘、比较以及完成变量的其他作用。
符号 意义 数据类型
+ plus int, float, string, vector, matrix
- minus或negation int, float, vector, matrix
* for int, float, matrix
: multiply for vector
: dot product int, float, vector, matrix
/ divided by int, float, vector
% remainder of division int, float, vector
^ cross product vector
矩阵型可以用于取模modulus(%)和除divide?(/)运算。但是右边必须是个整型或浮点作为算子。更多信息看Matrices。
整数和浮点数
对于整型和浮点属性和变量，遵循基本的数学运算规则。取模(%)运算在编程语言中通常有效。
int $card = 7 % 3; // Result: 1
float $bus = 0.5 % 3; // Result: 0.5
字串
对字串可使用+运算，见Strings。
矢量
矢量变量间的运算，算法^计算矢量的叉积，算法*计算点积。对所有其他的运算，一个矢量的每个分量与其他矢量的各个成分进行运算。
vector $Vo = <<3, 9, 5>> + <<9, 2, 3>>; // <<12, 11, 8>>
vector $Vu = <<2, 3, 4>> - <<1, 2, 3>>; // <<1, 1, 1>>
vector $me = <<2, 3, 2>> / <<1, 2, 5>>; // <<2, 1.5, 0.4>>
vector $rf = <<12, 3, 9>> % <<4, 2, 5>>; // <<0, 1, 4>>
点积返回一个浮点。点积常常概念化为两个变量矢量被它们之间角度的余弦所乘之积的长度的积。
vector $V1 = <<4, 6, 8>>;
vector $V2 = <<2, 2, 2>>;
float $F1 = $V1 * $V2; // 36 (点积)
点积运算(*)的结果可用以下方程进行计算：
$F1 = ($V1.x * $V2.x) + ($V1.y * $V2.y) + ($V1.z * $V2.z);
一个矢量与一个整型或一个浮点间的运算把整型或浮点转换为矢量，* 运算是不同的。
*运算的结果是矢量的每个成分被整数或浮点数相乘。
vector $tak = 3.2 * <<1, 3, -5>>; // <<3.2, 9.6, -16>>
vector $sak = <<0, 1.2, 9.1>> * 5; // <<0, 6, 45.5>>
运算^只能运算于矢量类型。它表达了叉积运算，返回一个矢量。
vector $V3 = <<2, 0, 0>>;
vector $V4 = <<0, 3, 0>>;
vector $V5 = $V3 ^ $V4; // <<0, 0, 6>> (叉积)
叉积矢量的方向是法线指向两个变量矢量。该矢量的幅度是两个矢量的长度之积。可用如下方程计算结果：
$V5 = <<(($V3.y * $V4.z) - ($V3.z * $V4.y)),
(($V3.z * $V4.x) - ($V3.x * $V4.z)),
(($V3.x * $V4.y) - ($V3.y * $V4.x))>>;
矩阵
可以在每个矩阵的相应元素之间只进行加或减。矩阵必须具有相同的行数和列数。
matrix $Va[1][4] = <<2, 0, 0, 2>>;
matrix $Vb[1][4] = <<6, 3, 7, 5>>;
matrix $Vc[1][4] = $Va + $Vb; // <<8, 3, 7, 7>>
matrix $Vd[1][4] = $Va - $Vb; // <<-4, -3, -7, -3>>
矩阵相乘时，左矩阵的列数应该等于右矩阵的行数。结果的矩阵具有与左矩阵相同的行数和与右矩阵相同的列数。
matrix $Ve[2][4] = <<4, 1, 1, 2; 3, 4, 5, 8>>;
matrix $Vf[4][3] = <<7, 6, 0; 7, 5, 4; 2, 1, 6; 2, 0, 2>>;
matrix $Vg[2][3] = $Ve * $Vf; // <<41, 30, 14; 75, 43, 62>>
当右边的项是一个标量时，取模和除法算符使用该标量作为右边的项对矩阵的每一个元素进行运算。以下的例子展示出了这一点：
matrix $Vh[1][4] = <<4, 9, 5, 2>> % 3; // <<1, 0, 2, 2>>
matrix $Vi[1][4] = <<1, 2, 8, 4>> / 2; // <<0.5, 1, 4, 2>>
略写
在语句描述中你常常会分配一个变量，它的值与其它一些值进行了运算。略写运算提供了一种简单而又快速的方法。
你可以对int, float和vector数据类型的运算进行略写。
这些算符并没有提供附加的功能或者提高运算速度，但是可以节省你宝贵的输入时间。
例如，可以不写成：
$bus = $bus + 3.5;
而可以写成：
$bus += 3.5;
这两条语句做相同的事情，但是第二条输入的少。对于任何计算符，可以将以下格式： 变量 = 变量 算符 值
写成：
变量 算符= 值
下表示出了这种形式的所有的略写算符、它们的扩展格式和它们的值。
这些算符只对int、float和vector类型定义。但是， += 算符也对string类型定义。
略写格式 扩展格式 值
-------------------------------------------------------------
变量 += 值 变量 = 变量 + 值 变量 + 值
变量 -= 值 变量 = 变量 - 值 变量 - 值
变量 *= 值 变量 = 变量 * 值 变量 * 值
变量 /= 值 变量 = 变量 / 值 变量 / 值
变量 %= 值 变量 = 变量 % 值 变量 % 值
-------------------------------------------------------------
float $mice = 25.3;
$mice -= 6; // $mice = $mice - 6;
$mice %= 4; // $mice = $mice % 4;
$mice /= 3; // $mice = $mice / 3;
vector $kick = <<2, 3, 4>>;
$kick += <<7, 5, 1>>; // $kick = $kick + <<7, 5, 1>>
也有一个 ^= 算符，它仅仅是对vector定义的。该运算计算一个做矢量和右矢量operand的点积。
vector $ice = <<1, 2, 3>>;
$ice ^= <<2, 4, 4>>; // $ice = $ice ^ <<2, 4, 4>>
增量和减量
有一些略写算符可以用于对floats和ints进行加1和减1的运算。下表列出了这些算符、它们的扩展格式以及值。
略写格式 扩展格式 值
-------------------------------------------------------------
变量++ 变量= 变量+ 1 变量
变量-- 变量= 变量- 1 变量
++变量 变量= 变量+ 1 变量+ 1
--变量 变量= 变量- 1 变量- 1
-------------------------------------------------------------
当增量或减量略写算符加到变量前面时，想象该增量或减量发生在该语句执行之前。
但是，当该算符加到了变量的后面，想象该增量或减量发生在该语句被执行之后。
float $eel = 32.3;
float $crab = $eel++; // $crab = 32.3; $eel = 33.3;
$crab = $eel--; // $crab = 33.3; $eel = 32.3;
$crab = --$eel; // $crab = 31.3; $eel = 31.3;
$crab = ++$eel; // $crab = 32.3; $eel = 32.3;
注意：如果有多个增量或减量略写算符作用在同一语句的相同的变量上，则算符的运算顺序是无法预知的。应当避免这种情况。
4、比较
比较运算用于逻辑和关系表达式。
逻辑运算
逻辑的基础是语句是否为真或者假。逻辑算符决定一个语句是真还是假，然后执行相应的语句。
可以将int、float和vector数据类型用于逻辑算符。
每种类型的值对应于真和假。一个 int 或 float 值当它的值转换成整型时是0则被认为是假。
一个矢量的幅度值当它的值转换成整型时是0则被认为是假。转换成所有其它的值则都被认为是真。
下表显示三中逻辑算符的符号和逻辑意义：
符号 逻辑为真，如果：
-------------------------------------------------------------
││ 或 不管左边或者右边为真
&& 和 左边或者右边都为真
! 非 右边为假
-------------------------------------------------------------
if (0 ││ 1) print("true\n"); // True
if (0 && 1) print("true\n"); // False
if (2 && <<3, 7.7, 9>>) print("true\n"); // True
if (! 5.39 && 7) print("true\n"); // False
if (<<0, 0, 0>> ││ 0) print("true\n"); // False
if (! <<0, 0, 0>>) print("true\n"); // True
关系运算
关系运算比较两个值。它们对int, float和vector数据类型是有效的。指令的真值取决于左边对右边值的关系。
下表列出关系运算符和条件：
符号 真，如果右边为：
-------------------------------------------------------------
< 小于右边
> 大于右边
== 等于右边
!= 不等于右边
>= 大于或者等于右边
<= 小于或者等于右边
-------------------------------------------------------------
if (-2.5 < 1) print("true\n"); // True
if (16.2 > 16.2) print("true\n"); // False
if (-11 == -11) print("true\n"); // True
if (-11 != -11) print("true\n"); // False
if (-11 >= -11) print("true\n"); // True
if (1 <= 0) print("true\n"); // False
当一个矢量被进行<, >, > =, or < = 运算，它的幅度被用于代替矢量自己本身。矢量的幅度是浮点类型。
if (<<1, 2, 3>> < <<3, 2, 1>>) print("true"); // False
if (<<1, 2, 3>> <= <<3, 2, 1>>) print("true"); // True
if (<<0, 0, 4>> > <<3, 2, 1>>) print("true"); // True
if (<<0, 5, 0>> <= <<-3, -4, 0>>) print("true"); // True
当用== 或者 != 运算比较两个矢量时，该矢量本身被使用。
如果一个矢量的每一个成分都与另一个矢量的对应成分相等，则这两个矢量相等。
if (<<1, 2, 3>> == <<3, 2, 1>>) print("true"); // False
if (<<1, 2.2, 3>> == <<1, 2.2, 3>>) print("true"); // True
if (<<1.2, 2, 3>> != <<0, 0, 0>>) print("true"); // True
提示：注意赋值算符(=)与等价算符(==)之间的差别。有时候用一个代替另一个产生的错误是很难发现的。
例如，使用赋值算符代替等价算符产生一个值。该值可以被用作为一个逻辑真值或者一个谎言。
将这些算符进行混合并不保险，因为一个变量当它不打算赋于一个值时却可以赋于该值。
作为整数的比较赋值
所有的比较算符产生整数结果。尽管在同一个语句里不常将比较算符与计算相混合，但这种混合是无效的。
事实上，可以使用一个整型变量作为一个逻辑语句的一部分和保存逻辑结果。
int $sra = (4.7 == 4.7) + 5; // Assigned: 6
int $rra = <<1, 2, 3>> >= <<9, 0, 0>>; // Assigned: 0
int $rrr = 0 ││ 72.3; // Assigned: 1
int $sar = 3 * (1.2 && ! <<0, 0, 0>>); // Assigned: 3
if ($rra ││ $rrr) print("true\n"); // True
逻辑算符只使用整型项工作。即使你可以比较真值，但这样做不保险。看以下例子：
int $xsv = 5;
if ($xsv) print("true\n"); // True
if (true) print("true\n"); // True
if ($xsv == true) print("true\n"); // False
变量 $xsv 因为它的值而表达了一个真值，但转换为整型并不为0。但是，有许多为0的整型值。
事实上，关true也表达了一个真值，因为它的值为1 (常数 )。然而，这些真值相互都不相等。
一个整型值为1 ，其它的整型值为5。
由于这个问题，可以不比较真值。即使这些值都是真值，它并不意味着值是相等的，正象上例所显示的那样。
5、条件
条件算符有三项。第一项是一个测试条件，它表达了是真还是假。它后跟一个问号(?)，然后第二项和第三项以冒号(
分开。
如果测试条件为真，使用 ? 后面的项。反之使用 : 后面的。 以下是条件算符的格式：
测试条件 ? 语句1 : 语句2;
float $src = rand(5) < 3 ? 15 : 25;
在上例中，测试条件作为一个整型来运算。如果rand(5)返回了一个小于3的数，$src 被赋值为15；反之 $src 被赋值为25。
Maya只计算语句1或语句2，而不是两者都计算。
int $full = 23;
int $large = 1 < 2 ? ++$full : --$full;
在这个例子中，large 和 full 都被赋值为24。
float $mog = <<0, 0, 0>> ? 8 : 3.3;
因为在上述例子里Maya把8作为一个整型，所以浮点数 3.3 在被赋值给$mog之前先被转换成一个整数。它把3赋值给$mog。
6、运算序列
以下显示出了MEL中运算符优先的顺序。相同行的运算符具有相同的优先级。
如果一条指令有两个以上的相同优先级的运算符，则最左边的运算符是首先进行的。
Unary和赋值运算符是右相关的; 其它所有的都是左相关的。
int $chow = 3 + 5 * 2; // int $chow = (3 + (5 * 2))
float $blu = 5 * ++$chow; // float $blu = (5 * (++$chow))
$blu = 5 && 3 % 2 / 3; // $blu = (5 && ((3 % 2) / 3))
$blu -= $chow += ! 5 < 3; // $blu -= ($chow += ((! 5) < 3))
这些例子显示了运算优先的缺省顺序。要改变运算符优先的顺序，可以使用组运算。
7、成组运算
括号是用于成组运算的，在运算优先结构的顶部。如以下的例子所示，括号对于手动地修改运算符的赋值顺序是有用的。
int $mao = (3 + 5) * 2;
float $fir = (1 + 2) * 5 * ($mao < 20);
$mao /= 2 + ((($fir -= 10) == 5) < 0.5);
八.定义作用
语句的结合形成脚本的作用。
本章有以下内容：1、了解作用和流控制；2、分组；3、条件作用；4、环。
1、了解作用和流控制
为了控制许多语句的执行顺序,使用流控制(flow control)。流控制使你可以有条件地、重复地执行MEL脚本的一节。
使你可以产生一个纯净的和简单的MEL脚本运行复杂的程序。流控制的最基本的成分是分组。
2、分组
使用分组可以：
--用一条简单的语句执行一组语句
--产生脚本的可调节性
--定义局部变量的可见性
典型地，使用分组在只允许执行一条语句的地方执行一组语句。为了不限制一组语句，使用花括号({ })。
例如， if 语句只允许执行一条语句，如果它的条件是真的话。在这条语句之后的任何语句将会被有条件地执行。
为了有条件地执行它们，需要对每一条语句加一个if 语句。这会是很没有效率和使人厌烦。
int $mok = 241;
if ($mok % 3 == 0)
print("It's true!\n");
print("This is always executed\n");
if ($mok % 3 == 0)
print("It's really really true!\n");
把这个语句分成组只允许使用一条语句：
int $sok = 241;
if ($sok % 3 == 0)
{
print("It's true!\n");
print("It's really really true!\n");
}
一个组内的所有语句，即使只有一条，也必须用分号结束。在关闭了一个组之后不需要分号。 对围绕程序体也需要分组：
proc delta()
{
print("Delta is active.\n");
print("Roger that.\n");
}
分组是很少使用的，虽然它对于避免名字冲突和重新覆盖定位于组内的局部变量的存储器是很有用的。
可见性
一个组内的局部变量用在该组执行之后。它在该组已经执行并使得这些变量在组外不可见时，
重新覆盖了定位于这些局部变量之后的存储器。一个组内的局部变量只存在于这个组里。
int $real = 28;
{
float $ghost = 73.3;
print($real + "\n"); // real exists in grouping
print($ghost); // ghost exists in grouping
}
print($real); // real exists outside of grouping
print($ghost); // ERROR: ghost exists only in grouping
一个程序内的局部变量可认为是对该程序是局部的。因此，在一个程序内被声明的局部变量将只在该程序内是可见的。
3、条件作用
条件语句使你仅当该测试条件为真时执行一条语句或一组语句，这个测试条件必须在括号中，
结果值应当是一个整型、浮点或者是一个矢量。该测试条件值随后被转换为一个整型数表达真或假。
如果测试条件有一个int或float类型的值，仅当该值转换成整型后不为0时，该测试条件为真。
if (0) print("true\n"); // False
if (1) print("true\n"); // True
if (-17.4) print("true\n"); // True
if (0.9) print("true\n"); // False
if (-0.7) print("true\n"); // False
如果测试条件有一个矢量类型的值，仅当该矢量的幅值转换成整型时不为0时，该测试条件为真。
if (<<0.9, 0.3, 0.3>>) print("true\n"); // False
if (<<.8, 0.3, 0.7>>) print("true\n"); // True
if (<<0, 0, 0>>) print("true\n"); // False
if (<<0, 4, -37>>) print("true\n"); // True
if (<<0, 1, 0>>) print("true\n"); // True
测试条件可以包括任何的变量和算符(甚至赋值算符)，但是结果值应该是int、 float或者vector类型。
if
if 条件语句有以下格式：
if (test condition)
statement;
如果测试条件为真，语句被执行。
if (9836 % 27 > 13)
print("Wow, that's interesting!\n");
if (3743 % 17 < 8)
{
print("These are...");
print(" useful results.\n");
}
else
else 语句仅与if 条件语句一起工作。它有以下格式：
if (test condition)
statement1;
else
statement2;
如果测试条件为真，执行语句1；否则执行语句2。语句1和语句2可以是任何的有效语句。
if (rand(10) < 5)
print("That was random.\n");
else
print("No it wasn't.\n");
if (rand(2))
print("It takes one to get here\n");
else
{
print("This is just...");
print(" less than one");
}
else if
else if 语句仅与if else 条件语句一起工作。它有以下格式：
if (test condition1)
statement1;
else if (test condition2)
statement2;
如果测试条件为真，执行语句1。否则，如果语句2为真，执行语句2；如果没有真值，就都不执行。
语句1和语句2可以是任何的有效语句。
float $random = rand(2);
if ($random < 1)
print("That was random.\n");
else if ($random < 2)
print("Sure was.\n");
else
print("That's impossible...\n");
在上述的例子中，
--如果随机变量的值小于1，只显示 "That was random.\n" 。
--如果随机变量大于等于1而小于2，只显示 "Sure was.\n" 。
--如果随机变量的值为2，只显示"That's impossible...\n" 。
rand(2) 调用极少返回一个准确为2的值。
float $crow = rand(10);
if ($crow < 5)
print("The crow has landed.\n");
else if ($crow < 7)
{
print("The crow is between five...");
print(" and seven.\n");
}
switch
一个switch语句执行一些语句的片段，取决于控制值。该控制值可以是int、 float、string或者vector数据类型。
switch体被括在括号中与一个或更多的调用情况的语句块相比较。
各个情况被case后跟一个相同类型的作为控制的值加以标号，然后是冒号。
该控制值决定了哪个执行case语句。如果一个case语句值等于控制值，该case 语句就被执行。
switch语句具有以下的总体形式：
switch (control value)
{
case value1:
statement1;
break;
case value2:
statement2;
break;
case value3:
statement3;
break;
...
default:
statement4;
break;
}
在一个case 语句之后，可以有任何语句，包括流控制。为了防止MEL连续地执行下一个case语句，可以使用一个break语句。
在一个switch内，一个break语句使switch语句的其余部分被忽略。
例：break 语句
int $sway = rand(3);
switch ($sway)
{
case 0:
print("Case 0\n"); // Executed only if $sway = 0
break;
case 1:
print("Case 1\n"); // Executed only if $sway = 1
break;
case 2:
while (rand(10) < 7) // These statements
print("I say!\n"); // are executed only
print("Case 2\n"); // if $sway = 2
break;
}
提示：虽然在一个switch语句里的最后的一个case语句不需要一个break语句，因为这是switch的结束，
但加上一个break仍然是个好想法。如果你想要再增加case 给该switch语句，break语句已经在这儿了。
如果你想要该switch继续执行下一个case语句，可以不要break语句。但是，当以后修改这段程序代码时有可能会出现问题。
int $argo = rand(2);
switch ($argo)
{
case 0:
print("Food\n"); // Executed if $argo is 0.
case 1:
print("Fight\n"); // Executed if $argo is 0 or 1.
break;
}
可以用多于一条case语句去执行同一个MEL语句块。如，如果想要使"a"和"A"的控制值都执行一些语句，可以写与以下例子相似的程序：
string $mt = rand(2) < 1 ? "a" : "b";
string $mp = rand(2) < 1 ? "A" : "B";
string $XXz = rand(2) < 1 ? $mt : $mp;
switch ($XXz)
{
case "a":
case "A":
print("Apple\n"); // Executed if "a" or "A"
break;
case "b":
case "B":
print("Banana\n"); // Executed if "b" or "B"
break;
}
在这个例子中，变量$mt可以是"a"或者"b"，变量$mp可以是"A"或者"B"。另外，变量$XXz可以是可变量。这意味着$XXz和控制值可以是"a"、"b"、"A"或"B"。
要说明一个要执行的语句块，即使没有与控制值相匹配的case值，可以使用缺省标号。
该标号可以被定位在switch语句的任何地方，但是它总是出现在所有的case语句的后面。
如果没有缺省标号和没有与控制值相匹配的case值，则该switch语句什么事也不做。
例子：缺省标号
vector $mgb = <<1, 1, 0>>;
switch ($mgb)
{
case <<0, 1, 1>>:
print("Who\n"); // Executed if $mgb is <<0, 1, 1>>
break;
case <<1, 0, 1>>:
print("What\n"); // Executed if $mgb is <<1, 0, 1>>
break;
default:
print("Why\n"); // Executed if $mgb is not
break; // <<0, 1, 1>> or <<1, 0, 1>>
}
在上述例子中，执行了缺省的case，并显示"Why\n"。
4、环
当某个测试条件为真时条件语句执行语句。而当某个测试条件为真时环语句重复地执行语句。
虽然环允许你在写脚本中进行有效的控制，但是它也是产生问题的根源。语句无休止地重复执行的环会永远没有停止。如，执行"while (1);" ，Maya会不停止的执行这一行；不要试做它，除非你准备退出Maya。
本节描述三种主要的环语句：while、do-while和for。也描述了环的中断语句：continue和break。
while
一个while环继续执行一些希望执行的语句，一直到某个条件为真时为止。它有以下格式：
while (test condition)
statement;
如果测试条件为真，Maya便执行该语句。Maya随后再次检测该测试条件。如果测试条件为真，就再次执行该语句。继续这个过程，直到该测试条件为假。这时退出环。
int $files = 5;
while ($files > 2)
print("There are " + $files-- + " files left.\n");
以上的例子程序的输出如下：
There are 5 files left.
There are 4 files left.
There are 3 files left.
上例中当该条件第一次被检测时，files有值5 ，5大于2，产生了一个真条件。 因此，执行显示指令，并将files减量为4。
在这点，测试条件再次由4对files进行判断。测试条件再次为真，因此再执行显示语句，并将files减量为3。然后测试条件再次为真，再执行显示语句，并将files减量为2。这次测试条件为假，因为2不大于2。while语句退出。
当测试条件为真时，如果有多于一行的MEL脚本程序被执行，可以使用分组。
int $t = -10;
while ($t < 0)
{
print("t minus " + (-$t) + " seconds and counting.\n");
$t = $t + 1;
}
print("Houston, we have lift-off!\n");
do-while
一个do-while环非常相似于一个while环，因为两者都执行一些说明的语句，直到某个测试条件为真。但是，do-while环先执行语句，然后检查是否要重复这个环。这就是说该语句至少要执行一次。
一个do-while环有以下格式：
do
statement;
while (test condition);
注意do-while loop必须以分号(;)终止。
do
print("This is randomization kid.\n");
while (rand(2));
在以上的例子中，rand(2)是一个在0与2之间的浮点值。这个数转换成一个整数后为0, 1或者2。1 或 2 的值会使该环重复；0 值则退出该环。每次测试条件被评价时，rand(2)可以返回一个不同的数。因此，测试条件测试条件具有大约50%的机会为真；有大约50%的机会为假。
这里是一个使用分组的类似的一个例子：
do {
print("Here comes the rain again.\n");
print("Raining on my head like a memory.\n");
} while (rand(2));
for
你可能常常希望一个具有初始化设置、测试和条件语句的改变的环控制。为此可以使用for环。for环有以下格式：
for (initializer; test condition; change of condition)
statement;
初始化只被执行一次，在for环被执行之前。初始化是一条语句，它一般使用于把一个值标注给测试条件中的一个变量。可以使用初始化执行任何语句或者也可以完全地不进行初始化。但是，它不能被用于声明一个变量。
for环在执行语句之前判断测试条件。for环的这一部分完全象while环。事实上，一个for环正是一个具有初始化和条件语句改变的while环。但是，如果缺少了测试条件，测试条件则总是被假定为真，在一个while环中会产生一个错误。当测试条件为真时，该语句被执行；一旦被判断为假，就退出该环。
在环的每一次反复中执行的条件语句的改变可以加在环的最后。典型地，条件语句的改变用于改变一些环控制变量，虽然你可以对任何语句使用它或者完全不用它。
int $Index;
for ($Index = 0; $Index < 2; $Index++)
print("Give me a beat!\n");
for ($Index = 0; $Index < 3;)
{
print("Can I get some?\n");
$Index = $Index + 1;
}
for (; $Index--;)
print("Give me all your lovin'.\n");
for (;;)
if (rand(5))
print("Forever yours.\n");
else
break;
这些例子显示出了当使用for环时一些不同的可能性。在最后的for环中，if else语句被认为是一条单语句。
虽然初始化不能用于声明一个变量，但它可以被用于隐含声明一个变量。
for ($xxx = 0; $xxx < 3; $xxx++)
print("Hit me three times.\n");
for环也允许你使用多个初始化或者多个增量器。为此，用逗号(,)把各个初始化和条件语句的改变分离开。
int $nx1, $nx2;
for ($nx1 = 0, $nx2 = 10; $nx1 < $nx2; $nx1++, $nx2--)
print("nx1 = " + $nx1 + ", nx2 = " + $nx2 + "\n");
float $cg = 25.3;
for (; $cg < 93.8; $nx1--, $nx2 = rand(11), $cg *= 1.7)
{
print("nx1 = " + $nx1 + ", nx2 = " + $nx2 + "\n");
print( "CG levels currently at " + $cg + "\n\n");
}
for-in
for-in环是for环的一个引申。它专门工作在阵列中。你可能常常想隐含地通过一个阵列的所有元素。当一个for环需要一个索引变量、初始化、测试条件和增量器时，for-in环只需要一个元素变量。for-in环有以下格式：
for (element in array)
statement;
例子： for-in 环
string $car;
string $cars[3] = {"n NSX", " Porsche", "n Acura"};
for ($car in $cars)
print("I have a" + $car + ".\n");
结果是：
I have an NSX.
I have a Porsche.
I have an Acura.
例子： for loop
int $carIndex;
string $cars[3] = {"n NSX", " Porsche", "n Acura"};
for ($carIndex = 0; $carIndex < size($cars); $carIndex++)
print("I have a" + $cars&carIndex; + ".\n");
以上的for环都是等价的，但是for-in环需要的输入较少些。
vector $coordinates[2] = {<<1, 2, 3>>, <<4, 3, 7>>};
for ($coordinate in $coordinates)
{
print("Coordinate: " + $coordinate + ".\n");
print("You sank my battleship!\n");
}
continue
continue语句都出现在环内。它聚焦在要发生的环的下一次反复，跳过该环的所有其余的语句。
例子：
float $fox = 5;
for ($fox = 0; $fox < 5; $fox++)
{
print("$fox equals: " + $fox + "\n");
if ($fox > 2)
continue;
print(" Got here\n");
}
输出是：
$fox equals: 0
Got here
$fox equals: 1
Got here
$fox equals: 2
Got here
$fox equals: 3
$fox equals: 4
没有if语句，在该$fox quals: 3 和 $fox equals: 4行之后环也输出Got here。Maya忽略了continue语句直到$fox增加到一个大于2的值。当$fox 成为3 或更大时，continue语句执行并跳过环中其余的语句，显示出got here。
break
break语句立即退出一个环。可以使用一个break语句在所有的环之内。
float $free = 0;
while ($free < 10)
{
print("$free equals: " + $free + "\n");
if ($free++ == 3)
break;
}
print("I'm free!");
输出是：
$free equals: 0
$free equals: 1
$free equals: 2
$free equals: 3
I'm free!
没有if语句，该环会执行10次，并显示数字0到9。在$free等于3之后，break语句终止了这个环，所以环中的显示语句只执行4次。
