Swift- String&&Array&&Map,flatMap

String

• Swift的字符串String，根OC的NSString，在API设计上还是有很大差异

var emptyStr1 = ""
var emptyStr2 = String()

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

String 的插入和删除

var str = "1_2"
// 1_2_
str.insert("_",at:str.endIndex)
//1_2_3_4
str.insert(contentsOf:"3_4",at:str.endIndex)
//1666_2_3_4
str.insert(contentsOf:"666",at:str.index(after:str.startIndex))
//1666_2_3_8884
str.insert(contentsOf:"888",at:str.index(before:str.endIndexx))
//1666hello_2_3_8884
str.insert(contentsOf:"hello",at:str:index(str.startIndex,offsetBy:4))

// 666hello_2_3_8884
str.remove(at:str.firstIndex(of:"1")!)
// hello_2_3_8884
str.removeAll($0 == "6")
var range = str.index(str.endIndex,offsetBy:-4)..< str.index(before:str.endIndx)
//hello_2_4
str.removeSubrange(range)

Substring

• String可以通过下标、prefix、suffix等截取子串，子串类型不是String，而是Substring

var str = "1_2_3_4_5"
// 1_2
var substr = str.prefix(3)
// 4_5
var substr = str.subffix(3)
// 1_2
var range = str.startIndex..< str.index(str.startIndex,offsetBy:3)
var substr3 = str[range]
// 最初的String，1_2_3_4_5
print(substr3.base)
// Substring -> String
var str2 = String(substr3)

• Substring 和它的base，共享字符串数据
• Substring 转为String时，会重新分配新的内存存储字符串数据

String 与 Character

for c in "jianguo" { // c 是Chaaracter类型
    print(c)
}

var str = "jianguo"
// c 是Chaaracter类型
var c = str[str.startIndex]

String 与 NSString

• String 与 NSString 之间可以随意地桥接转换
• 如果你觉得String的API过于复杂难用，可以考虑将String转为NSString

var str1:String = "jianguo"
var str2:NSString = "rose"

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

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

• 比较字符串内容是否等价

  1. String使用 == 运算符
  2. NSString使用isEqual方法，也可以使用 == 运算符（本质还是调用了isEqual方法）

• String 与NSString可以相互桥接转换

• String 不能桥接转换成（通过as 强转） NSMutableString，NSMutableString可以转为 String

Swift	转	OC
String	<->	NSString
String	<-	NSMutableString
Array	<->	NSArray
Array	<-	NSMutableArray
Dictionary	<->	NSDictionary
Dictionary	<-	NSMutableDictionary
Set	<->	NSSet
Set	<-	NSMutableSet

Array

Array的常见操作

var arr = [1,2,3,4]
// [2,4,6,8]
var arr2 = arr.map {$ * 2}
//[2,4]
var arr3 = arr.filter {$0 % 2 == 0}
// 10
var arr4 = arr.reduce(0){$0 + $1}
// 10
var arr5 = arr.reduce(0, + )

func double(_ i:Int) -> Int { i *2}
var arr = [1,2,3,4]
//[2,4,6,8]
print(arr.map(double))

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

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

// reduce实现map、filter的功能
var arr = [1,2,3,4]
// [2,4,6,8]
print(arr.map{$ * 2})
print(arr.reduce([]){$0 + [$1 * 2]})

// [2,4]
print(arr.filter{$0 % 2 == 0})
print(arr.reduce([]){$1 % 2 == 0 ? $0 + [$1] : $0})

lazy 优化

//arr.lazy 可以做到在用到result再去映射，不用lazy，就去立刻去映射，如果arr 数据量大，映射过程复杂，会浪费性能。
let arr = [1,2,3]
let result = arr.lazy.map {
    (i:Int) -> Int in
    print("mapping \(i)")
    return i * 2
}
print("begin-----")
print("mapped",result[0])
print("mapped",result[1])
print("mapped",result[2])
print("end------")

Optional 的map 和 flatMap

// 
var num1:Int? = 10
//Optional(20)
var num2 = num1.map{$0 * 2} // $0 是num1 解包后的值，乘以2，再将值包装一层返回去
var num3:Int? = nil
// nil
var num4 = num3.map{$0 * 2}

var num1:Int? = 10
// Optional(Optional(20))
vr num2 = num1.map{ Optional.some($0 * 2)}
// Optional(20)，发现里面是一个可选类型，就不再包装一层
var num3 = num1.flatMap {Optional.some($0 * 2)}
// Optional(20)
var num4 = num1.flatMap{$0 * 2}

作用

var num1:Int? = 10
var num2 = (num1 != nil) ? (num1! + 10):nil
var num3 = num1.map { $0 + 10}
// num2 、num3 是等价的

var fmt = DateeFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var str:String? = "2025-02-22'
//old
var date1 = str != nil ? fmt.date(from:str!):nil
//new fmt.date 也是一个可选值，可能转换成功，可能失败
var date2 = str.flatMap{fmt.date(from:$0)}
var date3 = str.flatMap(fmt.date)

var scrore:Int? = 98
//old 
var str1 = score != nil ? "socre is\(score!)" : "No score"
//new ?? 空合并操作，右边为非可选项，把左侧的值解包
var str2 = score.map {"score is \($0)"} ?? "No score"

//items.firstIndx 可能找的到可能找不到
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),
]
func getPerson1(_ name:String) -> Person? {
    let index = items.firstIndx {$0.name == name}
    return index != nil ? items[index!] : nil
}
func getPerson2(_ name:String) -> Person? {
    return items.firstIndex{$0.name == name}.map {items[$0]}
}

struct Person {
    var name:String
    var age:Int
    init?(_ json:[String:Any]){
        // “，”表示两者都成功，等价于 &&
        guard let name = json["name"] as? String,
              let age = json["age"] as? Int else {
            return nil
        }
        self.name = name
        self.age = age
    }
}
var json:Dictionary? = ["name":"Jianguo","age":10]
//old
var p1 = json != nil ? Person(json!) : nil
// new
var p2 = json.flatMap(Person.init)