Swift基础语法文章汇总

本文讲述了Swift中对字符串和数组的一些方法，能够方便我们对字符串和数组进行复杂操作

主要内容：

1. 字符串
2. 数组

1、字符串

1.1 String

拼接：

/*
 1、空字符串
 */
var emptyStr1 = ""
var emptyStr2 = String()

/*
 2、字符串拼接
 */
var str: String = "1"
// 拼接， jack_rose
str.append("_2")
// 重载运算符 +
str = str + "_3"
// 重载运算符 +=
str += "_4"
// \()插值
str = "\(str)_5"
// 长度， 9，1_2_3_4_5
print(str.count)

说明：

1. String本身是可变的，可以直接进行拼接
2. 不会产生新的字符串，返回的是原来的字符串
3. 拼接方式有多种，都很方便

判断子串：

/*
 3、截取子串
 */
var str3 = "123456"
print(str.hasPrefix("123"))
print(str.hasSuffix("456"))

说明：

1. 判断前缀和后缀的子串是否存在

插入：

/*
 4、字符串插入
 */
var str4 = "1_2"
// 1_2_
str4.insert("_", at: str4.endIndex)
// 1_2_3_4
str4.insert(contentsOf: "3_4", at: str4.endIndex)
// 1666_2_3_4
str4.insert(contentsOf: "666", at: str4.index(after: str4.startIndex))
// 1666_2_3_8884
str4.insert(contentsOf: "888", at: str4.index(before: str4.endIndex))
// 1666hello_2_3_8884
str4.insert(contentsOf: "hello", at: str4.index(str4.startIndex, offsetBy: 4))

说明：

1. 这里的startIndex和endIndex是专门的Index类型
2. endIndex是指字符串的最后一个字符的后一个位置
3. startIndex是字符串的第一个位置
4. 我们只能获取到这两个值，其他的位置只能通过创建Index索引来获取
5. str.index(after:str.startIndex)是获取第一个位置的后一个位置
6. str.index(str.startIndex,offsetBy: 4)是指从开始位置偏移四位
7. 插入一个字符直接写""，但是如果插入多个字符必须使用contentOf:""

删除：

/*
 5、字符串删除
 */
// 666hello_2_3_8884
str4.remove(at: str4.firstIndex(of: "1")!)
// hello_2_3_8884
str4.removeAll { $0 == "6" }
var range = str4.index(str4.endIndex, offsetBy: -4)..<str4.index(before: str4.endIndex)
// hello_2_3_4
str4.removeSubrange(range)

说明：

1. remove移除的是某个字符，这里表示移除字符为"1"的第一个字符
2. removeAll移除的是闭包表达式计算出来的所有字符
3. 还可以移除某个范围的字符。这个范围也是通过..<来写的

1.2 SubString

Swift专门提供了子串类型。
String可以通过下标、prefix、suffix等截取子串，子串类型不是String ，而是Substring
本质上SubSting和原来的String是共用一段内存，这也就是真正的子串的含义。
在读取时没有拷贝值赋给子串，而是共用。在修改时会拷贝出一份内存给子串

/*
 6、Substring
 */
var str6 = "1_2_3_4_5"
// 1_2
var substr1 = str.prefix(3)
// 4_5
var substr2 = str.suffix(3)
// 1_2
var range2 = str6.startIndex..<str6.index(str6.startIndex, offsetBy: 3)
var substr3 = str[range2]

// 最初的String，1_2_3_4_5
print(substr3.base)

//直接转换成String，此时会开启新的空间
var str61 = String(substr3)

说明：

1. Substring发生修改 或者 转为String时，会分配新的内存存储字符串数据
2. 还可以通过.base得到子串的原始字符串

Substring转换String.png

1.3 String 与 Character的转换

通过字符串获取到其中某个字符的时候，得到的就是Character类型

/*
7、 Substring -> String
 */
for c in "jack" { // c是Character类型 print(c)
    print(c)
}

var str7 = "jack"
// c是Character类型
var c = str7[str7.startIndex]

1.4 String相关的协议

这两个协议数组和字符串都遵守了

1.4.1 BidirectionalCollection

协议中包含startIndex 、endIndex 属性、index 方法

1.4.2 RangeReplaceableCollection

包含append、insert、remove 方法

1.5 多行String

以结尾的3引号为对齐线.png

说明：

1. 三引号就可以实现多行字符串
2. 缩进以结尾的3引号为对齐线
3. 如果要显示3引号，至少转义1个引号

1.6 String 与 NSString

String与NSString 之间可以随时随地桥接转换，系统会帮我们桥接。

代码：

/*
String和NSString的转换
*/
var str1: String = "WY"
var str2: NSString = "wenyi"

var str3 = str1 as NSString
var str4 = str2 as String

// ja
var str5 = str3.substring(with: NSRange(location: 0, length: 2))
print(str5)

说明：

• 桥接完之后是两个不同的值，而不是新的值
• 可以通过强转类型来判断是否可以桥接

String与NSMutableString的桥接判断：
1、String和NSString可以相互桥接转换
2、String不能桥接转换成NSMutableString
3、NSMutableString可以桥接转换成String

可以这么理解：NSMutableString是NSString的子类，范围要小于NSString，所以NSMutableString一定是NSString，但NSString不一定是NSMutableString。

数组、字典、集合也是如此：

转换示意图.png

2、数组

Swift提供了很多操作，可以方便的完成更复杂的功能

2.1 常见操作

/*
 1、常见操作
 */
func test1(){
    var arr = [1, 2, 3, 4]
    // [2, 4, 6, 8]
    var arr2 = arr.map { $0 * 2 }
    print(arr2)
    // [2, 4]
    var arr3 = arr.filter { $0 % 2 == 0 }
    print(arr3)
    // 10
    var arr4 = arr.reduce(0) { $0 + $1 }
    print(arr4)
    // 10
    var arr5 = arr.reduce(0, +)
    print(arr5)
}

说明：

1. map是表示数组元素映射
   1. 将arr数组中的每个元素取出来进行操作，返回出来作为arr2数组的元素
2. filter表示数组元素过滤
   1. 取出arr数组中的每个元素进行判断，判断为true的元素会返回出来作为arr3数组的元素
3. reduce循环操作数组每个元素返回一个值
   1. 传入的值作为闭包表达式的参数
   2. 这一轮的返回值作为下一轮进入该闭包表达式的参数。
   3. 一直到数组循环结束，那么就完成计算，此时拿到的结果就返回给arr2

2.2 lazy的优化

优化前：

优化前.png

优化后：

优化后.png

说明：

1. 正常情况下我们不去使用新数组，只要创建新数组，都会循环映射
2. 数组的每个元素都会进行映射，比较耗时，但我们不一定会使用这么多映射的元素
3. 加上lazy后只有使用的时候才会进行操作

2.3 map的深入认识

2.3.1 flatMap(展平映射)

func test3() {
    var arr = [1, 2, 3]
    // [[1], [2, 2], [3, 3, 3]]
    var arr2 = arr.map { Array.init(repeating: $0, count: $0) }
    print(arr2)
    // [1, 2, 2, 3, 3, 3]
    var arr3 = arr.flatMap { Array.init(repeating: $0, count: $0) }
    print(arr3)
}

说明：

1. 区别在于map会返回三个数组，flatMap只返回一个数组
2. map是进行映射，将数组的每个元素进行操作后返回作为新数组的元素，而返回的元素是一个数组，所以是三个数组
3. 对于flatMap是将映射出来的所有元素返回来作为新数组的元素

map方法认识：

/*
 返回一个数组，其中包含将给定闭包映射到序列元素上的结果
 - Parameter transform:一个映射闭包
    1. 这个闭包接收数组元素作为它的参数
    2. 返回一个转换后的值，这个值的类型可以与参数相同，也可以不同
 - Returns:
    返回一个数组，数组元素为转换后数组的元素
 */
@inlinable public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]

flatmap方法认识

/*
 返回一个数组，其中包含使用此序列的每个元素调用进行指定转换后的串联结果。
 当转换为每个元素生成序列或集合时，使用此方法接收单个级别的集合。
 
 <例子>
 let mapped = numbers.map { Array(repeating: $0, count: $0) }
 // [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]

 let flatMapped = numbers.flatMap { Array(repeating: $0, count: $0) }
 // [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
 
 实际上，`s.flatMap(transform)` <=> `Array(s.map(transform).joined())`
 
 - Parameter transform:
    1. 这是一个闭包，接收数组的元素作为它的参数
    2. 返回一个序列（数组）或集合（多个数组元素组合的数组）
 - Returns:
    1. 返回一个展平数组
 */
@inlinable public func flatMap<SegmentOfResult>(_ transform: (Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence

说明：

1. 可以看到map进行映射，返回的类型是自定义的，所以可以返回多数组
2. 而flatMap返回的只是一个Sequence，也就是只有一个数组。
3. flatMap返回的是一个数组，数组的元素就是闭包表达式中获取到的数组的元素，

注意：

• Array.init(repeating:, count:)会得到一个数组，数组元素为repeating，元素个数为count。

2.3.2 compactMap(压缩紧凑映射)

func test4() {
    var arr = ["123", "test", "jack", "-30"]
    // [Optional(123), nil, nil, Optional(-30)]
    var arr2 = arr.map { Int($0) }
    // [123, -30]
    var arr3 = arr.compactMap { Int($0) }
}

说明：

1. 会自动将可选项进行解包后再加入到数组中
2. 可以看到，如果是nil就不会添加到数组中

2.3.3 Optional的map和flatMap

代码：

func test5() {
    var num1: Int? = 10
    // Optional(20)
    var num2 = num1.map { $0 * 2 }

    var num3: Int? = nil
    // nil
    var num4 = num3.map { $0 * 2 }
}

说明：

• map拿到的仍然是可选项
• 如果本身是nil，那么不会执行map

代码：

func test6() {
    var num1: Int? = 10
    // Optional(Optional(20))
    var num2 = num1.map { Optional.some($0 * 2) }
    // Optional(20)
    var num3 = num1.flatMap { Optional.some($0 * 2) }
}

说明：

• map映射 拿到的是什么就是什么
• 而flatMap看到已经是可选项了，便不再包装可选项

代码：

func test7() {
    var fmt = DateFormatter()
    fmt.dateFormat = "yyyy-MM-dd"
    var str: String? = "2011-09-10"
    // old
    var date1 = str != nil ? fmt.date(from: str!) : nil
    // new
    var date2 = str.flatMap(fmt.date)
}

说明：

• 如果是nil，那么返回nil
• 如果不是nil，那么直接调用，此时str就是传入的参数。闭包简写表示fmt.date就知道是要操作它

代码：

func test8() {
    struct Person {
    var name: String
    var age: Int
    }
    var items = [
    Person(name: "jack", age: 20),
    Person(name: "rose", age: 21),
    Person(name: "kate", age: 22)
    ]
    // old
    func getPerson1(_ name: String) -> Person? {
    let index = items.firstIndex { $0.name == name }
    return index != nil ? items [index!] : nil
    }
    // new
    func getPerson2(_ name: String) -> Person? {
    return items.firstIndex { $0.name == name }.map { items [$0] }
    }
}

说明：

• firstIndex表示得到第一个符合要求的索引
• 此处表示$0.name == name的就是符合要求的元素，返回它的索引