Swift 语言入门学习笔记

变量与常量

Swift 使用 var 声明变量,使用 let 声明常量。常量是不会被修改的量,只能被赋值一次。

1
2
var foo = 1
let bar = 1

Swift 是强静态类型的语言,具有类型推论(Type Inference)的特性,即在编译期自动推导出值的数据类型。简单的说,当你将一个变量赋值为 1 时,Swift 便认为它是整数型变量,此后修改它的值为其他类型会报错。

1
2
var foo = 1
foo = 'Hello' // 错误

在变量声明时可以使用 : 显式地声明它的类型。

1
let foo: String = 'Hello World!'

使用 , 可以在一个语句中声明多个变量。

1
2
let foo = 1, bar = 2
let baz, qux: Int

数据类型

Swift 中的数据类型包括整型 Int,浮点型 FloatDouble,布尔型 Bool,字符串 String 以及元组 Tuple

整型

声明一个整型。

1
2
let foo = 1 // 普通整型
let bar: UInt = 1 // 无符号整型

为了便于阅读,可以使用 _ 任意分隔数字。下划线并无实际意义,foo 的值仍是 10000000

1
let foo = 10_000_000

浮点型

Swift 中的浮点型包括 FloatDouble 两种类型。Double 的精度更高,能够容纳更多小数位数。

声明一个浮点数,默认为 Double 类型。

1
let foo = 1.23

显式地声明一个浮点数为 FloatDouble 类型。

1
2
let foo: Float = 1.23
let bar: Double = 1.23

浮点数的小数部分同样支持用 _ 分隔的表示方式。

1
let foo = 0.123_456

布尔型

声明一个布尔型。

1
2
let foo = true
let bar = false

字符串

在 Swift 中,字符串只能使用双引号表示。

声明一个字符串。

1
let foo = "Hello"

使用 + 拼接字符串。

1
print("He" + "llo") // Hello

使用 \() 在字符串中包含变量。

1
2
let foo = "Swift"
print("Hello, \(foo)!") // Hello, Swift!

使用 isEmpty 属性判断一个字符是否为空。

1
2
let string = ""
print(string.isEmpty) // true

元组

元组是由多个值组成的复合值,其元素可以是任意类型,且彼此间不必是相同类型。

创建一个普通元组 foo 和带元素命名的 bar。元组 foo 使用从 0 开始的索引访问元素,元组 bar 使用元素名称访问元素。两者分别类似于 JavaScript 中的数组和对象。

1
2
let foo = (1, 2)
let bar = (a: 1, b: 2)

显式地指定元组中每个元素的类型。

1
2
let foo: (Int, Float) = (1, 1.0)
let bar: (a: Int, b: Float) = (a: 1, b: 1.0)

使用索引或名称访问元组中的元素。

1
2
let foo = (a: 1, b: 2)
print(foo.0, foo.a) // 1 1

将一个普通元组分解成独立的变量或常量。

1
2
3
let foo = (1, 2)
let (x, y) = foo
print(x, y) // 1 2

分解一个命名元组,并且使用 _ 忽略用不到的元素。

1
2
3
let foo = (a: 1, b: 2)
let (a, _) = foo
print(a) // 1

类型转换

Swift 不自动转换数据类型。两个不同数据类型计算时,需要显式地强制转换为相同的类型。举个栗子,当整数和小数相加时,使用 Int 函数将浮点数强制转换为整数。

1
2
3
let foo = 1
let bar = 1.0
let baz = foo + Int(bar)

运算符

Swift 中的运算符和其他语言,如 Java、JavaScript 基本一致。区间运算符 是 Swift 特有的运算符。

基本运算符

基本运算符用于数值的计算,常用的包括加减乘除及取余运算。

1
print(1 + 2 - 3 * 4 / 5 % 6) // 1

由于 Swift 是一个强类型的语言 —— 整型除以整型的结果仍是整型,所以 1 除以 2 的结果是 0,而不是 0.5

1
2
print(1 / 2) // 0
print(1.0 / 2.0) // 0.5

Swift 2.2 起废弃了自增运算符 ++ 和自减运算符 -- ,应使用 +=-= 实现。

1
2
foo++  // 错误
foo += 1 // 正确 等同于 foo = foo + 1

比较运算符

比较运算符比较两个值,然后返回一个布尔值。二者关系成立时返回 true ,关系不成立时返回 false 。比较运算符一般用于条件判断。与其他常见语言并无二致,Swift 中的比较运算符包括相等 == 和不等 != ,大于 > 和大于等于 >= ,小于 < 和小于等于 <=

1
2
1 == 2 // false
1 <= 2 // true

逻辑运算符

逻辑运算符包括逻辑非 !,逻辑与 && 和逻辑或 || ,常用于条件判断。

1
2
3
4
5
let foo = true
let bar = false
!foo // false,foo 不为真时返回 true。
foo && bar // false,foo、bar 皆为真时返回 true。
foo || bar // false,foo、bar 中有一个为真时返回 true。

三元运算符

三元运算符判断一个条件表达式,true 时执行 : 前面的表达式,否则执行 : 后面的表达式。

1
2
let raining = true
let wheather = raining ? "Rainy" : "Sunny" // Rainy

区间运算符

区间运算符用于表示一个整数的集合。

1
2
a...b // 相当于数学上的 [a, b]
a..<b // 相当于数学上的 [a, b)

函数

使用 func 声明函数。

1
2
3
4
5
6
let text = "This is a log."
func log(msg: String) {
print(msg)
}
log(msg: text)
// This is a log.

控制流

Swift 4 提供了 ifswitch 条件语句,以及 for-inwhilerepeat-while 循环语句。

  • 使用 if / switch 制造条件。
  • 使用 for-in / while / repeat-while 制造循环。
  • Swift 3 起废弃了常见的 C 语言风格的 for 循环。
  • 同样支持使用 break 结束循环,使用 continue 结束当前循环并进入下一次循环。

if 语句

if 语句的条件不需要用 () 包裹。即使只有一个语句,{} 也不能省略。

1
2
3
4
5
6
7
let wheather = "rainy"
if wheather == "rainy" {
print("It will rain today.");
} else {
print("It won't rain today.");
}
// It will rain today.

guard 语句

在使用其他语言的过程中,经常会遇到嵌套 if 语句的情况,影响代码的可读性。

Swift 中的 guard 语句解决了这个问题。guard 语句判断一个条件,只有条件成立时才能执行 guard 语句之后的代码,否则执行 else 子句中的代码。我们可以优雅的把不符合继续执行的条件放在一个方法的前面处理。

1
2
3
4
5
6
7
8
9
let wheather = "sunny"
func todo() {
guard wheather == "sunny" else {
return
}
print("Go sports.")
}
todo()
// Go sports.

switch 语句

Swift 中的 switch 语句只会执行一个 case ,所以不需要像其他语言那样使用 break 手动结束循环。另外,一个 case 可以对应多个值,使用逗号分隔。

使用 switch 语句判断一周中的某一天应该做什么事。

1
2
3
4
5
6
7
8
9
10
11
let day = "Monday"
switch day {
case "Friday":
print("Go shopping.")
break // 冗余
case "Saturday", "Sunday":
print("Go sports.")
default:
print("Go to work.")
}
// Go to work.

使用 fallthrough 关键字可以在循环结束后继续执行下一个 case 的代码块。

1
2
3
4
5
6
7
8
9
let num = true
switch num {
case true:
print("true", terminator: " ")
fallthrough
case false:
print("false", terminator: " ")
}
// true false

case 可以使用 where 子句进一步限定条件。例如,判断一个整数是否介于 5 到 10 之间,并且是一个偶数。

1
2
3
4
5
6
7
8
let num = 8
switch num {
case 5...10 where num % 2 == 0 :
print(true)
default:
print(false)
}
// true

for-in 循环

遍历一个区间,计算 1-100 的累加结果。

1
2
3
4
5
var sum = 0
for i in 1...100 {
sum += i
}
print(sum) // 5050

遍历一个数组,打印一个拼接的字符串。

1
2
3
4
5
var string = ""
for item in ["Hello", "World", "Swift"] {
string += item
}
print(string) // HelloWorldSwift

while 循环

打印 1-10 之间的整数。

1
2
3
4
5
6
var i = 1
while i <= 10 {
print(i, terminator: " ")
i += 1
}
// 1 2 3 4 5 6 7 8 9 10

repeat-while 循环

repeat-while 类似其他语言中的 do-while 循环,即先执行代码,再判断是否符合条件。如果条件成立,继续循环,否则跳出循环。repeat-while 中的循环体至少会执行一次。

使用 repeat-while 语句打印 1-10 之间的整数。

1
2
3
4
5
6
var i = 1
repeat {
print(i, terminator: " ")
i += 1
} while i <= 10
// 1 2 3 4 5 6 7 8 9 10