二十一、map函数相关用法

数组元素操作map及相关函数

1. map、flatMap、compactMap函数

var arr = [1, 2, 3, 4]
var arrS = ["1", "2", "3", "4"]
//映射用map
var arr2 = arr.map { $0 * 2 }//返回数组
var arrS = arr.map { "abc_\($0)" }
//map也可以接受一个同类型的表达式 达到同样的效果
func double(_ element:Int) -> Int{
    element * 2
}
print(arr.map(double))

//遍历元素 并将循环产生的结果放到数组中
//[[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
var arr2 = arr.map { Array.init(repeating: $0, count: $0) }
//遍历元素 并将循环产生的数组中的元素g合并到一个数组中
//[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
var arr3 = arr.flatMap { Array.init(repeating: $0, count: $0)}

var arr = ["123", "123", "jack", "-30"]
//[Optional(123), Optional(123), nil, Optional(-30)]
var arr2 = arr.map { Int($0) }
//压缩紧凑
//[123, 123, -30]
var arr3 = arr.compactMap { Int($0) }

2. filter函数

//过滤 用filter
var arr3 = arr.filter {  $0 > 2 }//返回数组

3 reduce函数

//当前后遍历有关联用reduce
//元素总和
var result = arr.reduce(0) { $0 + $1}//$0 上一次遍历相加结果 $1数组元素
var result2 = arr.reduce(0, +)//更精简

//使用reduce 实现map函数的功能
var arr = [1, 2, 3, 4]
//数组相加 合并为新的数组
var arr2 = arr.reduce([]) { $0 + [$1 * 2] }

//使用reduce 实现filllter函数的功能
var arr3 = arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 }

lazy优化map函数

let arr = [1,2,3]

let result = arr.lazy.map { (value) -> Int in
    print("mapping \(value)")
    return value * 2
}

print("begin---")
print("result count",result.count)//count不会影响lazy属性
print("mapped",result[0])
print("mapped",result[1])//使用一次遍历一次
print("mapped",result[2])
print("end---")

/*
 输出结果:
 begin---
 result count 3
 mapping 1
 mapped 2
 mapping 2
 mapped 4
 mapping 3
 mapped 6
 end---
 **/

let result2 = arr.map { (value) -> Int in
    print("mapping \(value)")
    return value * 2
}

print("begin---")
print("mapped",result2[0])
print("mapped",result2[1])
print("mapped",result2[2])
print("end---")
/* 输出结果:
mapping 1
mapping 2
mapping 3
begin---
mapped 2
mapped 4
mapped 6
end---
*/

Optional的map和flatMap

1. 基本数据类型的Optional类型

var num: Int? = 10
var numNil: Int? = nil

var num2 = num.map { $0 * 2 }//Optional(20)
var num3 = numNil.map { $0 * 2 }//nil
print(num2, num3)

//再包装一层
var num4 = num.map{ Optional.some($0 * 2) }//Optional(Optional(20))
//flatMap更智能一点
var num5 = num.flatMap{Optional.some($0 * 2)}//Optional(20)
print(num4, num5)

//num6 与 num7等价
var num6 = (num != nil) ? (num! + 10) : nil
var num7 = num.map{$0 + 10}
print(num6, num7)

2.Class 与struct 的Optional类型

var fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var str: String? = "2011-09-10"
//日常写法
var date1 = str != nil ? fmt.date(from: str!) : nil
//使用flatMap 如果已经是可选类型直接返回 不用再包装
var date2 = str.map(fmt.date)

struct Person {
    var name:String
    var age: Int
}

var items = [Person(name: "jack", age: 10),
             Person(name: "rose", age: 20),
             Person(name: "kate", age: 30)]
//old
func getPerson(_ name:String) -> Person?{
    let index = items.firstIndex { $0.name == name }
    return index != nil ? items[index!] : nil
}
//new
func newPerson(_ name: String) -> Person?{
    let index = items.firstIndex { $0.name == name }
    return index.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? = ["age":"10","name":"rose"]
var person1 = json != nil ? Person(json!) : nil
var person2 = json.map(Person.init)