Q网志

来源：Ivan_Pig

很遗憾，JavaFX目前没有发布Linux版本！我使用http://deadlock.netbeans.org/hudson/job/JavaFX_NB_daily/的NetBeans日构建的插件(11月24日停止更新了)，运行JavaFX1.0的例子程序报错！郁闷，看来只能等Sun放出Linux版本的JavaFX了！还有，JavaFX目前的语法和之前的语法好像有了很大的区别！所以才想到翻译这个文档，计划一天翻译一到两节！
原文地址：http://java.sun.com/javafx/1/tutorials/core/index.html

总目录：
Lesson 1: Getting Started with JavaFX Script
Lesson 2: Writing Scripts
Lesson 3: Using Objects
Lesson 4: Data Types
Lesson 5: Sequences
Lesson 6: Operators
Lesson 7: Expressions
Lesson 8: Data Binding and Triggers
Lesson 9: Writing Your Own Classes
Lesson 10: Packages
Lesson 11: Access Modifiers

Lesson 1: Getting Started with JavaFX Script

目录

- Step 1 : 下载并安装JDK
- Step 2 : 选择开发环境
- Step 3 : 下载并安装JavaFX编译器

Step 1: 下载并安装JDK

JavaFX脚本语言是建立在Java平台上的脚本语言，你的机器需要安装JDK5或者JDK6(JDK6在速度方面有提高)。如果你还没有安装，请在开始学习此教程前下载和安装JDK6或者JDK5。

Step 2: 选择开发环境

关于JavaFX开发环境，你有两个选择：使用IDE或者使用文本编辑工具。至于选择哪种开发环境，完全在于个人习惯。但是下面的总结能帮助你做出一个合理的选择。

普遍看法:（不翻译了，反正就是推荐使用IDE，也就是Netbeans了，目前就NetBean有此插件。要不你就用文本编辑工具吧！）

*IDEs present the most commonly used functions as Graphical User Interface (GUI) elements, and offer many useful features, such as automatic code completion. An IDE also gives you immediate feedback on errors and highlights code so that it is easier to understand.

* A text editor provides simplicity and familiarity. Experienced programmers often rely on their text editor of choice, preferring to work in that environment whenever possible (some editors, like vi, have a rich set of built-in keystroke commands that some programmers simply cannot live without!)

The officially supported IDE for the JavaFX Script programming language is NetBeans IDE 6.5. The NetBeans IDE website provides instructions for downloading, installing, and configuring the IDE.

Step 3: 下载并安装JavaFX编译器

你还需要下载和安装JavaFX脚本编译器和运行时环境。一个途径就是下载JavaFX SDK，它除了提供JavaFX编译器，运行时环境还提供了一些其他的工具。

另一个途径就是从openjfx项目的网站上下载最新的编译器二进制文件。编译器是用Java写的，安装方法就是解压缩下载的文件，然后将javafxc和javafx tools添加到你的路径下去。具体的方法在PlanetJFX WiKi上有完整介绍！

最后，如果你想冒险尝试（if you want to live on the bleeding edge）—-你可以加入OpenJFX编译器项目，创建你自己的一个拷贝，然后自己编译源码。（如果你选择这个途径，你还需要Apache Ant1.7.0,较新版本的Subversion—写此文章时最新版本是1.5.4）。想获得更多关于从源码创建编译器的信息，请浏览Planet JFX Wiki.

Lesson 2: Writing Scripts

目录

- 编写一个简单的计算器
- 声明变量
- 方法的定义和执行
- 给方法传递参数
- 方法的返回值
- 使用命令行参数

-编写一个简单的计算器

开始之前，你要有一个calculator.fx文件，包含如下代码。

def numOne = 100;
def numTwo = 2;
var result;  

add();
subtract();
multiply();
divide();  

function add() {
     result = numOne + numTwo;
     println("{numOne} + {numTwo} = {result}");
}  

function subtract() {
     result = numOne - numTwo;
     println("{numOne} - {numTwo} = {result}");
}  

function multiply() {
     result = numOne * numTwo;
     println("{numOne} * {numTwo} = {result}");
}  

function divide() {
     result = numOne / numTwo;
     println("{numOne} / {numTwo} = {result}");
}

JavaFX脚本语言是变异型语言，就是说所有的源代码在运行前都需要先转化为Java字节码！

下面的命令将会编译calculator脚本:

javafxc calculator.fx

编译完成后， 你会发现相应的Java字节码被生成，并且被放置到了叫做calculator.class的文件里面。你还会发现另一个文件calculator$Intf.class被创建。这个文件是被提供来运行应用的—你可以忽略它，但是不要删除。

现在你可以用下面的命令运行编译后的类了。

javafx calculator

输出：

100 + 2 = 102
100 - 2 = 98
100 * 2 = 200
100 / 2 = 50

这是一个很小的程序，但是它向你展现了JavaFX里面一些很重要的组成部分。学习这些部分是你掌握JavaFX的第一步。

Note:JavaFX语言不难掌握，但是由于你是第一次接触它，我们一次只介绍一部分的知识点以便你能更好的掌握它。我们的宗旨是方法的明了。我们会在后面的章节介绍更高级的用法。

-声明变量

让我们来仔细看一下calculator.fx这个例子—后面我们会扩展这个例子。

第一段代码定义了几个变量：

def numOne = 100;
def numTwo = 2;
var result;

变量可以由var或者def关键字来定义。 两者的区别是var定义的变量可能在程序的执行过程期间有新的值被赋给它,而def定义的变量会一直保留第一次被赋予的值！我们给numOne,numTwo变量赋了值，但没有给result变量赋初值，因为这个变量将会保存我们的计算结果。

变量名一般由字母和数字组成，且不能以数字开头！建议以小写字幕开头，如果变量包含不止一个单词，从第二个单词开始，大写每个单词的第一个字母，如上例所示（numOne）。

Note:你可能注意到了，我们并没有做特别的规定让变量去存储一个数字（对字符串或其他类型的数据也是一样的）。编译器足够的聪明，能够从变量所存储的内容判断出类型。这就是类型猜测.类型猜测使你的工作简单化，像编写脚本语言一样，因为你不需要再定义变量的类型了。

-方法的定义和执行

余下的源代码定义了一些方法，add,subtract,multiply和divide。

function add() {
     result = numOne + numTwo;
     println("{numOne} + {numTwo} = {result}");
}  

function subtract() {
     result = numOne - numTwo;
     println("{numOne} - {numTwo} = {result}");
}  

function multiply() {
     result = numOne * numTwo;
     println("{numOne} * {numTwo} = {result}");
}  

function divide() {
     result = numOne / numTwo;
     println("{numOne} / {numTwo} = {result}");
}

方法是一段可执行的代码块，执行特定的任务！在我们的例子中，每个方法执行一个数学计算并打印结果！将执行的代码放置到方法中可以使你的程序更加的易读，易用和除错！方法体被大括号包围，方便辨认方法的开始和结束！

如果不调用方法，方法不会真正的执行！这使得你可以在你程序的任何地方去执行方法！不管方法的定义是在调用的前面还是后面，都没有关系！在我们的例子中，我们在方法定义前就执行了方法！

方法执行代码如下:

add();
subtract();
multiply();
divide();

-给方法传递参数

下面我们将修改calculator代码使其能接受参数！参数是你在执行方法时传递给方法的值！使用这种途径，我们的计算器能运算任意两个数的四则运算，而不是只能运算硬编码给numOne和numTwo的值。

var result;  

add(100,10);
subtract(50,5);
multiply(25,4);
divide(500,2);  

function add(argOne: Integer, argTwo: Integer) {
     result = argOne + argTwo;
     println("{argOne} + {argTwo} = {result}");
}  

function subtract(argOne: Integer, argTwo: Integer) {
     result = argOne - argTwo;
     println("{argOne} - {argTwo} = {result}");
}  

function multiply(argOne: Integer, argTwo: Integer) {
     result = argOne * argTwo;
     println("{argOne} * {argTwo} = {result}");
}  

function divide(argOne: Integer, argTwo: Integer) {
     result = argOne / argTwo;
     println("{argOne} / {argTwo} = {result}");
}

现在的输出为:

100 + 10 = 110
50 - 5 = 45
25 * 4 = 100
500 / 2 = 250

在这一个版本里面我们移除了numOne和numTwo这两个变量，因为不再需要它们了！取而代之的是我们修改了方法的定义，需要传递两个参数给方法。每个参数都有名称，后面跟着一个冒号加类型。当方法接受多个参数的时候，参数之间用逗号隔开。

-方法的返回值

方法可能会有返回值。比如，add方法可以修改为返回计算结果，如下：

function add(argOne: Integer, argTwo: Integer) : Integer {
     result = argOne + argTwo;
     println("{argOne} + {argTwo} = {result}");
     return result;
}

add方法现在可以像这样运行：

var total;
total = add(1,300) + add(23,52);

如果没有返回值需要返回，默认返回Void。

-使用命令行参数

我们可以进一步的修改calculator程序来接受命令行参数。这可以使终端用户在运行时决定需要计算的数值。

var result;  

function run(args : String[]) {  

     // Convert Strings to Integers
     def numOne = java.lang.Integer.parseInt(args[0]);
     def numTwo = java.lang.Integer.parseInt(args[1]);  

     // Invoke Functions
     add(numOne,numTwo);
     subtract(numOne,numTwo);
     multiply(numOne,numTwo);
     divide(numOne,numTwo);
}  

function add(argOne: Integer, argTwo: Integer) {
     result = argOne + argTwo;
     println("{argOne} + {argTwo} = {result}");
}  

function subtract(argOne: Integer, argTwo: Integer) {
     result = argOne - argTwo;
     println("{argOne} - {argTwo} = {result}");
}  

function multiply(argOne: Integer, argTwo: Integer) {
     result = argOne * argTwo;
     println("{argOne} * {argTwo} = {result}");
}  

function divide(argOne: Integer, argTwo: Integer) {
     result = argOne / argTwo;
     println("{argOne} / {argTwo} = {result}");
}

这次修改新增了一些新的知识点，最值得注意的就是run()方法。不像其他的方法，run()是一个特殊的方法，是程序的入口点！run()方法会在args变量里面保存所有的命令行参数，以String Sequences的形式保存（Sequences是有序的对象链，很像其他编程语言里面的数组；在后面的章节将详细介绍）。

运行这段代码，现在你必须要设定第一个和第二个参数。

javafx calculator 100 50

输出:

100 + 50 = 150
100 - 50 = 50
100 * 50 = 5000
100 / 50 = 2

Note:在之前的所有版本里面，我们并没有提供run()方法。我们只是输入代码然后它就执行了。默认情况下，编译器会插入一个无参的run()方法，然后在里面放入要执行的代码！

我们重新定义了numOne和numTwo变量，这次是才run()方法内定义的，我们的计算functions需要数字类型的参数，但是命令行参数是字符串，我们在将命令行参数赋给方法前，必须要要将每个命令行参数从String转化为Integer。

// Convert Strings to Integers
def numOne = java.lang.Integer.parseInt(args[0]);
def numTwo = java.lang.Integer.parseInt(args[1]);

我们借助Java语言来完成这个转换。这个简单的脚本语言能直接使用Java语言而获得很强大的功能（Tapping into the existing Java ecosystem as needed brings tremendous power to this otherwise simple scripting language. ）

Lesson 3: Using Objects

目录

- 什么是对象？
- 声明一个对象
- 对象结构
- 执行实例方法

-什么是对象？

什么是对象？对象是软件里面互不关联的部分，对象具有状态和行为！简言之：

对象的变量表示对象的状态。
对象的方法表示对象的行为。.
理论上，对象能模拟任何东西，从GUI组件(按钮，多选框，标签)到不可见的抽象的东西(温度，金融，产品注册信息等)

Note:想了解更多，请看Java教程里的相应教程。

-声明一个对象

在JavaFX脚本语言里面，对象是由object literal创建的。

Address {
     street: "1 Main Street";
     city: "Santa Clara";
     state: "CA";
     zip: "95050";
}

我们创建了一个Address对象，给假象的地址簿应用程序使用。下载Address.zip解压缩类文件和AddressBook.fx

Note:Address.class文件(Address.class和Address$Intf.class)包含了你创建Address对象的重要信息，供编译器使用。如果你想知道这些文件是从哪里来的，你可以先创建Address类的定义文件(叫Address.fx的文件)，然后编译它，就会生成Address.class文件。JavaFX脚本语言和Java语言提供了很多预编译的class文件供你在程序里面使用。这使得你可以完成不同领域的任务，包括创建有震撼视觉效果的GUI程序。我们会在此教程的最后告诉你怎么创建自己的类，在Writing Your Own Classes章节！这里，你只需要下载需要的类文件就可以了。

现在，编译脚本：javafxc AddressBoox.fx，如果没有任何的输出，则说明编译成功。

Note:技术术语，这里的变量应该叫做实例变量。你可以把实例变量想象成每个对象都会有的内建的属性。事实上，“属性”这个词是在以前版本里面使用的概念。在OOP的世界里面”instance”和”object”是同义的！

-对象结构

对象结构很容易学习和使用！第一个单词（Address）指出了你要创建的对象类型。两个大括号定义了对象的内容。对象里的每个实例变量都给了一个初始值。(street, city, state, zip)

多个对象可以在一起创建：

Address {
     street: "1 Main Street";
     city: "Santa Clara";
     state: "CA";
     zip: "95050";
}  

Address {
     street: "200 Pine Street";
     city: "San Francisco";
     state: "CA";
     zip: "94101";
}

Note:当定义一个object literal，实例变量可以以空格，逗号和分号隔开！下面的定义也是正确的：

Address {
     street: "1 Main Street"
     city: "Santa Clara"
     state: "CA"
     zip: "95050"
}  

Address {
     street: "200 Pine Street",
     city: "San Francisco",
     state: "CA",
     zip: "94101",
}

教程里面将使用分号来作为分隔符。当定义一个方法的时候，分号是必须的。
你也可以将一个刚创建的对象和一个之前创建的对象关联。

def addressOne = Address {
     street: "1 Main Street";
     city: "Santa Clara";
     state: "CA";
     zip: "95050";
}  

def addressTwo = Address {
     street: "200 Pine Street";
     city: "San Francisco";
     state: "CA";
     zip: "94101";
}

或者将一个对象放置到另一个对象里面！

def customer = Customer {
     firstName: "John";
     lastName: "Doe";
     phoneNum: "(408) 555-1212";
     address: Address {
          street: "1 Main Street";
          city: "Santa Clara";
          state: "CA";
          zip: "95050";
     }
}

在最新版本的例子里面，Customer定义了几个新的变量。而里面的address变量持有了一个Address对象。这种格式很平常，看看程序怎么缩进的。通过缩进，Address的变量和Customer里面的变量能很容易的辨认出来！要编译这个例子，下载Customer.zip,解压缩到相同的目录，编译即可。

-执行实例方法

JavaFX提供高了很多行为为你提供便利！这些行为是通过对象的方法提供的。

你通过变量的名字（这里是customer），后面跟个”.”，紧接着是方法名称，这样的形式来执行实例方法。

def customer = Customer {
     firstName: "John";
     lastName: "Doe";
     phoneNum: "(408) 555-1212"
     address: Address {
          street: "1 Main Street";
          city: "Santa Clara";
          state: "CA";
          zip: "95050";
     }
}  

customer.printName();
customer.printPhoneNum();
customer.printAddress();

输出：

Name: John Doe
Phone: (408) 555-1212
Street: 1 Main Street
City: Santa Clara
State: CA
Zip: 95050

你现在可能想知道，这些方法是哪来的？我怎么知道一个对象里面包含那些变量和方法？如果你想使用一个类库，你需要API。API是一个格式良好的文档，列出了对象的变量和方法！这是唯一可以确定对象会提供什么方法的途径。在之后的教程里，在你要创建图形化程序的时候，你会学到如何的使用这个文档！

Lesson 4: Data Types

目录

- String
- Number and Integer
- Boolean
- Duration
- Void
- Null

-String

你已经看过很多String的例子了，但是还是让我们来自习的看看它还具有那些特性。String的定义，可以用双引号，也可以用单引号！

var s1 = 'Hello';
var s2 = "Hello";

不论单引号还是双引号都必须是对称的：你能在双引号里面嵌入单引号，或者在单引号里面嵌入双引号。以单引号定义的String和双引号定义的String之间没有任何的区别！

你还能在String里面插入表达式，表达式以”{}”包围。

def name = 'Joe';
var s = "Hello {name}"; // s = 'Hello Joe'

在表达式里面还能够再嵌入String：

def answer = true;
var s = "The answer is {if (answer) "Yes" else "No"}"; // s = 'The answer is Yes'

在运行时，编译器会根据answer的值来使用”Yes”或者”No”自动的替换掉表达式。

要连接多个String，使用多个大括号即可。

def one = "This example ";
def two = "joins two strings.";
def three = "{one}{two}";      // join string one and string two
println(three);                // 'This example joins two strings.'

-Number and Integer

Number 和Integer 接收数字类型的值，而很多情况下，你让编译器自己去猜测是什么类型就可以了。

def numOne = 1.0; // compiler will infer Number
def numTwo = 1;   // compiler will infer Integer

当然，你可以指定变量的类型：

def numOne : Number = 1.0;
def numTwo : Integer = 1;

两者的区别是Number是浮点型而Integer是整型。只有当你需要浮点型的时候才使用Number，否则建议使用Integer.

-Boolean

Boolean 有两个值：true 和 false。当需要设置程序的特定状态时，使用此变量类型。

var isAsleep = true;

或者是一个条件表达式：

if (isAsleep) {
     wakeUp();
}

当()里面的值为true时，{}里面的代码将被执行。关于更多内容，请看Expressions lesson

-Duration

Duration 类型表示一系列的时间：

5ms; // 5 milliseconds
10s; // 10 seconds
30m; // 30 minutes
1h; // 1 hour

Durations被解释为时间—比如，5m就是5分钟。时间在animation 里将被频繁的使用。（请参看Building GUI Applications with JavaFX里面的Creating Animated Objects章节）

-Void

Void是被用来说明一个方法没有返回值的。

function printMe() : Void {
     println("I don't return anything!");
}

下面是等价的，省略了返回值

function printMe() {
     println("I don't return anything!");
}

JavaFX里面的关键字Void，以大写V开头。如果你熟悉Java语言里面的void类型，请特别注意！

Note:在JavaFX里面，一切都是表达式。在第二个printMe里面返回值依然是Void，编译器能自动识别。在Expressions lesson你将会了解更多内容。

-Null

Null是一个特殊的值，表示一个变量没有一个正常值。Null不同于数字0或者空字符串，所以当Null和数字0或空字符串比较时，是不等的。

null关键字可以用来做比较，如下所示：

function checkArg(arg1: Address) {
     if(arg1 == null) {
          println("I received a null argument.");
     } else {
          println("The argument has a value.");
     }
}

这个方法接收一个参数，判断是否为null.

Lesson 5: Sequences

目录

- 创建序列
- 使用布尔表达式创建序列
- 访问序列的元素
- 向序列里插入项
- 从序列里删除项
- 倒序序列里的项
- 比较序列
- 使用序列片段

-创建序列

除了5种最基本的数据类型。JavaFX脚本语言还提供了链式数据结构。序列表示一组有序的对象，序列里面的对象称为项。序列以‘［］’定义，每个项之间以逗号隔开。

一种创建序列的方法就是直接列出序列里面的项即可。每一个元素以逗号隔开，且放在[]之间。如下：

var weekDays = ["Mon","Tue","Wed","Thu","Fri"];

声明一个序列然后赋给weekDays变量。编译器知道我们是要创建字符串序列，因为每个项都是定义为字符串类型。 如果序列里面声明的是整数类型（var nums = [1,2,3];）编译器知道我们需要的是整数序列。

你也可以给序列一个特定的类型。

var weekDays: String[] = ["Mon","Tue","Wed","Thu","Fri"];

这么定义，告诉编译器weekDays接受一系列的String

序列里面还能定义序列

var days = [weekDays, ["Sat","Sun"]];

在这样的情况下，编译器会自动的平坦化序列，即转化为如下形式：

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

还有一种简短的方法来创建连续的数字。要创建1到100的序列，使用如下方法：

var nums = [1..100];

-使用布尔表达式创建序列

你能使用布尔表达式或者断言（predicate）来声明一个已存在的序列的子序列。例如，对于下面的序列：

var nums = [1,2,3,4,5];

接着，以第一个序列里面的项为基础，创建第二个序列，此序列只包含大于2的项。创建方法如下：

var numsGreaterThanTwo = nums[n | n > 2];

上面的表达式可以用语言描述为：“从num序列里选出所有大于2的项，然后将这些项赋给numsGreaterThanTwo序列”。(”select all items from the num sequence where the value of an item is greater than 2 and assign those items to a new sequence called numsGreaterThanTwo),”where”后面的
“the value of an item is greater than 2″就是断言（predicate）

在这段代码里面：

1. 新创建的序列存放在numsGreaterThanTwo里面。

2. 代码： nums[n | n > 2];指定了源序列。在例子里面，nums就是已经存在的序列。

3. 遍历num里面的所有项，当表达式为true的时候，就返回这个项，由返回的所有项，创建一个新的序列。

4. 符号 “|”是用来分割变量n和后面的代码的。

5. 代码: nums[n | n > 2];定义了一个布尔表达式，它是是否要把原来序列里面的项拷贝到现在的序列里面去的一个衡量标准。

-访问序列元素

序列里的项可以通过下标来访问，从0开始。要访问一个元素，以序列的名字，后面跟”［元素的索引］”即可:

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

println(days[0]);
println(days[1]);
println(days[2]);
println(days[3]);
println(days[4]);
println(days[5]);
println(days[6]);

打印如下:

Mon
Tue
Wed
Thu
Fri
Sat
Sun

你还可以使用sizeof操作符后面跟上序列的名字来得到序列的长度：

sizeof days

下面的代码，打印7：

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
println(sizeof days);

-向Sequence里插入项

insert关键字允许你向序列里的一个特定元素的前面或后面插入一个元素。

Note:事实上，序列是不变的。这意味着序列一旦被创建就不会改变。举个例子，当你插入或删除一项时，在此操作后，会创建一个新的序列并且这个序列会被赋给原来那个变量。

让我们来重新创建days序列,来证明一下：

var days = ["Mon"];

这里，这个sequence只包含一个元素 “Mon”.

我们可以使用insert和into关键字在序列的最后插入”Tue”。

insert "Tue" into days;

类似的，我们添加 “Fri”, “Sat”和”Sun”。

insert "Fri" into days;
insert "Sat" into days;
insert "Sun" into days;

现在序列就包含了： “Mon”, “Tue”, “Fri”, “Sat”, and “Sun”.

我们还可以使用insert和before关键字在给定的索引所指定的元素前面插入一项。记住，索引以0开始，所以”Fri”的索引是2.所以我们能够像下面这样在”Fri”前面插入”Thu”.

insert "Thu" before days[2];

现在序列包含了: “Mon”, “Tue”, “Thu”, “Fri”, “Sat”, and “Sun”.

在”Wed”后面插入”Tue”,我们能使用insert和after关键字:

insert "wed" after days[1];

现在序列包含了一周的所有天： “Mon”, “Tue”, “Wed”, “Thu”, “Fri”, “Sat”, and “Sun”.

-从序列里删除项

delete和from关键字使得从序列里面删除项变得很简单。

delete "Sun" from days;

现在序列包含：”Mon”, “Tue”, “Wed”, “Thu”, “Fri”, and “Sat”.

你还可以删除一个特定索引的元素。下面的代码将从序列里面删除”Mon”(记住”Mon”是第一个元素，他的索引是0)

delete days[0];

要删除序列里的所有项，使用delete跟上序列的名字即可：

delete days;

注意，delete只是把项从序列里面移走；它不会删除days这个变量。你还能够访问days变量，并向里面添加值。

-倒序序列里的项

你可以使用reverse操作符来倒序序列:

var nums = [1..5];
reverse nums; // returns [5, 4, 3, 2, 1]

-比较序列

有时你可能会要比较序列是否相等。序列是按值来比较的：如果长度相同，里面的项也相同，那么他们就是相等的。

让我们来测试一下：

var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5];
println(seq1 == seq2);

表达式seq1 == seq2将为true，因为序列拥有相同个数的项，且每个项的值都相同。所以，这段代码将打印true.

修改其中一个序列的项的个数，他们就不相同了：

var seq1 = [1,2,3,4,5];
var seq2 = [1,2,3,4,5,6];
println(seq1 == seq2);

这里输出”flase”，因为第二个序列比第一个序列长，所以两序列不相等。

我们还能通过修改项的值来使两个序列不相等，即使两个序列的长度仍然相等：

var seq1 = [1,2,3,4,5];
var seq2 = [1,3,2,4,5];
println(seq1 == seq2);

代码将会还是打印”false”，因为两个序列不等。

-使用序列片段

序列片段提供访问序列的一部分的功能。

seq[a..b]

这段语法将访问索引a和索引b之间的所有的元素。下面的脚本创建了一个只包含”Sat”和”Sun”的表示周末的序列。

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
var weekend = days[5..6];

seq[a..<b]

在索引a和b之间，且靠近b的地方使用”<”，将不包含索引b。我们可以用这个创建”Mon” 到”Fri”的表示工作日的序列。

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
var weekdays = days[0..<5];

seq[a..]

省略第二个索引，你能够访问从索引a到最后的所有项！举同样的例子，我们可以像下面这样创建表示周末的序列：

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

seq[a..<]

最后，你能够使用”<”而不需要第二个索引，来访问序列a后面的，除了最后一项之外的所有项。

var days = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
var days2 = days[0..<];

这里创建一个包含从 “Mon” 到 “Sat”的序列。