原本连接： http://www.ibm.com/developerworks/cn/java/j-lo-fantom/
Fantom 诞生于 2007 年，相比于 Groovy 和 Scala 来说已经算是比较晚了。但是它吸收了其他语言的长处，形成了自己独特的语法风格，在新一代基于 JVM 的语言中占有了重要的地位。本文是对于 Fantom 编程语言的一个简要介绍，包括了基本语法和一些高级特性，例如对闭包、动态编程 (Dynamic Programming)，以及函数式编程 (Functional Programming) 的支持。本文的主要目标是使 Java 开发人员可以熟悉 Fantom 这种语言，并能感受到 Fantom 结构上的精简和功能上的强大。
需要注意的是，Fantom 并不仅仅可以在 JVM 中运行，还可以在 .net CLR（通用语言运行时）和浏览器中运行。对多种平台的支持也使得 Fantom 的竞争力得到了进一步的提升。
要体验 Fantom 各种有趣的特性，首先需要在您的计算机上安装 Fantom。在 Linux 和 Windows 平台上安装的步骤并不相同，这里介绍 Linux 平台上的安装方法，Windows 平台上则可以参考这里的教程。
首先在 这里下载 Fantom 的发行包（zip 格式）。发行包里同时包含了 Linux 和 Windows 平台下所需的文件。下载完成之后，将其解压到您选定的目录。浏览目录下的内容，您会发现很多 Fantom 的文档以及示例程序等有用的内容。当然，最重要的是 bin 目录下的几个可执行文件，尤其是 fan/fan.exe，它是 Linux/Windows 平台下 Fantom 语言的解释器和编译器。
接下来需要配置环境变量。定义一个环境变量 FANTOM_HOME（或者任何您喜欢的名字），指向解压 Fantom 的目录。然后将 FANTOM_HOME/bin 添加到 PATH 中。
最后，运行一下 adm 目录中的 unixsetup，为所有可执行文件添加执行权限：
清单 1. 为 Fantom 的可执行文件添加权限
bash adm/unixsetup |
至此，Fantom 的运行环境就配置完毕了。或许您还希望安装一个集成开发环境（IDE）。目前支持 Fantom 的 IDE 还不是很多，推荐使用基于 Eclipse 的Fantom IDE。不过由于 Fantom 语言的简洁性，使用普通的文本编辑器也一样可以很好的完成开发工作。
接下来，像所有编程语言的介绍一样，我们从“Hello World”开始。
Fantom 从本质上来说是一种脚本语言，所以您可以写出如下简洁的 Hello World 脚本：
清单 2. Fantom 的 Hello World 脚本
class HelloWorld
{
static Void main()
{
echo("Hello world!")
}
}
|
保存为 helloworld.fan，然后这样运行它：
清单 3. 运行 Hello World 脚本
root@computer:~# fan helloworld.fan Hello world! |
和很多脚本语言一样，Fantom 也提供了一个 Shell 环境。您同样可以在 Shell 环境中完成 Hello World：
清单 4. Shell 环境中的 Hello World
root@computer:~# fansh Fantom Shell v1.0.56 ( ‘ ? ’ for help) fansh> echo (“Hello world!”) Hello world! fansh> quit |
作为 JVM 的备选语言之一，Java 做到的 Fantom 也能做到。所以我们也可以把 Hello World 显示到 Web 页面上。Fantom 中提供了对 Web 服务器的内置支持（WISP 库）。所以我们不需要第三方的 Web 服务器就可以实现一个简单的 Web 应用程序。
下面是 Fantom 发行包里面附带的一个例子，您可以在 example/web/hello.fan 中找到：
清单 5. Web 环境中的 Hello World
using util
using web
using wisp
class WebHello : AbstractMain
{
@Opt { help = "http port" }
Int port := 8080
override Int run()
{
wisp := WispService
{
it.port = this.port
it.root = HelloMod()
}
return runServices([wisp])
}
}
const class HelloMod : WebMod
{
override Void onGet()
{
res.headers["Content-Type"] = "text/plain; charset=utf-8"
res.out.print("hello world #4")
}
}
|
下面对这段代码做一些说明：
- 类 WebHello 继承自 AbstractMain，AbstractMain 用于快速地创建应用程序，无论是 Web 应用程序，还是桌面应用程序，都可以通过继承这个类来方便的创建。WebHello 重载了 AbstractMain 中的 run 方法，这个方法是应用程序的入口点，这里用来初始化 Web 服务器；
- run 方法中声明了一个 WispService 的实例，这个实例中指定 Web 服务器的端口（8080）和开启的服务（HelloMod）；
- HelloMod 类相当于 Java 中的 Servlet，其中有一个重载的 onGet 方法，相当于 Servlet 中的 doGet。在这个例子的 onGet 方法中，除了指定 HTTP 头以外，只输出了一行“hello world #4”。
由于 Fantom 提供了内置的 Web 服务器支持，运行这个例子十分简单，只需要使用 Fantom 解释器处理这段代码：
清单 6. 运行 Hello World
root@computer:~# fan examples/web/hello.fan [16:08:57 21-Dec-10] [info] [web] WispService started on port 8080 |
看到上面所示的 WISP 服务启动成功的信息之后，您就可以在浏览器中访问 http://localhost:8080来查看运行结果了，十分方便，是不是？
上面介绍了三种不同形式的使用 Fantom 语言编写的 Hello World 程序。仔细观察这些代码，您会发现 Fantom 的语法和 Java 有很大的不同。正是这种独特的语法使 Fantom 语言的代码十分简洁易懂。
Fantom 在语法上有很多和 Java 相同的地方，包括绝大部分的运算符，if … else 结构，while 和 for 循环等。但做为一种新的编程语言，Fantom 也吸收了很多其他编程语言的语法特性。接下来会举例介绍。
Fantom 的语句是以行为单位的，语句的结尾并不需要分号，这一点与 Java 不同。但为了照顾众多 Java 和 C++ 程序员的使用习惯，以分号分隔的语句也同样被支持：
清单 7. Fantom 的语句
if(true) {
dosomething()
return
} // OK for Fantom
if(true) {
dosomething();
return;
} // OK for Fantom
if(true) {
dosomething();return;
} // OK for Fantom too
|
对于像 Java 和 C++ 这样的强类型编程语言来说，声明和赋值语句看起来没什么区别，除了声明语句最左侧的类型定义：
清单 8. Java 的声明和赋值语句
String foo = “Foo”; // Java declaration foo = “Foo”;// Java assignment |
而对于弱类型的语言，例如 Perl 来说，声明和赋值语句看起来是完全一样的。这使得有的时候代码十分难于读懂：
清单 9. Perl 的声明和赋值语句
$foo = “Foo”;// Perl assignment or declaration |
而 Fantom 同时支持强类型和弱类型风格的变量声明：
清单 10. Fantom 的声明语句
Str foo := “Foo” foo := “Foo” |
而赋值语句是这样的：
清单 11. Fantom 的赋值语句
foo = “Foo” |
可以看到声明和赋值时使用的操作符是不一样的。这使得代码更加清晰易读。
在使用 Java 开发应用程序的时候，一个特别需要注意的地方就是避免对空对象使用成员引用操作符（.），如果对一个为 null 的对象使用成员引用操作符，会抛出 NullPointerException 异常。但在 Fantom 中，如果您使用像下面这样的空对象安全的（Null-Safe）代码，就可以无需考虑这个问题：
清单 12. 空对象安全的成员引用
price = fruitMap?.find(“Apple”)?.getPrice() |
这行代码相当于：
清单 13. 与清单 12 等价的代码
Int price := null
if (fruitMap != null)
{
fruit := fruitMap.find(“Apple”)
if ( fruit != null )
price = fruit.getPrice()
}
|
可见如果 fruitMap 或者 fruitMap.find() 的返回值为 null，则 price 也为 null。在这个过程中并不会抛出任何异常，而且只需要一条语句，十分简洁。
Fantom 中借鉴了 Perl 的数据类型——列表（List）和映射（Map，Perl 中称之为散列—— Hash）。而在 Java 中实现同样的数据结构则需要使用接口 java.util.List<E> 和 java.util.Map<K,V> 的实现类，很显然 Fantom 中选用了更简洁的语法。下面举例说明：
清单 14. Fantom 的列表
Int[10, 20, 30] [10, 20, 30] |
上面两条语句的效果是一样的，在列表中的元素类型已经确定的情况下，前面的数据类型定义可以省略。
Fantom 还引入了一种新的数据类型表示，即在数据类型后面加 ?，这种新的数据类型的默认值为 null，而不是根据类型不同而使用不同的默认值，例如 Int，预设的默认值是 0，而 Int? 的默认值是 null。默认的 Int 列表是不能够储存 null 类型的元素的，如果想要实现这一点，需要如下的定义：
清单 15. 能储存 null 元素的列表
[10, null, 30] Int?[10, 20, 30] |
第一条语句中的第二个元素是 null，因此列表被定义为 Int? 类型，而第二条语句则是显式指定列表为 Int? 类型，两条语句的效果是一样的。
上面的例子中我们可以知道，Fantom 对于元素类型不统一的列表定义，会为列表使用一个通用的数据类型，下面是几个例子：
清单 16. 不同类型元素的混合列表
[10, ”20”, 30] // evaluates to Obj[] [10, 20f, 30] // evaluates to Num[] |
对于 [10, “20”, 30] 这个例子，由于第二个元素是 Str 类型，而另外两个元素是 Int 类型，因此这个列表的类型是 Int 和 Str 的共同基类—— Obj。第二个例子同理，列表的类型是 Int 和 Float 的共同基类—— Num。
映射用来储存一组键 / 值对，定义映射的语句如下：
清单 17. Fantom 的映射
[Int:Str][1:”one”, 2:”two”, 3:”three”] Int:Str[1:”one”, 2:”two”, 3:”three”] [1:”one”, 2:”two”, 3:”three”] |
上面三种定义是等价的。映射在其元素数据类型不一致时的规则与列表相同，不再赘述。
上述的只是一些 Fantom 的一些新的语法特点，更详细的介绍可以在 Fantom 的在线文档库中找到。
在了解 Fantom 的基本语法之后，下面来介绍 Fantom 中类的定义。对于 Java 语言来说，JavaBean 是一个很重要的概念，一个典型的 JavaBean 定义里，通常有若干个 private 的成员变量，以及用来存取这些成员变量的 public 的 getter 和 setter 方法，另外可能还有一些其他的 public 方法，如下面的例子：
清单 18. Java 的类定义
public class Employee {
private String name;
private Integer age;
private Integer yearOfService;
public String name() { return this.name; }
public void name( String name ) { this.name = name; }
public Integer age() { return this.age; }
public void age( Integer age ) { this.age = age; }
public Integer yearOfService() { return this.yearOfService; }
public void yearOfService( Integer yearOfService ) \
{ this.yearOfService = yearOfService }
public Float calculateSalary() { …… }
}
|
而在 Fantom 中，对应的类只需要很少的代码：
清单 19. Fantom 的类定义
class Employee {
Str name
Int age
Int yearOfService
Float calculateSalary() { …… }
}
|
Fantom 会自动生成对应的 getter 和 setter 方法。如果需要自己重载，也相当简单：
清单 20. 重载 setter 方法
class Employee {
Str name
Int age { set { checkAge(val); &age = it } }
Int yearOfService
Float calculateSalary() { …… }
}
|
其中的 it是保留字，表示将要赋给成员变量的值，即 setter 方法的参数；&age表示成员变量 age 实际的存储单元。
事实上，Fantom 还自动生成了一个类的默认构造函数，这个构造函数以保留字 make为名字：
清单 21. 类的构造函数
class Employee {
Str name
Int age
Int yearOfService
new make(Str name, Int age, Int yearOfService)
{
this.name = name
this.age = age
this.yearOfService = yearOfService
}
}
|
在 Java 中，类的构造函数是没有返回类型的，而在 Fantom 中，构造函数前需要加保留字 new以示不同。
在 Java 语言中，代码的管理是以包（package）为单位的。包定义了一个名字空间（namespace），使得在代码量较大的时候管理起来比较容易，同时也使得不同名字空间下的代码相互隔离。包的名称是层次化的，整个代码库是一个树状结构：
图 1.Java 的代码结构
包的引入解决了名字混乱的问题，但是如果包的层次比较多的话，整个代码结构仍然会变得难以读懂。
而在 Fantom 中，包的概念被容器（Pod）所代替，代码被组织为两个层次：容器和类。于是代码呈现一种扁平的两层结构：
图 2.Fantom 的代码结构
实际上 Fantom 中的容器不仅能完成代码管理的工作，还能提供代码部署时的支持，在这点上，它相当于 Java 中的 Jar 文件，或者 .NET 平台上的 DLL 文件。
我们可以把之前的 Hello World 程序包装进容器中，虽然对于这种规模很小的程序没有什么用处，但是可以通过这个过程了解 Fantom 下容器的概念，以及打包代码库的方法。这里以 Linux 环境下为例。
首先我们需要设置容器的目录结构，选择一个目录作为容器的工作目录，过一会儿我们要在这个目录下放置编译脚本。再选择一个目录作为代码目录，放置待编译的代码，为了方便，我们把代码目录放在工作目录下，结构如下所示：
清单 22.目录结构
hello/
build.fan
source/
hello.fan
|
这里的 build.fan 就是编译脚本，实际上它也是以 Fantom 源代码形式编写的，内容如下：
清单 23.编译脚本
class Build : build::BuildPod
{
new make()
{
podName = "hello"
summary = "hello world pod"
depends = ["sys 1.0"]
srcDirs = [`source/`]
}
}
|
我们可以看到，这个编译脚本实际上创建了一个 BuildPod 的派生类，并在构造函数中设置了必要的一些参数。容器 build 中提供了很多用于编译 Fantom 代码库的功能，读者们可以参考 Fantom 的文档库查询详细的介绍。
对于 Hello World 程序来说，我们只需要一个源代码文件 hello.fan，它的内容如下：
清单 .24 Hello World 代码
class Main
{
static Void main() { echo("Hello world!") }
}
|
由于编译脚本实际上也是 Fantom 源代码，我们只需要使用 Fantom 解释器运行这段脚本就能完成编译：
清单 25. 编译 Hello World 容器
root@computer:~/hello# fan build.fan
compile [hello]
Compile [hello]
FindSourceFiles [1 files]
WritePod [file:/usr/local/fantom/lib/fan/hello.pod]
BUILD SUCCESS [39ms]!
|
代码已经编译完成了，我们可以在命令行中访问容器里的方法：
清单 26. 在 Shell 中访问容器中的方法
root@computer:~/hello# fan hello Hello world! root@computer:~/hello# fan hello::Main Hello world! root@computer:~/hello# fan hello::Main.main Hello world! |
同样也可以在代码里访问容器里的方法。创建一个新的文件 AccessPod.fan，加入如下代码：
清单 27. 在代码里访问容器中的方法
using hello
class AccessPod {
static Void main() { hello::Main.main() }
}
root@computer:~ # fan AccessPod.fan
Hello world!
|
在前面的例子中我们可以看到，编译 Fantom 源代码得到的是 .pod 文件，这种文件中包含了编译 Fantom 源代码而生成的字节码（我们称之为 Fcode）、常量池以及程序运行必须的资源文件等。实际上它是一个普通的 zip 文件，您可以使用任何解压缩工具来查看其中的内容：
清单 28. 解压 pod 文件
root@computer:~/fantom/lib/fan# unzip ./hello.pod – d ./hello Archive: ./hello.pod inflating: ./hello/meta.props inflating: ./hello/fcode/names.def inflating: ./hello/fcode/typeRefs.def inflating: ./hello/fcode/methodRefs.def inflating: ./hello/fcode/strs.def inflating: ./hello/fcode/types.def inflating: ./hello/fcode/Main.fcode inflating: ./hello/doc/Main.apidoc |
在上一章中我们了解到，Fantom 源代码被编译成 pod 文件，那么在 Fantom 运行环境中运行 pod 文件的原理是怎样的呢？本章将简要说明。
现在我们已经知道 Fantom 代码是在 Fantom 运行环境中被执行的，那么为什么说 Fantom 可以在 JVM 中运行呢？这是因为 Fantom 运行环境实际上是运行在 JVM 之上的。因此 Fantom 代码的部署和运行过程如下：
- 源代码被编译成 Fcode 形式的代码，并与其他资源文件等被打包成 pod 文件；
- 在运行时，Fantom 运行环境读取 pod 文件，并生成 Java 字节码输出给 JVM；
- Fantom 提供的系统 API 是使用 Java 代码实现的。
下图可以形象地说明这一过程：
图 3. 在 JVM 中运行 Fantom 代码
前面介绍过，Fantom 代码还可以在 .Net 运行时上运行，这时对应于 .Net 平台的运行环境会将 pod 文件转换成 .Net 中间语言，同时，另一套使用 C# 编写的系统 API 库会被使用，这与在 JVM 上的情况是十分类似的。
Fantom 代码还可编译成 JAR 文件，从而直接被 JVM 读取并运行。下面的例子把前面使用过的 WISP 库编译打包成 JAR 文件：
清单 29. 将 WISP 库打包成 JAR 文件
using Build
class Build : BuildScript {
Void distWisp() {
dist := JarDist(this)
dist.outFile = `./wisp.jar`.toFile.normalize
dist.podNames = Str[“concurrent”, “inet”, “util”, “web”, “webmod”, “wisp”]
dist.mainMethod = “wisp::WispService.main”
dist.run
}
}
|
接下来介绍 Fantom 中的一些高级特性，包括闭包和多线程支持。
Fantom 中的闭包定义为：一个在方法内部定义的函数，如果它可以引用它的作用域之外的局部变量，就称这个内部函数为闭包。
先来看一个简单的闭包例子：
清单 30. Fantom 的闭包
class ClosureExample {
static Void main() {
Int a := 5
f := |Int b->Int|{ return a + b }
echo(f(6)) // print 11 on screen
}
}
|
闭包是没有名字的，上面的代码中，闭包被赋给了变量 f，f 就表示了闭包生成的匿名函数。接下来我们就可以按照一般函数的用法来调用函数 f。闭包引用了一个外部的变量 a，另外还定义了一个参数 b，并声明返回 Int 类型的值。接下来我们对这段代码做一点修改：
清单 31. 绑定局部变量的闭包
class ClosureExample {
static Void main() {
Int a := 5
f := |Int b->Int|{ return a = a + b }
echo(f(6)) // print 11
echo(f(6)) // print 17
echo(a) // print 17
}
}
|
可以看到，变量 a 在闭包内被修改了，并且在闭包之外依然有效。我们称之为闭包绑定了局部变量 a。闭包的这种特性使得它可以在封闭作用域下保存自己的状态。闭包同样可以绑定类的成员变量：
清单 32. 绑定成员变量的闭包
class ClosureExample {
Int a
Void test() {
a = 5
f := |Int b->Int|{ return this.a + b }
echo(f(6)) // print 11
echo(f(6)) // print 17
echo(a) // print 17
}
}
|
由于闭包可以被当做参数传递，所以利用闭包来实现对列表和映射的遍历是相当方便的：
清单 33. 使用闭包遍历列表
list := [1, 2, 3]
f := |Int val| { echo(val*val) }
list.findAll(f)
|
上面这段代码遍历列表 list，并输出每个元素的平方。findAll 方法接收一个函数作为参数，并将这个函数应用在列表的每个元素上。
闭包是实现函数式编程的重要工具。更多关于闭包的语法特性可以参考 Fantom 的在线文档。
Java 中使用共享内存机制来实现多线程并发。为了保证程序的正确性和一致性，Java 程序员必须十分小心的编写代码，避免发生饥饿和死锁等情况。这无形中提高了 Java 下多线程程序的开发门槛。而 Fantom 下使用了完全不同的多线程模型，它基于以下三个基本原则：
- 在任何情况下，线程间不能共享任何 可变 的状态；
- 不可变 的数据可以安全地在线程间共享；
- 线程间可以通过消息传递来共享数据。
前两条原则意味着所有可变的数据都只能在线程内部访问，这样就保证了一致性，因此 Fantom 中并没有锁操作，因为可以共享的数据都是不可变的，并不需要锁来保证一致性。
什么样的数据是不可变的呢？不可变的数据包括：
- 所有的以 const 修饰的对象，以及
- 使用 Obj.toImmutable 转化的列表、映射以及函数对象。
Fantom 中的线程对应的类是行动者（Actor）。它提供了一系列的方法，用于在线程间传递数据：
清单 34. 向 Actor 对象传递消息的方法
Future send(Obj? msg) Future sendLater(Duration d, Obj? msg) Future sendWhenDone(Future f, Obj? msg) |
send 方法将一个消息（对象或 null）传递给行动者。sendLater 方法在语句执行之后一定的时间再将小时传递给行动者。而 sendWhenDone 方法则是在另外一个消息被处理完成之后再将消息传递给行动者。
Future 类用来表示消息处理的结果，它提供了 get 方法来获得消息处理的返回值：
清单 35. 获得消息处理返回值的方法
Obj? get(Duration? Timeout := null) |
Timeout 用来设定等待时间，如果设为 null，则程序将一直等待直到获得返回值。
Actor 类还有一个可重载的方法 receive，是接收到消息时的回调函数，我们可以重载它以加入自定义的消息处理代码：
清单 36. 重载 receive 方法
const class MyActor : Actor {
new make(ActorPool p) : super(p) { }
override Obj? receive(Obj? msg) { doSomething() }
}
|
另外一种方法是在 Actor 类的构造函数中传入一个闭包，作为 receive 方法：
清单 37. 定义回调函数
f := |Int msg->Int| { doSomething() }
a := Actor(ActorPool(), f)
|
Actor 类的构造函数还有一个参数 ActorPool，这个类用来定义行动者的资源池，我们可以通过修改参数来指定资源池允许的最大 Actor 数量，它的默认值是 100：
清单 38.b 定义 Actor 数量的上限
ActorPool { maxThread = 10 }
|
本文只是对 Fantom 编程语言的一个简单介绍，目的是让使用其他编程语言的开发人员了解 Fantom 中提供的一些独特的语法和功能。实际上 Fantom 的历史还很短，它依然有很好的机会变得更加强大和易用。
Fantom 吸收了很多其他编程语言的优秀设计，例如 Python 等语言中的 Mixin，Erlang 中的闭包和 Actor 模型等等。另外，它还可以和 Java 的代码进行互操作，从而有效地利用大量现有的 Java 代码。
Fantom 在短时间内不大可能替代 Java 语言的地位。但是作为 JVM 的备选语言，Fantom 提供了另一种很好的选择，它可以用更少的代码完成很多 Java 可以完成的东西，也可以完成一些 Java 难以完成的东西。随着 Fantom 的不断发展，它完全有能力在 JVM 平台上发挥更重要的作用。
195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
