本人对泛型的商讨还很浅显,后续小编会写一篇有关斯维夫特范型的篇章,招待大家关切-> 美洛蒂Zhy

1. flatMap重回后的数组中不设有nil 同期它会把Optional解包

let fruits = ["apple", "banana", "orange", ""]
let counts = fruits.flatMap { fruit -> Int? in
    let length = fruit.characters.count
    guard length > 0 else {
        return nil
    }
    return length
}
// [5,6,6]
print(counts)
let numbers = [1,2,3,4,5,6]let evens = numbers.filter { $0 % 2 == 0 }// [2, 4, 6]print

Filter

filter 能够抽取数组中符合条件的因素 重新组合五个新的数组

flatMap 与 map 分化之处是flatMap再次回到后的数组中不设有 nil
同有的时候候它会把Optional解包;flatMap 仍是能够把数组中存有数组的数组
一齐张开产生三个新的数组 ;flatMap也能把八个不相同的数组合併成叁个数组
那些统一的数组成分个数是前方多个数组成分个数的乘积

FlatMap

flatMap 与 map 分化之处是flatMap重返后的数组中子虚乌有 nil
同一时间它会把Optional解包;flatMap 仍是可以把数组中存有数组的数组
一起展开造成三个新的数组 ;flatMap也能把多少个例外的数组合併成三个数组
那些统一的数组成分个数是前方七个数组成分个数的乘积

能够看来地点的代码正是大家平日使用的代码,但经过数组的map函数能够帮我们简化下边的代码

3. Map还是可以回来决断数组中的成分是或不是满足某种条件的Bool值数组

let array = [1,2,3,4,5,6]
// 最洁简的写法
let isEven = array.map { $0 % 2 == 0 }
// 这里在写下完成的写法 下面的例子 将都采用最洁简的写法^_^ 同时也要养成习惯看见上面那种洁简的写法 就要懂它做了些什么 会有什么样的结果
let isEven1 = array.map { num in
    // 写上retrun在Playground中的循环次数是6次 不写是7次 Xcode版本是7.2(7C68) 
    // 不知道这是不是bug 有知道的提醒下我~
    return num % 2 == 0
}
// [false, true, false, true, false, true]
print(isEven)
let fruits = ["apple", "banana", "orange", ""]let counts = fruits.flatMap { fruit -> Int? in let length = fruit.characters.count guard length > 0 else { return nil } return length}// [5,6,6]print

let array = [[1,2,3], [4,5,6], [7,8,9]]// 如果用map来获取新的数组let arrayMap = array.map { $0 }// [[1, 2, 3], [4, 5, 6], [7, 8, 9]]print// 用flatMaplet arrayFlatMap = array.flatMap { $0 }// [1, 2, 3, 4, 5, 6, 7, 8, 9]print(arrayFlatMap)

// 这种情况是把两个不同的数组合并成一个数组 这个合并的数组元素个数是前面两个数组元素个数的乘积let fruits = ["apple", "banana", "orange"]let counts = [1, 2, 3]let fruitCounts = counts.flatMap { count in fruits.map { fruit in// title + "\" // 也可以返回元组 (fruit, count) }}// [("apple", 1), ("banana", 1), ("orange", 1), ("apple", 2), ("banana", 2), ("orange", 2), ("apple", 3), ("banana", 3), ("orange", 3)]print(fruitCounts)// 这种方法估计用的很少 可以算是一个 flatMap 和 map 的结合使用吧

1.比方大家有叁个这样的须要遍历贰个数组中有所的成分,将每种成分本人与自身相加,最终回来三个封存相加后成分的数组(-_-原谅小编这表达能力,下边用代码演讲)

一旦大家不利用map函数,那么代码如下

let numbers = [1,2,3]
var sumNumbers = [Int]()
for var number in numbers {
    number += number
    sumNumbers.append(number)
    }
// [2,4,6]
print(sumNumbers)   

能够观察地点的代码就是大家平时使用的代码,但经过数组的map函数能够帮大家简化上边的代码

// 可以看到我们甚至可以不再定义可变的数组直接用不可变的就可以
let numbers = [1,2,3]
let sumNumbers = numbers.map { (number: Int) -> Int in
    return number + number
}
// 下面介绍简便写法 因为map闭包里面的类型可以自动推断所以可以省略
let sumNumbers1 = numbers.map { number in
    return number + number
}
// 可以省了return 但是循环次数多了一次 目前不知道这是什么原因(循环次数是3次这是4次) 结果是一样的 
let sumNumbers2 = numbers.map { number in number + number }
print(sumNumbers2) // [2,4,6]
// 最终简化写法
let sumNumbers3 = numbers.map { $0 + $0 }

假定咱们不使用map函数,那么代码如下

filter能够很好的帮我们把数组中不须求的值都去掉 那些非常赞!

let numbers = [1,2,3,4,5,6]
let evens = numbers.filter { $0 % 2 == 0 }
// [2, 4, 6]
print(evens)

filter 能够抽出数组中符合条件的元素 重新组合二个新的数组

1. 诸如大家要获取二个数组中颇具因素的和

let numbers = [1,2,3,4,5]
// reduce 函数第一个参数是返回值的初始化值
let sum = numbers.reduce(0) { $0 + $1 }
// 这里我写下完整的格式
let sum1 = numbers.reduce(0) { total, num in
    // 这里写不写return在Playground都循环5次 但上面用最洁简的方法显示循环6次。。。 What The Fuck 这是什么鬼!!!
    return total + num
}
// 15
print(sum)

map函数能够被数组调用,它接受一个闭包作为参数,效用于数组中的每一个成分。闭包重临二个转移后的因素,接着将有所这么些转换后的要素构成二个新的数组

3. flatMap也能把四个例外的数组合併成贰个数组 那个统一的数组成分个数是前边七个数组成分个数的乘积

// 这种情况是把两个不同的数组合并成一个数组 这个合并的数组元素个数是前面两个数组元素个数的乘积
let fruits = ["apple", "banana", "orange"]
let counts = [1, 2, 3]
let fruitCounts = counts.flatMap { count in
    fruits.map { fruit in
//        title + "(index)"
        // 也可以返回元组
        (fruit, count)
    }
}
// [("apple", 1), ("banana", 1), ("orange", 1), ("apple", 2), ("banana", 2), ("orange", 2), ("apple", 3), ("banana", 3), ("orange", 3)]
print(fruitCounts)
// 这种方法估计用的很少 可以算是一个 flatMap 和 map 的结合使用吧
网站地图xml地图