[Swift的5个特性]

例如，在消费者方面像Ruby这样的脚本语言已经被广泛采用，这很大程度上得益于它
干净的语法。在企业领域，具有类型推理能力的强类型（类型安全的）语言更受欢迎，为了将函数式编程语言所具有的函数即对象、Lambda表达式等经典特性
引入进来，C#和Java（或者Scala）等语言都做出了大量的努力。Objective-C一直都缺少这类东西，例如干净的语法（和语法糖），类型推
理。而Swift正是为了填补这个空白。

从语言的角度看，Swift是非常了不起的。苹果借鉴了Scala和C#这些现代语言的优点，非常完美地融合了面向对象和函数式编程范式。但是说Swift是一门函数式语言是一种极大的延伸。下面就让我
们看看Swift最具杀伤力的5个特性。

#1: 语法糖

从语法上讲Swift非常华丽。简单性方面的其他例子包括字符串插入，以及语言对数组和循环处理的支持。

字符串插入

1 2 3 4 5 6 7

var message = "Hello World" println("The message is \(message)" )//The message is Hello world var a = 1, b = 2" println(The sum is \(a + b)") //The sum is 3

循环

1 2 3 4

var length = 10 for i in 0..<length { //Do something with i }

数组

1 2	var list = ["a", "b"] list += ["c", "d"]

以上仅是Swift为简单性提供语言支持的一部分示例。需要注意的是你依然可以使用Array类的“append”方法连接数组，而苹果之所以走了额外的一英里将其构建为语言的一部分目的是为了展示他们设计Swift的目标。

Playground执行你在开发环境中输入的所有内容，提供与变量值、函数调
用返回值以及特定代码块被执行的次数相关的详细信息。

下面的图片展示了实时预览功能：



#2: 函数是一等对象

越来越多的语言将函数作为一等公民并支持高级函数。例如，最近发布的Java 8引入了Lambda表达式。它的理念很简单，就是让函数可以接受函数类型的参数，同时也可以将函数作为返回值。理念的简单性奠定了它强大的基础，因为这样支持更多的抽象。例如，我们可以将一个“过滤（filter）”函数应用到一个数组，该过滤函数接受数组中的每一个条目作为参数，通过特定的标准对条目
进行判定从而完成对给定数组的过滤。使用更加通用的方法的关键是能够接受函数类型的参数。下面就让我们看看定义函数的语法。

Swift定义函数的语法与传统的Haskell这样的函数型语言相似，但并不完全一样。箭头（->）的左边是参数以及参数的类型，右边是返回值类型。在本文的示例中，我们想要过滤一个数字列表，因而基于一个给定的数字我们会返回一个Bool类型。在这种情况下，函数看起来可能是这样的：

1	(Item:Int) -> Bool

这段代码的意思是接受一个Int类型的参数，返回一个Bool类型的值。很显然，你可以包含多个参数，但是不太明显的是，你还可以返回多个值，而这不需要创建一个容器对象。在后面的示例中，函数会返回一个元组
。

一个过滤整数的函数定义可能是这样：

1 2 3

funct bigNumbersOnly (item:Int) -> Bool { return item > 3 }

现在，我们已经创建了自己的过滤函数，下面让我们看看可以接受函数参数类型的“filter”函数。

var numbers = [1, 2, 3, 4, 5]

var bigOnes = numbers.filter(bigNumbersOnly)

或者我们也可以将函数赋值给某个变量，稍后再使用它：

1 2 3 4 5 6 7

//define two variables of type functionvar biggies = {(item:Int) -> Bool in return item > 3 } var threes = {(item:Int) -> Bool in return item == 3 } //decide which one to apply at runtime var result = numbers.filter(onlyThrees ? threes : biggies)

当今，将函数作为对象，让用户能够像使用参数那样引用、传递函数已经成为一种优美的标准。而Swift实现方式的简洁性依然是一个值得称道的地方，这一核心概念配合类型推理可以让你事半功倍。

#3:强类型与类型推理

在企业开发领域，我们非常习惯于使用强类型（或者说类型安全的）语言。强类型语言通常会给我们带来一点额外的自信，因为它能够在编译时进行错误检查，如果这些语言也能够支持类型推理那么将会是一种非常好的体验。例如，可以这样：

1 2 3 4 5

//Without Type inference var x:String = "bar" //With Type inference var y = "bar

注意，第二行的语句并没有声明变量的类型。因为Swift知道“bar”是一个字符串，所以我们并不需要显式地定义它的类型，当然我们也可以指定，正如第一个语句那样。这看起来好像并没有特别大的作用，但是如果推理的是函数的类型那么它就会变得十分有趣。

那么如果不使用类型我们应该如何定义之前例子中的函数呢？下面的代码展现了Swift的实现：

1 2	//$0 will map to the first parameter, $1 to the second... var result = numbers.filter({ return $0 == 3})

没有比这更简洁的了！如果你的参数不止一个，同时想要通过名字引用参数，那么可以这样做：

{a, b in return a > b }

#4 泛型

Swift提供的另一个非常便利的特性是泛型。在企业开发领域，泛型首先被引入到了C#中，在获得了大量的关注之后Java也引入了该特性。使用泛型可以让开发者消除类型转换，因为编译器能够运行特定的类型检查，而对于不支持泛型的语言而言这是无法做到的。虽然刚开始将泛型引入C#的时候确实产生了
一些争论，但是现在它已经被C#和Java社区所普遍接受。

泛型提供了一种方式可以让我们推迟类型的定义，通常（但不限于）是参数和返回值的类型。虽然它听起来很复杂，但是实际上通过一个简单的示例我们就能非常容易地理解它。

//At the moment of creating this function

//I am not defining what T is. The actual

//Type of T will be deferred to the call

//of the doNothing function.

func doNothing (item:T) -> T {

return item

}

//When I call doNothing, I am implicitly

//setting the type of T to the Type of the

//parameter I am sending. In this case,

//an Array.

//Notice how the compiler knows, that the

//return type is an Array.

doNothing([1, 2, 3]).count

虽然上面并不是一个真实的例子，但是通过它我们能够看到在编译时确定数组内部元素类型的便利。下面是一个更简单的示例，注意编译器是如何知道数组是包含字符串类型的：

var list = ["hello", "world"]

list[0].uppercaseString //HELLO

泛型的使用范围并没有被限定于参数，我们也可以定义泛型类、枚举和结构。事实上，在前面的示例中，list的类型是Array<String>。

你可能会将Swift中的泛型与Objective-C中的协议类比，虽然它们的语法非常相似，但是概念是非常不同的。Objective-C并不
支持泛型。协议提供了一种方式去声明一个确定的实现符合某个消息契约，但是契约必须预先指定。例如，使用协议你并不能强迫数组中的所有条目都是同一类型的
（无论是什么类型），但是使用泛型能够做到。

除了概念上的不同之外，Swift并不支持协议，就像Objective-C不支持泛型一样。

#5 元组

元组是非常简单的概念，你可以定义一个有序的值组。当你需要将多个值作为一个参数来回传递、或者被调用的函数需要返回多个值的时候元组会非常有用。元组并不需要我们为它的值定义任何类型，编译时会完成所有的类型推理和类型检查工作。定义元组的语法如下：

(1, "Two", ["Three"])

在上面的例子中，我们创建了一个带有三个值的元组，第一个是一个整数，第二个是字符串，第三个是一个字符串类型的数组。乍一看这很像一个数组，但概念完全不同。你不能从一个元组中删除或者向里追加元素，同时注意编译器是如何知道每一个值的确切类型的：

你可以通过元素在元组内部的位置引用它的值，正如图片所提示的那样；或者你也可以为每一个值指定一个名称。如果一个函数需要返回几个值，那么这是非常方便的，同时它也能让我们避免定义那些特定于某个函数的类或者结构。下面让我们看一个这样的例子：

func info(items:[Int]) -> (avg:Int, min:Int, max:Int) {

var sum = items.reduce(0, { $0 + $1 })

var min = items.reduce(Int.max, { $0 > $1 ? $1 : $0})

var max = items.reduce(Int.min, { $0 < $1 ? $1 : $0})

return (sum / items.count, min, max)

}

var result = info([1, 2, 3, 4, 5, 6])

result.avg //3

result.min //1

result.max //6

元组提供了一种非常简单的使用多个值的方法，让我们省去了定义一个特定的类或者结构的额外工作。

还有更多…

除了上面介绍的特性之外Swift还有很多其他的优秀特性值得我们一看，例如属性观察器、可选链接以及扩展。

强类型和类型推理特性将会让它非常适合于企业开发.