类型别名

1
2
3
4
typealias newname = type

typealis Feet = Int
var feet: Feet = 1

变量

1
2
3
var variableName = <initial value>

var name = "ban"
  • 输出
1
println("\(name)")

可选(Optionals)类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
Swift 的可选（Optional）类型，用于处理值缺失的情况。可选表示"那儿有一个值，并且它等于 x "或者"那儿没有值"。
Swfit语言定义后缀？作为命名类型Optional的简写，换句话说，以下两种声明是相等的：

var optionalInteger: Int?
var optionalInteger: Optional<Int>
在这两种情况下，变量 optionalInteger 都是可选整数类型。注意，在类型和 ?之间没有空格。

Optional 是一个含有两种情况的枚举，None 和 Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。当声明一个可选类型的时候，要确保用括号给 ? 操作符一个合适的范围。例如，声明可选整数数组，应该写成 (Int[])? 写成 Int[]? 会报错。

当你声明一个可选变量或者可选属性的时候没有提供初始值，它的值会默认为 nil。

可选项遵照 LogicValue 协议，因此可以出现在布尔环境中。在这种情况下，如果可选类型T?包含类型为T的任何值（也就是说它的值是 Optional.Some(T) ），这个可选类型等于 true，反之为 false。

如果一个可选类型的实例包含一个值，你可以用后缀操作符 ！来访问这个值，如下所示：

optionalInteger = 42
optionalInteger! // 42
使用操作符！去获取值为nil的可选变量会有运行时错误。

你可以用可选链接和可选绑定选择性执行可选表达式上的操作。如果值为nil，任何操作都不会执行，也不会有运行报错。

让我们来详细看下以下实例来了解 Swift 中可选类型的应用:

import Cocoa
var myString:String? = nil
if myString != nil {
    print(myString)
}else{
    print("字符串为 nil")
}
以上程序执行结果为：
字符串为 nil

可选类型类似于Objective-C中指针的nil值，但是nil只对类(class)有用，而可选类型对所有的类型都可用，并且更安全。

强制解析
当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个感叹号表示"我知道这个可选有值，请使用它。"这被称为可选值的强制解析（forced unwrapping）。

实例如下：

import Cocoa
var myString:String?
myString = "Hello, Swift!"
if myString != nil {
   print(myString)
}else{
   print("myString 值为 nil")
}
以上程序执行结果为：

Optional("Hello, Swift!")
强制解析可选值，使用感叹号（!）：

import Cocoa
var myString:String?
myString = "Hello, Swift!"
if myString != nil {
   // 强制解析
   print( myString! )
}else{
   print("myString 值为 nil")
}
以上程序执行结果为：

Hello, Swift!

注意：
使用!来获取一个不存在的可选值会导致运行时错误。使用!来强制解析值之前，一定要确定可选包含一个非nil的值。

自动解析
你可以在声明可选变量时使用感叹号（!）替换问号（?）。这样可选变量在使用时就不需要再加一个感叹号（!）来获取值，它会自动解析。

实例如下：

import Cocoa
var myString:String!
myString = "Hello, Swift!"
if myString != nil {
   print(myString)
}else{
   print("myString 值为 nil")
}
以上程序执行结果为：

Hello, Swift!
可选绑定
使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。

像下面这样在if语句中写一个可选绑定：

if let constantName = someOptional {
    statements
}
让我们来看下一个简单的可选绑定实例：

import Cocoa

var myString:String?

myString = "Hello, Swift!"

if let yourString = myString {
   print("你的字符串值为 - \(yourString)")
}else{
   print("你的字符串没有值")
}
以上程序执行结果为：

你的字符串值为 - Hello, Swift!

常量

1
2
let constantName = <initial value>
let name = "ban"
  • 类型标注
1
2
var constantName:<data type> = <optional initial value>
var name: String = "ban"
  • Unicode 支持
1
let 名字 = "ban"

条件语句

  • if
1
2
3
4
5
6
7
8
if boolean_expression {
   /* 如果布尔表达式为真将执行的语句 */
}

var varA:Int = 10;
if varA < 20 {
    print("varA 小于 20");
}
  • if else
1
2
3
4
5
6
7
8
9
if boolean_expression_1 {
   /* 如果 boolean_expression_1 表达式为 true 则执行该语句 */
} else if boolean_expression_2 {
   /* 如果 boolean_expression_2 表达式为 true 则执行该语句 */
} else if boolean_expression_3 {
   /* 如果 boolean_expression_3 表达式为 true 则执行该语句 */
} else {
   /* 如果以上所有条件表达式都不为 true 则执行该语句 */
}
  • 嵌套If
1
2
3
4
5
6
if boolean_expression_1 {
   /* 当 boolean_expression_1 表达式 true 时执行 */
   if boolean_expression_2 {
      /* 当 boolean_expression_1 表达式 true 时执行 */
   }
}
  • switch
1
2
3
4
5
6
7
8
9
10
switch expression {
   case expression1  :
      statement(s)
      fallthrough /* 可选 */
   case expression2, expression3  :
      statement(s)
      fallthrough /* 可选 */
   default : /* 可选 */
      statement(s);
}

注意：在大多数语言中，switch 语句块中，case 要紧跟 break，否则 case 之后的语句会顺序运行，而在 Swift 语言中，默认是不会执行下去的，switch 也会终止。如果你想在 Swift 中让 case 之后的语句会按顺序继续运行，则需要使用 fallthrough 语句。

循环

  • for in
1
2
3
for index in var {
   循环体
}
1
2
3
for index in 1...5 {
    print("\(index) 乘于 5 为：\(index * 5)")
}

闭区间操作符（…）

1
2
3
4
var someInts:[Int] = [10, 20, 30]
for index in someInts {
   print( "index 的值为 \(index)")
}
  • while
1
2
3
4
while condition
{
   statement(s)
}

数字 0, 字符串 ‘0’ 和 “”, 空的 list(), 及未定义的变量都为 false ，其他的则都为 true。

  • repeat…while
1
2
3
4
repeat
{
   statement(s);
}while( condition );

类似 do..while

字符串

  • 空字符串
1
2
var name = ""
var name = String()
  • 字符串拼接
1
2
var name = "ban"
name += "dianhong"

字符串常量不能被修改。即使用let声明的。

  • 字符串长度
1
\(string.count)
1
2
var name = "ban"
println("\(name.count)")
  • 字符串内容比较
1
stringA == stringB
  • Unicode字符串
1
2
stringA.utf8
stringA.utf16
  • 字符串运算
1
2
3
4
5
6
7
8
9
10
11
12
13
isEmpty 判断字符串是否为空，返回布尔值
hasPrefix(prefix: String) 检查字符串是否拥有特定前缀
hasSuffix(suffix: String) 检查字符串是否拥有特定后缀。
Int(String) 转换字符串数字为整型
String.count 计算字符串的长度
utf8 可以通过遍历 String 的 utf8 属性来访问它的 UTF-8 编码
utf16 可以通过遍历 String 的 utf8 属性来访问它的 utf16 编码
unicodeScalars 可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量编码.
+ 连接两个字符串，并返回一个新的字符串
+= 连接操作符两边的字符串并将新字符串赋值给左边的操作符变量
== 判断两个字符串是否相等
< 比较两个字符串，对两个字符串的字母逐一比较。
!= 比较两个字符串是否不相等。

字符(Character)

字符只有一个

字符不能为空

  • 字符串连接字符
1
2
3
var varA:String = "Hello "
let varB:Character = "G"
varA.append( varB )

占位符

_ 下划线，系统会忽略，可以用来做占位符。

1
2
3
for _ in 1...8 {
	print("我爱你")
}