Swift基础教程(一)

作者：从前慢现在也慢 | 2024-07-10 18:08:38

踩

Swift基础教程(一)

1. 集合Set

特点:
- 没有顺序
- 统一类型
- 内容不能重复

集合的使用

import Foundation

// 声明方法1:
var s:Set<Int> = [1, 2, 3, 4, 4]
print(s) // 实际只有[1,2,3,4]

// 声明方法2(推断声明):
var s1 = Set([1, 2, 3, 4])

// 集合的方法
print(a.count) // 输出集合数量
print(a.isEmpty) // 集合是否为空

// 集合插入数据, 返回两个值, c是布尔值， 代表是否成功， d是插入的值.
var (c, d) = a.insert(6) // (true, 6)

// 插入方法2.
a.update(with: 11) // 强行插入.

// 移除
a.remove(11)	

// 移除所有:
a.removeAll()  
print(a)		// 


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

集合的运算

集合的加(并)运算

var a = Set([1,2,3,4])
var b = Set([3,4,5,6])
var c = a.union(b)
print(c) 	// [1,2,3,4,5,6]
1
2
3
4

集合的减元素

var a = Set([1,2,3,4])
var b = Set([3,4,5,6])
var c = a.subtracting(b)
print(c) 	// [1,2]
1
2
3
4

集合的交运算

var a = Set([1,2,3,4])
var b = Set([3,4,5,6])
var c = a.intersection(b)
print(c) 	// [3,4]
1
2
3
4

集合的异或运算

var a = Set([1,2,3,4])
var b = Set([3,4,5,6])
var c = a.symmetricDifference(b)
print(c) 	// [1,2,5,6]
1
2
3
4

子集判断

var a = Set([1,2,3,4])
var b = Set([2])
var isSub:Bool = b.isSubset(of: a) // b集合是否是a集合的子集
print(isSub) // true
1
2
3
4

超集判断

var a = Set([1,2,3,4])
var b = Set([2])
var isSuper:Bool = a.isSuperset(of: b) // a集合是否是b集合的超集?
print(isSuper) // true
1
2
3
4

集合的随机数

var a = Set([1,2,3,4])
print(a.randomElement()) // 随机获取一个元素;
1
2

集合的变换运算(.map())
集合的排序(.sorted())
集合的洗牌.shuffled()

集合的遍历(同Array)

// 直接输出.
for item in a {
    print(item)
}

// 输出下标和值.
for (k, v) in a.enumerated() {
    print(k, v)  //实质小标无意义
}

// 不用参数，则遍历的项可以通过$0获取
a.forEach {
    print($0) 
}
a.forEach { item in
    print(item)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2. 字典(Dictionary)

key-value， key不能重复, value类型需要一致

字典的声明, key仅仅只能有 Int, String, Bool

var a1:Dictionary<Int, String> = [:] // 声明一个空字典
var a2:Dictionary<Int, String> = [1:"apple", 2:"orange"] // 声明一个有内容字典
var a3:Dictionary<String, String] = ["张三":"apple"]
var a4:Dictionary<Bool, String> = [true:"apple", false:"orange"]

// 字典类型自己推断声明
var a5 = ["张三":"篮球", "李四":"乒乓求"]
1
2
3
4
5
6
7

字典的访问

var a = ["张三":"篮球", "李四":"乒乓求"]
var hobby = a["张三", default:""] // 直接访问key,可能没有，所有需要跟一个默认值

1
2
3

字典的属性和方法

var a = ["张三":"篮球", "李四":"乒乓求"]
print(a.count)
print(a.isEmpty) 
1
2
3

字典的遍历

var a = ["张三":"篮球", "李四":"乒乓求"]
for (k, v) in a {
    print(k, v)
}
// 只遍历key
for k in a.keys {
    print(k)
}
// 只遍历值
for v in a.values {
    print(v)
}
a.forEach{
    print($0, $1)
}
a.forEach { k, v in
    print(k, v)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

字典其他方法

字典随机(randomElement)

print(a.randomElement()?? 0)
let e1 = a.randomElement() // 返回的是可选值(Optional)

使用解包方式
let e2 = a.randomElement()! // e2将不再是可选值，而是实际值.

1
2
3
4
5
6

3. 区间

通常用在for语句和数组下标中.

for index in 1...3 {
    print(index)
}
1
2
3

区间的定义

var a = 1...3	// 1, 2, 3    ClosedRange<Int>
var b = 1..<3	// 1, 2		  Range<Int>
var c = ...3    // ...到3     PartialRangeThrough<Int>
var d = ..<3    // ...到3, 不包含3. PartialRangeUpTo<Int>
var e = 1...    // 从1开始    PartialRangeFrom<Int>
var f = "a"..."z"	//       ClosedRange<String>		
var g = 0.0...10.0  //       ClosedRange<Double>

var h = stride(from: 10, to: 100, by: 2) // StrideTo<Int>

var g1:Range<Int> = 1..<3
var g2:ClosedRange<Int> = 1...3
1
2
3
4
5
6
7
8
9
10
11
12

区间使用

var a1 = ["a", "b", "c", "d", "e", "f"]
print(a1[...3])
1
2

区间的遍历++++++++++++++++++++++++++++

var a = 5...10
// 只能对闭合区间，才能够进行遍历. 对 "a"..."z"也无法进行遍历.
for i in a {
    print(i)
}
print(a.contains(11)) // false

var c = ...5
print(c.contains(-1000)) // true

print(a.count)  // 输出区间a的长度， 如果是开区间，则会编译错误
print(a.isEmpty) // 只对于闭区间有用
print(a.lowerBound)	// 下标
print(a.upperBound) // 上标
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4. 元组

var p1 = (10, 20)
// 指定类型
var p2:(Int, Int) = (20, 20)
// 自动推断
var p3 = ("张三", 1, 29, 180)
print(type(of: p3))

// 元组另外写法
var position = (x: 30, y: 40)
print(position)

var p4 = (name:"张三", sex:1, age:29, height:180)

// 访问元素
// 1. 通过下表访问
print(p1.0, p1.1)
// 2. 通过名字
print(p4.name, p4.height)

// 元组的解包
let (x, y) = position // x和y的名字可以和position中名字一致.
// 如果只需要一个，则另一个为_, 但是个数要一致
let (x, _) = position
// 如果拥有多个元素的元组，被一个元素解包，则输出的还是那个元组
let (v) = position 
print(v)   // (x: 30, y: 40)
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

5. 可选项

很多对象，可能有值，也可能为空，比如一个字符串，一个数字，或者一个对象，我们通常会判断是否为空.

var i = Int("10")   // 将字符串转换成整形，可能转换成功，也可能转换失败.
print(type(of: i)) 	// Optional<Int>
print(i) 			// Optional(10)
let v:Int = i!  	// 将可选类型进行解包成Int.
print(v)  			// 10

// 显示声明可选类型, 类型+?
var a:String? = "a"
print(type(of: a))

// 上述声明等效于
var b:Optional<String> = "b"
print(type(of: b))

// 初始化一个可选项为具体值
var n1:Int? = Optional.som(10)
print(n1!)
// 初始化一个可选项为空
var n2:Int? = Optional.none
print(n2)  // 因为n2是nil, 不能直接解包
// 判断可选是否为空
print(n2 == nil) //true

// 
var x1:Int? = 10
// 判断>10则输出
if a > 10 { 		// 因为a可能为空， 直接判断a>10会语法错误，因此不能直接这样进行比较.
    print("a > 10")
}

// if (let b = a) 这样写会有语法错误
if let b = a {
    if b > 10 {
        print("a > 10")
    }
}

// 判断字符串前缀
var s:String? = "ProductA"
if(s?.hasPrefix(prefix:"Pro")) {
    
}
if(let b = s?.hasPrefix(prefix:"Pro")) {
    if(b) {
    	print("有前缀")
    }
}
// 使用空和字符串更方便
print(s??"")

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/807145