Lesson 6: Operators

目录：

- 连接操作符
- 运算操作符
- 一元操作符
- 关系操作符
- 条件操作符
- 类型比较操作符

-连接操作符

链接操作符"="是你最常用的操作符之一。使用"="，可以将其右边的值赋给左边的变量。

result = num1 + num2;
days = ["Mon","Tue","Wed","Thu","Fri"];

在前面的章节里面，你已经使用了很多次了。

-运算操作符

运算操作符提供加，减，乘，除的功能。"mod"操作符为求余！

+ (additive operator)
- (subtraction operator)
* (multiplication operator)
/ (division operator)
mod (remainder operator)

下面提供一些例子：

var result = 1 + 2; // result is now 3
println(result);

result = result - 1; // result is now 2
println(result);

result = result * 2; // result is now 4
println(result);

result = result / 2; // result is now 2
println(result);

result = result + 8; // result is now 10
println(result);

result = result mod 7; // result is now 3
println(result);

你还能同时使用运算操作符和连接运算符构成复合运算符。例如 result += 1; 和 result = result+1;两者的效果都是result加上了1.

var result = 0;
result += 1;
println(result); // result is now 1

result -= 1;
println(result); // result is now 0

result = 2;
result *= 5; // result is now 10
println(result);

result /= 2; // result is now 5
println(result);

只有"mod"操作符不能这么写。如果你想求一个数被2除的余数，你需要这么写：

result = result mod 2;

-一元操作符

大部分的操作符需要两个操作数；而一元操作符只需要一个操作数，对操作数进行加/减操作，取负数，如果操作数为boolean，则可以取逻辑反，等操作。

- Unary minus operator; negates a number
++  Increment operator; increments a value by 1
--    Decrement operator; decrements a value by 1
not   Logical complement operator; inverts the value of a boolean

例子：

var result = 1; // result is now 1

result--;  // result is now 0
println(result);

result++; // result is now 1
println(result);

result = -result; // result is now -1
println(result);

var success = false;
println(success); // false
println(not success); // true

++/--操作符既可以在操作数的前面，也可以在操作数的后面。result++和++result运算的最后效果都是result加1。唯一的区别是result++是先取值后加1，++result是先加1再取值。如果你只是做简单的+/-，那么你用哪种方法都没有影响。但是，如果你在一个复杂的表达式里面使用，那么两种方法可能会不同。

下面的代码演示他们的区别：

var result = 3;
result++;
println(result); // result is now 4
++result;
println(result); // result is now 5
println(++result); // result is now 6
println(result++); // this still prints prints 6!
println(result); // but the result is now 7

-关系操作符

关系操作符用来比较一个操作数是否大于，小于，等于或不等于另一个数。

== equal to
!= not equal to
> greater than
>= greater than or equal to
< less than
<= less than or equal to

下面的代码测试这些操作符：

def num1 = 1;
def num2 = 2;

println(num1 == num2); // prints false
println(num1 != num2); // prints true
println(num1 > num2);  // prints false
println(num1 >= num2); // prints false
println(num1 < num2);  // prints true
println(num1 <= num2); // prints true

-条件操作符

条件and和条件or是用在两个boolean表达式间的操作符。这两个操作符有"short-circuiting"的特性，就是第二个操作数只有在需要的时候才执行。举个例子,对于and操作符，如果第一个表达式的执行结果是false，那么第二个表达式就不会执行了，当第一个表达式为true的时候，第二个表达式才会执行。

and
or

下面是例子：

def username = "foo";
def password = "bar";

if ((username == "foo") and (password == "bar")) {
     println("Test 1: username AND password are correct");
}

if ((username == "") and (password == "bar")) {
     println("Test 2: username AND password is correct");
}

if ((username == "foo") or (password == "bar")) {
     println("Test 3: username OR password is correct");
}

if ((username == "") or (password == "bar")) {
     println("Test 4: username OR password is correct");
}

输出：

Test 1: username AND password are correct
Test 3: username OR password is correct
Test 4: username OR password is correct


-类型比较操作符

instanceof操作符判断一个对象是否是一个特定的类型。你可以使用此操作符来判断，一个对象是否是一个特定的类。

def str1="Hello";
println(str1 instanceof String);  // prints true

def num = 1031;
println(num instanceof java.lang.Integer); // prints true

在学了以后的类和继承章节后，你会发现这个操作符很有用。


Lesson 7: Expressions

目录：

- 块表达式
- if表达式
- 范围表达式
- for表达式
- while表达式
- break和continue表达式
- throw, try, catch 和 finally表达式

-块表达式

块表达式包含一系列的声明或表达式，由大括号包围，且以分号隔开。块表达式的值是块里面最后的表达式的值。如果块里面没有表达式，块表达式就是Void类型。注意，var和def是表达式。

下面的块表达式添加了一些成员并把结果存放在total变量里面：

var nums = [5, 7, 3, 9];
var total = {
     var sum = 0;
     for (a in nums) { sum += a };
     sum;
}
println("Total is {total}.");

输出：

Total is 24.

第一行 (var nums = [5, 7, 3, 9];) 声明了一个整型的序列。

接着声明了一个total变量来保存序列里面的值的总和。

块表达式，为大括号里面的所有代码：

{
var sum = 0;
     for (a in nums) { sum += a };
     sum;
}

在括号里面，第一行声明了一个变量sum，来保存序列里面的成员。第二行循环序列，取出序列里的成员与sum相加。最后一行，为返回块表达式的值。


-if表达式

if表达式表达式可以根据特定的条件执行特定的一段代码。

例如，下面的代码根据年龄设置票价。12-65岁票价10元。老人和小孩5元。5岁一下的免费。

def age = 8;
var ticketPrice;

if (age < 5 ) {
     ticketPrice = 0;
} else if (age < 12 or age > 65) {
     ticketPrice = 5;
} else {
     ticketPrice = 10;
}
println("Age: {age} Ticket Price: {ticketPrice} dollars.");

年龄设为8时，输出如下：

Age: 8 Ticket Price: 5 dollars.

程序流程如下：

[b]if (age < 5 ) {
     ticketPrice = 0;
} [/b]else if (age > 5 and age < 12) {
     ticketPrice = 5;
} else {
     ticketPrice = 10;
}

如果年龄小于5，票价为0.那么程序就会跳过其他的判断，直接打印出结果。
如果不小于5，那么程序跳转到第二个判断。


if (age < 5 ) {
     ticketPrice = 0;
} else if (age > 5 and age < 12) {
     ticketPrice = 5;
} else {
     ticketPrice = 10;
}

如果年龄在5-12岁，票价为5.
如果大于或等于12岁，就跳到了else语句里面。

if (age < 5 ) {
     ticketPrice = 0;
} else if (age > 5 and age < 12) {
     ticketPrice = 5;
} else {
     ticketPrice = 10;
}

这个块，只有在前面的条件都不符合的情况下才执行。设置12岁及以上的人的票价为12.

Note: 上面的代码可简写为：

    ticketPrice = if (age < 5) 0 else if (age > 5 and age < 12) 5 else 10;

   
你最好掌握，在后面的章节将会用到。
   

-范围表达式

在序列那一讲，你了解到了如果简单的定义一个有序的数字序列。

var num = [0..5];

理论上，[0..5]就是个范围表达式。默认的，数字间递增1，但是你可以使用step关键字来修改递增的值。例如，定义一个1到10之间的所有奇数的序列。

var nums = [1..10 step 2];
println(nums);

输出

[ 1, 3, 5, 7, 9 ]

要创建一个递减的范围，请保证第二个数要小于第一个数，并且要将step设为一个负数。

var nums = [10..1 step -1];
println(nums);

输出：

[ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]

如果你创建了一个递减的序列，但是没有设定step的值，你将会得到一个空的序列。

下面的代码：

var nums = [10..1 step 1];
println(nums);

将会在编译的时候出现警告：

range.fx:1: warning: empty sequence range literal, probably not what you meant.
var nums = [10..1 step 1];
           ^
1 warning

如果你忽略了警告，那你得到的是个空的序列。

-for表达式

另一个和序列有关的表达式是for表达式。for表达式提供一个简便的循环结构来遍历序列里的所有项。

下面是个例子:

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];

for (day in days) {
     println(day);
}

输出:

Mon
Tue
Wed
Thu
Fri
Sat
Sun

让我们来分析这段代码。for表达式以for开头

[b]for[/b] (day in days) {
     println(day);
}

days变量是序列的名称，for表达式将遍历此序列。

for (day in [b]days[/b]) {
     println(day);
}

day变量依次持有序列里的项

for ([b]day[/b] in days) {
     println(day);
}

注意，day变量并不需要声明就可以在for表达式里面使用了。并且，for表达式结束后，day无法被访问。程序员经常给临时变量一个简短的名字以示区别。

在前面的例子里面，for没有显示的返回值。但是for返回一个序列。下面的两个例子来使用for来从一个序列创建另一个序列。

// Resulting sequence squares the values from the original sequence.
var squares = for (i in [1..10]) i*i; 

// Resulting sequence is ["MON", "TUE", "WED", and so on...]
var capitalDays = for (day in days) day.toUpperCase(); 

注意了，toUpperCase方法由String提供。你能在API里找到完整定义。

-while表达式

另一个循环表达式是while表达式。和for不同，不是遍历序列的，而是根据条件来循环的。while是一个语义(syntactically)上的表达式，为Void类型，没有返回值。

给个例子：

var count = 0;
while (count < 10) {
    println("count == {count}");
    count++;
} 

输出：

count == 0
count == 1
count == 2
count == 3
count == 4
count == 5
count == 6
count == 7
count == 8
count == 9

第一行声明了一个变量count并初始化为０

[b]var count = 0;[/b]
while (count < 10) {
    println("count == {count}");
    count += 1;
} 

接着开始while表达式。表达式循环，知道count为10为止。

var count = 0;
[b]while (count < 10) {[/b]
    println("count == {count}");
    count += 1;
}

循环体中，打印count值，并加１。

var count = 0;
while (count < 10) { 
    [b]println("count == {count}");
    count += 1;[/b]
}

当count为10时，循环结束。如果要创建一个无限循环，条件里改为true关键字，就像这样： while(true){}

-break和continue表达式

break和continue表达式和循环表达式有关。这两个表达式是作用于循环上的：break终止循环，continue跳过当前的循环。

brean和continue是语义(syntactically)表达式。他们为Void类型，没有返回值。

例子：

for (i in [0..10]) {
     if (i > 5) {
          break;
     }

     if (i mod 2 == 0) {
          continue;
     }

     println(i);
}

输出：

1
3
5


如果没有if表达式，程序将会简单的输出：0到10。

如果只有第一个if表达式，程序将在i比5大的时候跳出循环。

if (i > 5) {
     break;
}

程序将只打印1到5。

加上第二个if后，程序会间隔的执行循环。

if (i mod 2 == 0) {
     continue;
}

这里，表达式只有在i为偶数的时候才执行continue。当continue执行的时候，println()将不会被执行，也就不会打印了。


-throw, try, catch 和 finally表达式

在现实世界的应用里面，有时可能会出现不正常的程序流程。例如，一段脚本读取文件，但是文件找不到，那么这段脚本就无法执行了。我们将这种情况称为"异常"。

Note:异常是对象。一般可以从字面意思上知道他们表示的是什么异常。（例如，FileNotFoundException表示了无法找到文件。）但是，下面的例子并不是来展现各种各样的异常的。所以，以普通的异常来说明throw, try, catch, 和 finally
    
下面的脚本定义一个方法并抛出异常：

import java.lang.Exception;

foo();

println("The script is now executing as expected... ");

function foo() {
     var somethingWeird = false;

     if(somethingWeird){
          throw new Exception("Something weird just happened!");
     } else {
          println("We made it through the function.");
     }
}

运行，输出：

We made it through the function.
The script is now executing as expected...

但是，将变量改为true，异常将被抛出。在运行时，脚本将会中断，并打印如下信息：

Exception in thread "main" java.lang.Exception: Something weird just happened!
at exceptions.foo(exceptions.fx:10)
at exceptions.javafx$run$(exceptions.fx:3)

要阻止程序被异常终端，我们需要用try/catch来捕获foo()抛出的异常。由名字来看，这个表达式的作用是，try执行一些代码，但是发生了问题就catch到了一个异常。

try {
     foo();
} catch (e: Exception) {
     println("{e.getMessage()} (but we caught it)");
}

现在，程序打印：

Something weird just happened! (but we caught it)
The script is now executing as expected...

还有个finally块 （这个不能算得上是个表达式），不论是否有异常，finally块里的代码都会被执行。finally块一般是用来做清理工作的。

try {
     foo();
} catch (e: Exception) {
     println("{e.getMessage()} (but we caught it)");
} finally {
     println("We are now in the finally expression...");
}

程序输出：

Something weird just happened! (but we caught it)
We are now in the finally expression...
The script is now executing as expected...