常量和变量

一次声明多个变量

1
2
3
var x = 0.0, y = 0.0, z = 0.0

var red, green, blue: Double

变量名

Swift的变量名可以是任何的Unicode字符, 如: 中文, Emoji表情等都可以是变量名。

常量与变量名不能包含空格符,数学符号,箭头,保留的(或者非法的)Unicode 码位,连线与制表符。也不能以数字开头, 但是可以在常量与变量名的其他地方包含数字。

1
2
3
let π = 3.14159
let  = "你好世界"
let 🐶🐮 = "dogcow”

print函数

1
2
3
4
5
6
let x=1 ,y = 2, z=3
let name = "John"
print(x, y, z) // 
print(x, y, z, separator: ":")  // 
print(x, y, z, separator: ":", terminator: ";") //
print("My name is \(name)")  // 

注释

1
2
3
4
5
// 

/*

*/

分号

swift语法中,每行代码结尾的分号是可以省略的,但是如果一行包含多个语句时,分号则不能省略

1
let cat = 'cat'; print(cat)

整型

一些整型常量

 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
// 
Int.max
Int.min
// 
UInt.max
Uint.min

// 
Int8.max
Int8.min

// 17
let binaryInt: Int = 0b10001
// 17
let octalInt: Int = 0o21
// 17
let hexInt: Int = 0x11

// : 线便
let a = 1_000_1000 // 

let decimalInteger = 17

// 17 0b
let binaryInteger = 0b10001

// 17  "0o"
let octalInteger = 0o21

// 17 "0x"
let hexadecimalInteger = 0x11

一般建议直接使用Int类型,它的位数默认与当前使用的操作平台相关:

  • 在32位的平台上,等效于Int32
  • 在64位的平台上,等效于Int64

浮点型

1
2
3
// 
var a: Float = 3.1415926
var b: Double = 3.1415926

类型别名

可以使用 typealias 关键字来定义类型别名

1
2
3
typealias AudioSample = UInt16
//AudioSample.min  UInt16.min , maxAmplitudeFound  0
var maxAmplitudeFound = AudioSample.min

布尔类型和if语句

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
// bool
let imTrue: Bool = true
let imFalse: Bool = false

if imTrue {
    print("I am True")
}
else if 3+4 == 7{
    print("3+4 == 7")
}
else{
    print("I am false")
}

// 0
if 1 {
    print("I am true")
}

元组

  • 将多个不同的值集合成一个数据
  • 可以有任意多个值
  • 不同的值可以是不同的类型
 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
var point = (5,2)
var httpResponse = (404, "Not Found")


var point2: (Int, Int, Int) = (1,2,3)

// 
var point = (5,2)

// pythn
let (x, y) = point
let (status_code, status_message) = http404Error
print(x)
print(y)

// 访, python使
print(point.0)
print(point.1)

// 访python
var point3 = (x: 1, y: 2)
point3.x
point3.y

// 
var point4: (x: Int, y: Int) = (2,3)
point4.x
point4.y
// 使"_"
var logingResult = (true, "xxxxx")
let (isLoginSuccess, _) = logingResult
isLoginSuccess

可选值

当可以确定一个可选值包含有值时,可以使用!来强制使用值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)

if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
}

if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
}

if语句中可以同时绑定多个可选值(用,分隔)。只有当所有的值都真实有值时,if条件才成立。

下面两个if语句是等效的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
if let firstNumber = Int("4"), let secondNumber = Int("42"),
    firstNumber < secondNumber && secondNumber < 100 {
        print("\(firstNumber) < \(secondNumber) < 100")
    }

//
if let firstNumber = Int("4") {
    if let secondNumber = Int("42") {
        if firstNumber < secondNumber && secondNumber < 100 {
            print("\(firstNumber) < \(secondNumber) < 100")
        }
    }
}

if语句绑定的可选值有效范围仅在if语句内部

断言(Assertions)和先决条件(Preconditons)

Assertions和Preconditions的区别在于Assertions只在debug build中生效, 而Precondtions在debug build和production build中都生效。

 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

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")

//
assert(age >= 0)

//使assertionFailure
if age > 10 {
    print("You can ride the rollercoaster or the ferris wheel.")
} else if age > 0{
    print("You can ride the ferris wheel.")
}
else {
    assertionFailure("A person's age can't be less than zero.")
}

var index = 0
precondition(index > 0, "Index must greater than zero.")

//使preconditionFailure
var age = 0
if age > 10 {
    print("You can ride the rollercoaster or the ferris wheel.")
} else if age > 0{
    print("You can ride the ferris wheel.")
}
else {
    preconditionFailure("A person's age can't be less than zero.")
}

PS:

当在编译的时候用的是unchecked mode`(-Ounckecked), precondition是不会被执行的,默认它们的条件都是成立的,返回true。但是,使fatalError(_:file:line:)`是会生效的,无论编译参数是什么。