Swift 语言

Swift 中的类型


Swift 中的类型可以分为 3 组, 结构体、类和枚举。这三个都有:

  • 属性: 和类型关联的值
  • 初始化函数: 初始化类型的实例的代码
  • 实例方法: 在该类型的实例上调用的指定函数
  • 类方法或静态方法: 在类型自身上调用的指定函数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Structs

struct myStruct {
// properties
// initializers
// methods
}

// Enumerations
enum MyEnum {
// properties
// initializers
// methods
}

// Classes
class Myclass: SuperClass {
// properties
// initializers
// methods
}

Swift 的结构体和枚举比其它语言中的都要强大, 还能遵守协议并且能被扩展。

集合类型


数组类型写作 Array<T>, T是数组将会包含的元素的类型。数组能包含任意类型的元素: 标准类型、结构体或类。

1
2
3
var hasPet: Bool
var arrayOfInts: Array<Int> // 声明一个整数数组
var arrayOfInts: [Int] // 简写语法

字典的键可以是任意类型, 但是必须是唯一的。也就是说键必须是可哈希的。基本 Swift 类型例如 IntFloatCharacterString 都是可哈希的。键值可以是任意类型。

1
2
var dictionaryOfString: Dictionary<String, String>  // 正式写法
var dictionaryOfString: [String, String] // 简写形式

集合的成员必须是唯一的和可哈希的。

1
var winningLotteryNumbers: Set<Int>

初始化函数


创建实例的一种方式是使用字面量; 另一种方式是使用类型的初始化函数。使用类型名后跟一对儿圆括号(或加上参数)语法来创建类型的实例。

1
2
3
let emptyString = Stirng()          // ""
let emptyArrayOgInts = [Int]() // 0 elements
let emptySetOfFloats = Set<Float>() // 0 elements

其它类型有默认值:

1
2
let defaultNumber = Int()  // 0 
let defaultBool = Bool() // false

类型可以有多个初始化函数。例如, String 有一个初始化函数接收一个 Int 类型的参数并基于该参数创建一个字符串。

1
2
let number = 42 // 42
let meanningOfLift = String(number) // "42"

使用 Set 初始化函数接收一个数组字面量来创建一个set:

1
let availableRooms = Set([205, 411, 412])  // {412, 205, 411}

Float 有几个初始化函数。不带参数的初始化函数返回带有默认值的Float实例。还有一个初始化函数接收一个浮点数字面量。

1
2
let defaultFloat = Float()          // 0.0 
let floatFromLiteral = Float(3.14) // 3.14

如果你为浮点数字面量使用类型推断, 那么类型默认为Double

1
let  easyPi = 3.14

Optionals


Swift 的类型可以是 optional, 即在类型的名字的后面加上一个 ?

1
2
3
var anOptionalFloat: Float?
var anOptionalArrayOfStrings: [String]?
var anOptionalArrayOfOptionalStrings: [String?]?

optional 的值要么是一个指定的实例要么是 nil。

for…in 循环


添加迭代约束


1
2
3
4
for i in 1...10 where i % 2 == 0 {
// 只迭代偶数
print("\(i) 是偶数")
}

where 可以换行:

1
2
3
4
for word in ["Lorem", "ipsum", "dolor", "sit", "amet", "consectetur"]
where word.characters.count > 5 {
print(word, "is a long word")
}

where 从句可以足够复杂:

1
2
3
for i in 1...50 where i > 20 && i < 30 && (i % 2 == 0) {
print("\(i) 是偶数")
}

处理 non-nil 项


Optionals 是很多 Swift 开发场景中的自然输出, 例如在集合上映射一个函数或检索潜在的可失败资产。

你可以使用 Swift2的 .Somecase 简写来遍历那些不是 nil 值的项:

1
2
3
4
let items: [String?] = [nil, nil, "Hello", nil, "World"]
for case let item? in items {
print(item)
}

你绑定的项在 for 循环子句中被解包, 所以你可以直接使用它。

条件转换


Swift 允许你使用条件转换来过滤属于指定父类的异种对象的列表。这儿有个提取 UIView 的例子:

1
2
3
4
5
6
7
8
let mySwitch = UISwitch()
let myView = UIView()
let myDate = NSDate()

let myItems: [NSObject] = [mySwitch, myDate, myView]
for case let item as UIView in myItems {
print(item.frame)
}

这个方法在协议身上也适用。这儿有个超不自然的 case 来描述这个方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
protocol MyCustomProtocol {
var frame: CGRect {get}
}
struct Bar {}
struct Foo: MyCustomProtocol {
let frame: CGRect = .zero
}
extension UIView: MyCustomProtocol {}

let otherItems = [Bar(), Foo(), UIView()] as [Any]
for case let item as MyCustomProtocol in otherItems {
print(item.frame)
}

for var


1
2
3
4
5
6
for var x in 1...3 {
x += 3
print(x)
}

// 4,5,6

Swift 3 消除了所有的 for-var 结构。

替换

1
for var x in 1...5 { ... }

1
for x in 1...5 { var x = x; ... }