FJBQ
0%

Swift 语法笔记

发表于 更新于 分类于

前言

可以参考菜鸟教程：
Swift 教程 | 菜鸟教程 (runoob.com)

1
2
3
4
5
6
7
8
print(1, 2, 3, 4, 5, separator:" . ", terminator:"-")

- print 函数默认换行（默认终结符是\n）；
- separator：定义输出的内容之间的分隔符；
- terminator：定义输出的终结符；

var：定义变量
let：定义常量

字符串

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
// 字符串

// 重复十个a
var s0 = String(repeating: "a", count: 10)

// 多行字符串
var s1 = """
中国
人民
站起来了
"""
print(s1)

// 多行字符串(但是只输出一行)
var s2 = """
中国\
人民\
站起来了
"""
print(s2)		// 中国人民站起来了

// 转义字符\
var s3 = "\"中国\""
print(s3)		// 输出：“中国”

// 定界符（不用转义）
var s4 = #""中'国""#
print(s3)		// 输出："中'国"（第一对 "" 表示字符串的意思）

// 字符串链接
var name = "fj"
var age = 22
var hello = "bq"
var s5 = name + hello       // s5   = fjbq
name.append(hello)          // name = fjbq
name += hello               // name = fjbqbq
var s7 = "\(name) 年龄是: \(age)岁"   // 字符串转义

print("s5 : " + s5)
print("s7 : " + s7)

--------------------------------------------------------------

// 字符串属性
var name = "Fj Qq"
print(name.isEmpty)
print(name.count)               // 返回字符串的长度
print(name.description)         // 输出字符串的值
print(name.debugDescription)    // 便于调试的值
print(name.hashValue)           // 输出哈希值(每一个变量都有一个hash值)
print(name.uppercased())        // 大写
print(name.lowercased())        // 小写

print("proNum".hasPrefix("pro"))    // 判断字符串是否有pro前缀
print("proNum".hasPrefix("Num"))    // 判断字符串是否有Num后缀

// 字符串遍历

var ss = "fjbq中国人👀"

//  直接遍历值
for c in ss {
    print(c)
}

// 遍历索引(索引不是012...)
for index in ss.indices {
    print(ss[index])    
}

// ss.startIndex 是 ss 的第一个索引
print(ss[ss.startIndex])                    

// ss.endIndex 是ss的最后一个索引（但是不是最后一个字符，是最后一个字符的下一个位置）
// ss.index() 表示对ss的索引进行操作：
// ss.index(before: ss.endIndex) 表示获取 ss.endIndex 索引的前一个索引
// ss.index(after: ss.endIndex) 表示获取 ss.endIndex 索引的后一个索引
// ss.index(ss.endIndex, offsetBy: -2) 表示获取 ss.endIndex 索引偏移 -2 的索引
print(ss[ss.index(before: ss.endIndex)])

整数、浮点数、双精度

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
整数、浮点数、双精度

var a = 4.0
print(type(of: a))		// double

var myAge:Int = 50		// 显示声明整数
var yourAge = Int(60.0)	// double转换为int

var a = 0b10	// 2进制
var b = 0o7		// 8进制
var c = 0xf		// 16进制

var d = 89_000_000	// 分割数字
print(d)			// 89000000

var price = Int("3") ?? 0	// ?? 运算符：Int("3") 成功则为3，不成功则为 0（不加？？会报错）
print(price)

// 指定转换的进制
var price1 = Int("ff", radix: 16) ?? 0
print(price1)

// 随机数
print(Int.random(in: 1...100))		// [1,100]
print(Int.random(in: 100..<110))	// [100,110)

var x = -21
x.negate()		// -21 变成 21

x = -30
print(x.magnitude)	// magnitude 绝对值属性

// quotientAndRemainder：求商和余数；dividingBy：除以
x = 100
let (q,r) = quotientAndRemainder(dividingBy: 9)

// 返回x的符号：-1，0，1
print(x.signum())

// 整数的常量
print(Int.zero)
print(Int.max)
print(Int.min)

-------------------------------------------------------------

双精度

var z1 = Double.random(in: 10.0...100.0)
print(z1.squareRoot())	// 平方根

// 近似值
x = 100.23
print(x.rounded())						// 默认四舍五入
print(x.rounded(.awayFromZero))			// 四舍五入到幅度大于或等于源值的最接近的允许值
print(x.rounded(.down))					// 四舍五入为小于或等于源值的最接近的允许值
print(x.rounded(.toNearestOrAwayFromZero))	// 四舍五入到最接近的允许值；如果两个值同样接近，则选择幅度较大的一个
print(x.rounded(.toNearestOrEven))		// 四舍五入到最接近的允许值；如果两个值同样接近，则选择偶数
print(x.rounded(.towardZero))			// 四舍五入到幅度小于或等于源值的最接近的允许值
print(x.rounded(.up))					// 四舍五入为大于或等于源值的最接近的允许值

y = -1.1
print(y.magnitude)	// 绝对值
print(y.sign)		// 符号：plus，minus

print(Double.pi)	// 常量

------------------------------------------------------------------------------------

布尔值

var x = true
var y:Bool = false

x.toggle()		// x 取反
print(x)

print(Bool.random())	// 随机布尔值

运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运算符

var (a, b) = (10,20)

// 空合运算符
var h:String?	// 表示可能没有值
print(h ?? "")	// 有值输出h，没值输出""

// 区间运算符
// 1...10	[1,10]
// 1..<10	[1,10)
// 下面两个只能在有区间限制的情况下使用
// ...10	[0,10]
// ..<10	[0,10)

// 其他的基本和C++一样

小练习：计算圆的周长和面积

1
2
3
4
5
6
7
8
9
10
11
12
小练习：计算圆的周长和面积

print("请输入圆的半径：", terminator: "")
var value = readLine() ?? "0.0"     // 读入的是字符串，可能不读入

var radius:Double = 0.0
radius = Double(value) ?? 0.0       // 可能转化失败

let area = Double.pi * radius * radius
let perimeter = 2 * Double.pi * radius

print("半径为 \(radius) 的圆\n周长是 \(perimeter.rounded())  \n面积是 \(area.rounded())")

数组

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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
数组

性质：
1. 有序
2. 类型统一
3. 内容可重复

--------------------------------------------------------------------------------

// 数组的声明和定义

var a = [1,2,3]
var b = ["a","b","c"]
var c = [true,false,true]
print(a,b,c)

var a1:Array<Int> = [1,2,3]
var a2:[Int] = [1,2]
print(a1,a2)

var b1 = Array<Int>()
var b2 = Array<Int>([1,2])
var b3 = Array(1...7)
print(b1,b2,b3)

var c1 = Array(repeating:"*", count:6)
print(c1)
print(c1.count)     // 统计元素的个数
print(c1.isEmpty)   // 判断是否为空

--------------------------------------------------------------------------------

// 下标访问数组

print(a[0])         // 输出：1
print(b[0...2])     // 输出：["a", "b", "c"]
print(b[...2])      // 输出：["a", "b", "c"]
print(b[1...])      // 输出：["b", "c", "d", "e"]

--------------------------------------------------------------------------------

// 数组的遍历

for item in b
{
    print(item, terminator: "-")
}
print("")
// 输出：a-b-c-d-e-

for (i, value) in b.enumerated()
{
    print(i, value, separator: ":")
}
/*
输出：
0:a
1:b
2:c
3:d
4:e
*/

print(b[b.count - 1])   // 输出数组的最后一个元素，数组为空会报错
print(b.first ?? "")    // 输出数组的第一个元素，没加 ?? "" 会输出 Optional("a")，表示这个值是可选的（可能为空），当数组为空时输出nil
print(b.last ?? "")     // 输出数组的最后一个元素
print(b.randomElement() ?? "")  // 随机一个元素

--------------------------------------------------------------------------------

// 数组 追加元素

var v = ["坚定", "坚持", "坚强"]
v.append("努力")    // 追加一个元素
print(v)

v.append(contentsOf: ["勇敢","乐观"])
print(v)

v += ["奋斗","幸运"]
print(v)

--------------------------------------------------------------------------------

// 数组 插入和替换
v.insert("fjbq", at: 0)                         // 将fjbq插入到第0的位置
v.insert(contentsOf:["fj","fj777"], at: 0)      // 插入数组

var v1 = Array<Int>()
v1.insert(contentsOf: 1...3, at: 0)              // 插入序列
print(v1)

print(v)
v.replaceSubrange(0...2, with:["1","2"])    // 将v数组的0-2的元素替换成后面的数组（个数可以不匹配）
print(v)

----------------------------------------------------------------------------------------

// 数组的删除和查找

var v2 = ["111","222","333","444","111"]
var v3 = Array<String>()
var v4 = [111,222,333,444,111]

// v2.remove(at: 1)            // 删除指定下标的元素，下标越界会报错，空数组会报错
// v2.removeFirst()            // 删除第一个元素，空数组会报错
// v2.removeLast()             // 删除最后一个元素，空数组会报错
// v2.removeSubrange(1...2)    // 删除一个子区间，下标越界会报错，空数组会报错
// v2.removeAll()              // 全部删除
// print(v2)

var flag = v2.contains("111")   // 查找数组v2里面是否包含"111"，返回布尔值

/*
方法一：
    
    v2.first(where: { })：找到第一个满足条件的元素
    where: {$0 == "222"} 这是一个条件，也是一个闭包
    $0 表示闭包中的隐式参数
*/
var value = v2.first(where: {$0 == "222"})
print(value ?? "")  // 输出：222（加?? ""的原因是可能找不到，找不到为nil）

/*
方法二：
    
    v2.firstIndex(where: { })：找到第一个满足条件的元素的下标
    n 也是相当于是隐式参数

    值得注意的是：
        这里的结果不能直接用上面的 value 承接；
        因为 swift 实际上是 强数据类型 的语言，不像 lua 是弱数据类型的语言
        value 在上面已经被用作 String 了，下面再给他赋值为 Int 就不行！
*/
var value1 = v2.firstIndex(where: {n in
    n == "333"
})
print(value1) // 输出：Optional(2)

/*
其他：
    .first 找到第一个满足条件的元素
    .firstIndex 找到第一个满足条件的元素的索引号
    .last 最后一个元素
    .lastIndex 最后一个元素索引
*/

----------------------------------------------------------------------------------------


欢迎关注我的其它发布渠道