Scala的第一步

　　

第一步：学习使用Scala解释器

开始Scala最简单的方法是使用Scala解释器，它是一个编写Scala表达式和程序的交互式“shell”。在使用Scala之前需要安装Scala，可以参考 First Steps to Scala 内容。

你可以在命令提示符里输入scala使用它：

$ scala Welcome to Scala version 2.9.2.

Type in expressions to have them evaluated.

Type :help for more information.

scala>

在你输入表达式，如1 + 2，并敲了回车之后：

scala> 1 + 2

解释器会打印：

res0: Int = 3

这行包括：

 一个自动产生的或用户定义的名称说明计算的值（res0，表示结果0），
 一个冒号（:），跟着表达式的类型（Int），

 一个等号（=），
 计算表达式所得到的结果（3）。

Int类型指代了scala包的类Int。Scala里的包与Java里的包很相似：它们把全局命名空间分区并提供了信息隐藏的机制。类Int的值对应着Java的int值。
第二步：定义一些变量类Int的值对应着Java的int值。更广泛意义上来说，所有的Java原始类型在scala包里都有对应的类。例如，scala.Boolean对应着Java的boolean。

scala.Float对应着Java的float。当你把你的Scala代码编译成Java字节码，Scala编译器将使用Java的原始类型以便获得其带来的性能益处。 resX识别符还将用在后续的代码行中。例如，既然res0已在之前设为3，res0 * 3就是9：

scala> res0 * 3
res1: Int = 9

打印必要的，却不仅此而已的，Hello, world! ，输入：

scala> println("Hello, world!")
Hello, world!

println函数在标准输出上打印传给它的字串，就跟Java里的System.out.println一样。

第二步：定义一些变量

Scala有两种变量，val和var。val类似于Java里的final变量。一旦初始化了，val就不能再赋值了。与之对应的，var如同Java里面的非final变量。var可以在它生命周期中被多次赋值。下面是一个val的定义：

 

scala> val msg = "Hello, world!" 
msg: java.lang.String = Hello, world!

 

这个语句引入了msg当作字串"Hello, world!"的名字。类型是java.lang.String，因为Scala的字串是由Java的String类实现。

 

因为Scala具有自动理解你省略的类型的能力，即 类型推断：type inference。Scala解释器（或编译器）可以推断类型。不过，如果你愿意，也可以显式地定义类型，也许有些时候你也应该这么做。显式的类型标注不但可以确保Scala编译器推断你倾向的类型，还可以作为将来代码读者有用的文档。与之不同的是，Scala里变量的类型在其名称之后，用冒号分隔。如：

scala> val msg2: java.lang.String = "Hello again, world!" 
msg2: java.lang.String = Hello again, world!

因为在Scala程序里java.lang类型的简化名也是可见的，所以可以简化为：

scala> val msg3: String = "Hello yet again, world!" 
msg3: String = Hello yet again, world!

回到原来的那个msg，现在它定义好了，你可以按你的想法使用它，如：

scala> println(msg) 
Hello, world!

你对msg不能做的，就是再给它赋值，因为是val而不是var。尝试给msg赋新值会报错：

scala> msg = "Goodbye cruel world!" 
<console>:5: error: reassignment to val
 msg = "Goodbye cruel world!"

如果需要可重复赋值的变量，则必须使用var来定义。如：

scala> var greeting = "Hello, world!" 
greeting: java.lang.String = Hello, world!
scala> greeting = "Leave me alone, world!" 
greeting: java.lang.String = Leave me alone, world!

要输入一些能跨越多行的东西，只要一行行输进去就行。如果输到行尾还没结束，解释器将在下一行回应一个竖线。

scala> val multiLine = | "This is the next line." 
multiLine: java.lang.String = This is the next line.

如果你意识到你输入了一些错误的东西，而解释器仍在等着你更多的输入，你可以通过按两次回车取消掉：

scala> val oops = 
 |
 | 
You typed two blank lines. Starting a new command.
 scala>

第三步：定义一些函数

 现在你已经用过了Scala的变量，或许想写点儿函数。下面是在Scala里面的做法：

scala> def max(x: Int, y: Int): Int = if (x < y) y else x
max: (Int,Int)Int

函数的定义用def开始。函数名，本例中是max，跟着是括号里带有冒号分隔的参数列表。每个函数参数后面必须带前缀冒号的类型标注，因为Scala编译器没办法推断函数参数类型，在max参数列表的括号之后你会看到另一个“: Int”类型标注。这个东西定义了max函数的结果类型：result type跟在函数结果类型之后的是一个等号和一对包含了函数体的大括号。

在函数体前的等号提示我们函数式编程的世界观里，函数定义一个能产生值的表达式。函数的基本结构在下图里面演示：

                                   

　　　　　　　　　　　　　　　　　　　　Scala函数的基本构成

 有时候Scala编译器会需要你定义函数的结果类型。比方说，如果函数是递归的你就必须显式地定义函数结果类型。然而在max的例子里，你可以不用写结果类型，编译器也能够推断它。同样，如果函数仅由一个句子组成，你可以可选地不写大括号。这样，你就可以把max函数写成这样：

scala> def max2(x: Int, y: Int) = if (x > y) x else y
max2: (Int,Int)Int

一旦你定义了函数，你就可以用它的名字调用它，如：

scala> max(3, 5) 
res6: Int = 5

还有既不带参数也不返回有用结果的函数定义：

scala> def greet() = println("Hello, world!")
greet: ()Unit

当你定义了greet()函数，解释器会回应一个greet: ()Unit。“greet”当然是函数名。空白的括号说明函数不带参数。Unit是greet的结果类型。Unit的结果类型指的是函数没有返回有用的值。Scala的Unit类型比较接近Java的void类型，而且实际上Java里每一个返回void的方法都被映射为Scala里返回Unit的方法。因此结果类型为Unit的方法，仅仅是为了它们的副作用而运行

下一步，你将把Scala代码放在一个文件中并作为脚本执行它。如果你想离开解释器，输入:quit或者:q。

scala> :quit 
$

第四步：编写一些Scala脚本

尽管Scala的设计目的是帮助程序员建造非常大规模的系统，但它也能很好地缩小到做脚本的规模。脚本就是一种经常会被执行的放在文件中的句子序列。把以下代码放在hello.scala文件中：

 println("Hello, world, from a script!")

 然后运行

$ scala hello.scala

于是你又会得到另外的祝词

Hello, world, from a script!

通过Scala的名为args的数组可以获得传递给Scala脚本的命令行参数。Scala里，数组以零开始，通过在括号里指定索引访问一个元素。所以Scala里数组steps的第一个元素是steps(0)，不是像Java里的steps[0]。作为测试，输入以下内容到新文件helloarg.scala： 

// 向第一个参数打招呼

println("Hello, " + args(0) + "!")

然后运行：

$ scala helloarg.scala planet

这条命令里，"planet"被作为命令行参数传递，并在脚本里作为args(0)被访问。因此，你会看到：

Hello, planet!

注意这个脚本包括了一条注释。Scala编译器将忽略从//开始到行尾截止的以及在/*和*/之间的字符。本例还演示了String使用+操作符的连接。这与你的预期一样。表达式"Hello, "+"world!"将产生字符串"Hello, world!"。

第五步：用while循环；用if判断

 要尝试while，在printargs.scala文件里输入以下代码：

var i = 0
while (i < args.length) {
  println(args(i))
  i += 1
}

注意 虽然本节的例子有助于解释while循环，但它们并未演示最好的Scala风格。在下一段中，你会看到避免用索引枚举数组的更好的手段。

 这个脚本开始于变量定义，var i = 0。类型推断认定i的类型是scala.Int，因为这是它的初始值的类型，0。下一行里的while结构使得代码块（大括号之间的代码）重复执行直到布尔表达式i < args.length为假。args.length给出了args数组的长度。代码块包含两句话，每个都缩进两个空格，这是Scala的推荐缩进风格。第一句话，println(args(i))，输出第i个命令行参数。第二句话，i += 1，让i自增一。注意Java的++i和i++在Scala里不起作用，要在Scala里自增，必须写成要么i = i + 1，或者i += 1。用下列命令运行这个脚本：

$ scala printargs.scala Scala is fun

你将看到：

Scala is fun

注意Scala和Java一样，必须把while或if的布尔表达式放在括号里。（换句话说，就是不能像在Ruby里面那样在Scala里这么写：if i < 10。在Scala里必须写成if (i < 10)。）另外一点与Java类似的，是如果代码块仅有一个句子，大括号就是可选的，

并且尽管你没有看到，Scala也和Java一样使用分号分隔句子的，只是Scala里的分号经常是可选的。

第六步：用foreach和for枚举

 

尽管或许你没意识到，在前一步里写while循环的时候，你正在用指令式：imperative风格编程。指令式风格，是你常常使用像Java，C++和C这些语言里用的风格，一次性发出一个指令式的命令，用循环去枚举，并经常改变共享在不同函数之间的状态，

Scala允许你指令式地编程，但随着你对Scala的深入了解，你可能常会发现你自己在用一种更函数式：functional的风格编程。

函数式语言的一个主要特征是，函数是第一类结构，这在Scala里千真万确。举例来说，另一种（简洁得多）打印每一个命令行参数的方法是：

args.foreach(arg => println(arg))

这行代码中，你在args上调用foreach方法，并把它传入函数。此例中，你传入了带有一个叫做arg参数的函数文本：function literal。函数体是println(arg)。如果你把上述代码输入到新文件pa.scala，并使用命令执行：

$ scala pa.scala Concise is nice

你会看到：

Concise
is
nice

如果你更喜欢简洁的而不是显式的风格，就可以充分体会到Scala特别简洁的优越性。如果函数文本由带一个参数的一句话组成，你都不需要显式命名和指定参数。11
这样，下面的代码同样有效：

args.foreach(println)

总而言之，函数文本的语法就是，括号里的命名参数列表，右箭头，然后是函数体。语法演示在下图中

                        

为了努力引导你向函数式的方向，Scala里只有一个指令式for（称为for表达式：expression）的函数式近似。创建一个新文件forargs.scala，输入以下代码：

for (arg <- args)
println(arg)

这个表达式里“for”之后的括号包含arg<-args。<-右侧的是熟悉的args数组。<-左侧的是“arg”，val的名称（不是var）。（因为总归是val，你只要写arg就可，不要写成val arg。）尽管arg可能感觉像var，因为他在每次枚举都会得到新的值，但它的确是val : arg不能在for表达式的函数体中重新赋值。取而代之，对每个args数组的元素，一个新的arg val将被创建并初始化为元素值，然后for的函数体将被执行。

你可以认为<-符号代表“其中”。如果要读for(arg<-args)，就读做“对于args中的arg”。

如果执行forargs.scala脚本：

$ scala forargs.scala for arg in args

可以看到：

for 
arg 
in 
args