• Swift——map函数浅析

    2015-10-27 00:20:51
    Swift语言的数组提供了一个map函数很好用,可建立一个a数组的映射数组b,即数学上的y = f(x). 我为大家用代码来实现一下: import Foundation //定义数组; var arr = [1,2,3,4,5] //需要对数组中的每一个值+10...

         Swift语言的数组提供了一个map函数很好用,可建立一个a数组的映射数组b,即数学上的y = f(x).

    我为大家用代码来实现一下:

    import Foundation
    
    //定义数组;
    var arr = [1,2,3,4,5]
    
    //需要对数组中的每一个值+10操作;
    func fmap(a : Int) -> Int{
      return a + 10
    }
    
    //这是采用函数的方式
    //map函数里面可以直接使用函数作为参数;
    var arr2 = arr.map(fmap)
    print("arr = \(arr)")
    print("arr2 = \(arr2)")

    输出结果如下:

    输出结果分析:可以看到,我们对数组中的每一个元素都执行了+10操作,我们并没有进行遍历,然后再赋值给另一个新数组,可见使用map函数十分的方便。


          当然map函数的作用不限于此,不仅传递一个函数作为参数,还可以传递一个闭包表达式,代码如下:

    import Foundation
    
    //定义数组;
    var arr = [1,2,3,4,5]
    
    //需要对数组中的每一个值+10操作;
    func fmap(a : Int) -> Int{
      return a + 10
    }
    
    //这是采用函数的方式
    //map函数里面可以直接使用函数作为参数;
    var arr2 = arr.map(fmap)
    print("arr = \(arr)")
    print("arr2 = \(arr2)")
    
    
    //这是采用闭包的方式
    //map函数里面可以直接使用闭包表达式作为参数;
    //$0表示的是第一个参数,也就是arr中的每一个值;
    var arr3 = arr.map({$0+10})
    print("arr3 = \(arr3)")

    输出结果如下:


    输出结果分析:使用闭包比传递一个参数方便、简洁。


    github主页:https://github.com/chenyufeng1991  。欢迎大家访问!


    展开全文
  • Swift 提供了如下几个高阶函数map、flatMap、filter、reduce。使用高阶函数进行函数式编程不仅可以简化我们的代码,而且当数据比较大的时候,高阶函数会比传统实现更快,因为它可以并行执行(如运行在多核上)。 ...
    Swift 提供了如下几个高阶函数:mapflatMapfilterreduce。使用高阶函数进行函数式编程不仅可以简化我们的代码,而且当数据比较大的时候,高阶函数会比传统实现更快,因为它可以并行执行(如运行在多核上)。

    一、map 函数

    1,方法介绍

    map 方法获取一个闭包表达式作为其唯一参数。 数组中的每一个元素调用一次该闭包函数,并返回该元素所映射的值。
    简单说就是数组中每个元素通过某个方法进行转换,最后返回一个新的数组。

    2,使用样例

    (1)下面将 Int 类型数组(各个商品的金额),转换成 String 类型的数组(在金额前加上 符号)
    1
    2
    3
    let prices = [20,30,40]
    let strs = prices.map({ "$\($0)" })
    print(strs)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    (2)对一个数组里面的数据进行平方操作
    1
    2
    3
    let values = [4, 6, 9]
    let squares = values.map({ $0 * $0 })
    print(squares)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    二、flatMap 函数

    1,方法介绍

    flatMap 方法同 map 方法比较类似,只不过它返回后的数组中不存在 nil(自动把 nil 给剔除掉),同时它会把 Optional 解包。

    2,使用样例

    (1)下面比较 map 和 flatMap 这两个方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    let array = ["Apple""Orange""Grape"""]
     
    let arr1 = array.map { a -> Intin
        let length = a.count
        guard length > 0 else return nil }
        return length
    }
    print("arr1:\(arr1)")
     
    let arr2 = array.flatMap { a-> Intin
        let length = a.count
        guard length > 0 else return nil }
        return length
    }
    print("arr2:\(arr2)")
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    (2)flatMap 还能把数组中存有数组的数组(二维数组、N维数组)一同打开变成一个新的数组。
    1
    2
    3
    let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    let arr1 = array.map{ $0 }   // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    let arr2 = array.flatMap{ $0 } // [1, 2, 3, 4, 5, 6, 7, 8, 9]

    三、filter 函数

    1,方法介绍

    filter 方法用于过滤元素,即筛选出数组元素中满足某种条件的元素。

    2,使用样例

    (1)筛选出金额大于 25 的元素。
    1
    2
    3
    let prices = [20,30,40]
    let result = prices.filter({ $0 > 25 })
    print(result)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    四、reduce 函数

    1,方法介绍

    reduce 方法把数组元素组合计算为一个值,并且会接受一个初始值,这个初始值的类型可以和数组元素类型不同。

    2,使用样例

    (1)将数组中的金额相加,计算总和。
    1
    2
    3
    let prices = [20,30,40]
    let sum = prices.reduce(0) { $0 + $1 }
    print(sum)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    注意:上面计算总数代码还可以简化成如下代码:
    1
    let sum = prices.reduce(0, +)

    (2)将数组转成字符串,每个元素用顿号()隔开。
    1
    2
    3
    4
    5
    6
    7
    8
    let array = ["Apple""Orange""Grape"]
    let str = array.reduce("", {
        return $0 == "" ? $1 : $0 + "、" + $1
    })
    print(str)
     
    //上面等效与
    let str = array.joined(separator: "、")
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    五、高阶函数的组合使用、链式调用

    1,组合使用

    (1)flatMap 配合 filter 将多维整型数组里面的偶数筛选出来并且组合成了一个一维数组。
    1
    2
    3
    4
    5
    let collections = [[5,2,7],[4,8],[9,1,3]]
    let onlyEven = collections.flatMap {
        $0.filter { $0 % 2 == 0 }
    }
    print(onlyEven)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    (2)map 配合 reduce 计算二维数组里每个分组的总和。
    1
    2
    3
    let collections = [[5,2,7],[4,8],[9,1,3]]
    let sums = collections.map({ $0.reduce(0, +) })
    print(sums)
    原文:Swift - 高阶函数介绍(map、flatMap、filter、reduce)

    2,链式组合

    (1)将数组中大于 7 的所有数字进行求和操作。
    1
    2
    let marks = [4,5,8,2,9,7]
    let totalPass = marks.filter{$0 > 7}.reduce(0,+) //17

    (2)对某一个数组里面的数字进行平方操作然后再筛选出偶数值。
    1
    2
    let numbers = [4,5,8,2,9,7]
    let evenSquares = numbers.map{$0 * $0}.filter{$0 % 2 == 0} //[16, 64, 4]

    展开全文
  • Swift资源库--Map方法

    2016-05-26 09:29:53
    CollectionType Map 在CollectionType的extension中map方法的定义: extension CollectionType { /// Return an `Array` containing the results of mapping `transform` /// over `self`. /// /// - Comp

    CollectionType Map

    CollectionType的extension中map方法的定义:

    extension CollectionType {
        /// Return an `Array` containing the results of mapping `transform`
        /// over `self`.
        ///
        /// - Complexity: O(N).
        @warn_unused_result
        @rethrows public func map<T>(@noescape transform: (Self.Generator.Element) throws -> T) rethrows -> [T]
        ...
    }

    @warn_unused_result:如果没有检查或者使用该方法的返回值,编译器就会报警告。

    @noescape:用在函数的闭包参数上,意味着这个参数是唯一可被调用的(或者用在函数调用时以参数的方式出现),其意思是它的生命周期比函数调用的周期短,这有助于一些小小的性能优化,但最重要的是它屏蔽了闭包中对self.的需求。这使得函数的控制流比其他更加透明。

    throws:可以抛出一个错误的函数或方法必需使用 throws 关键字标记。这些函数和方法被称为抛出异常函数(throwing fu nctions)和抛出异常方法(throwing methods)。

    rethrows:一个函数或方法可以使用 rethrows 关键字来声明,从而表明仅当这个函数或方法的一个函数参数抛出错误时这个函数或方法才抛出错误。这些函数和方法被称为重抛出异常函数(rethrowing functions)和重抛出异常方法(rethrowing methods)。重抛出异常函数或方法必需有至少一个抛出异常函数参数。

    Generator:提到数组我们就会想到遍历,一般的遍历可能都是从头到尾进行的。但是如果你有特殊的需求呢。你可能不想呆板的进行遍历。这时候Generators就可以派上用场了。Generators的存在是进行特殊癖好的数组遍历,其筛选出符合该癖好的下标索引到数组没有元素为止。Self.Generator.Element就是在遍历的元素。

    简化一下map的定义:

    func map<T>(transform: (Self.Generator.Element) -> T) -> [T]

    可以看到,map 方法返回的是一个数组,其获取一个闭包表达式作为唯一参数,集合中的每个元素调用一次该闭包函数,并返回该元素所映射的值(也可以是不同类型的值)。具体的映射方式和返回值类型由闭包来指定。

    看几个简单例子:

    // 例子1:对一个Int类型数组的元素进行2倍放大。如:[1,2,3]->[2,4,6]。
    let arr = [1,2,3]
    let doubled = arr.map{
      $0 * 2
    }
    print(doubled)
    // 输出:[2,4,6]
    // 例子2:用一个Int类型数组存储商品金额,想把每个金额后面添加一个字符“$”,把数组转成字符串数组。如:[10,20,30,40] -> ["10¥","20¥","30¥","40¥"]
    let moneyArray = [10,20,30,40]
    let stringsArray = moneyArray.map{
        "\($0)$"
    }
    print(stringsArray)
    // 输出:["10$","20$","30$","40$"]
    展开全文
  • swift中高阶函数map、flatMap、filter、reduce Swift相比于Objective-C又一个重要的优点,它对函数式编程提供了很好的支持,Swift提供了map、filter、reduce这三个高阶函数作为对容器的支持。1 map:可以对数组中的...

    swift中高阶函数map、flatMap、filter、reduce

      Swift相比于Objective-C又一个重要的优点,它对函数式编程提供了很好的支持,Swift提供了map、filter、reduce这三个高阶函数作为对容器的支持。

    1 map:可以对数组中的每一个元素做一次处理

    // 计算字符串的长度
    let stringArray = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
    func stringcount(string:String) -> Int {
        return string.count
    }
    
    stringArray.map(stringcount)
    
    stringArray.map({string -> Int in
        return string.count
    })
    
    stringArray.map{
        return $0.count
    }

    2 flatMap与map不同之处:

      (1)flatMap返回后的数组中不存在nil,同时它会把Optional解包

    let array0 = ["Apple", "Orange", "Puple", ""]
    
    let arr01 = array0.map { a -> Int? in
        let length = a.count
        guard length > 0 else { return nil }
        return length
    }
    arr01 // [{some 5}, {some 6}, {some 5}, nil]
    
    let arr02 = array0.compactMap { a-> Int? in
        let length = a.count
        guard length > 0 else { return nil}
        return length
    }
    arr02 // [5, 6, 5]
    
        (2)flatMap还能把数组中存有数组的数组(二维数组、N维数组)一同打开变成一个新的数组
    let array1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    
    let arr11 = array1.map{ $0 }
    arr11 // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    
    let arr12 = array1.flatMap{ $0 }
    arr12 // [1, 2, 3, 4, 5, 6, 7, 8, 9]
    
        (3)flatMap也能把两个不同的数组合并成一个数组,这个合并的数组元素个数是前面两个数组元素个数的乘积
    let fruits = ["Apple", "Orange", "Puple"]
    let counts = [2, 3, 5]
    
    let array = counts.flatMap { count in
        fruits.map ({ fruit in
            return fruit + "  \(count)"
        })
    }
    array // ["Apple 2", "Orange 2", "Puple 2", "Apple 3", "Orange 3", "Puple 3", "Apple 5", "Orange 5", "Puple 5"]
    
    3 filer:过滤,可以对数组中的元素按照某种规则进行一次过滤
    // 筛选出字符串的长度小于10的字符串
    let strArray = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
    func stringCountLess10(string: String) -> Bool {
        return string.count < 10
    }
    stringArray.filter(stringCountLess10)
    
    stringArray.filter({string -> Bool in
        return string.count < 10
    })
    
    // $0表示数组中的每一个元素
    stringArray.filter{
        return $0.count < 10
    }
    4 reduce:计算,可以对数组的元素进行计算
    // 将数组中的每个字符串用‘、’拼接
    let strArray1 = ["Objective-C", "Swift", "HTML", "CSS", "JavaScript"]
    
    func appendString(string1: String, string2: String) -> String {
        return string1 == "" ? string2 : string1 + "、" + string2
    }
    // reduce方法中的第一个参数是初始值
    strArray1.reduce("", appendString)
    
    strArray1.reduce("", {(string1, string2) -> String in
        return string1 == "" ? string2 : string1 + "、" + string2
    })
    
    // $0表示计算后的结果, $1表示数组中的每一个元素
    strArray1.reduce("", {
        return $0 == "" ? $1 : $0 + "、" + $1
    })
    






    展开全文
  • map函数使用 /* map用于将每个数组元素通过某个方法进行转换 在Swift中,map被声明成Array类的命名方法: func map(transform: (T) -> U) -> U[] 这个方法以一个命名函数transform作为参数,transform...

    map函数使用

    /*

    map用于将每个数组元素通过某个方法进行转换

    Swift中,map被声明成Array类的命名方法:


    func map(transform: (T) -> U) -> U[]


    这个方法以一个命名函数transform作为参数,transform负责把元素类型T转成类型U并返回一个类型U的数组。


    在上面的事例中,TIntUString,作为转换函数传给map的是一个把Int转成String

    */

    //[10,20,30,40,50] -> [10,20,30,40,50]


    let moneyArr = [10,20,30,40,50]

    //最笨的方法

    var moneyArr1:[String] = []

    for money inmoneyArr {

        let moneyStr = "\(money)"

        moneyArr1.append(moneyStr)

    }

    print("\(moneyArr1)")

    moneyArr1.removeAll()

    print("\(moneyArr1)")


    //使用map函数

    func addChange(a:Int) ->String {

        return "$\(a)"

    }

    moneyArr1 = moneyArr.map(addChange)

    print("\(moneyArr1)")


    //map闭包

    moneyArr1 = moneyArr.map({ (money:Int) ->String in

        return "$$\(money)"

    })

    print("\(moneyArr1)")

    //简写

    moneyArr1 = moneyArr.map({"\($0)"})

    print("\(moneyArr1)")


    moneyArr1 = moneyArr1.sort(>)


    Filter函数

    /*

    filter用于选择数组元素中满足某种条件的元素。

    SwiftfilterArray类中的定义为:


    filter(includeElement: (T) -> Bool) -> T[]


    以返回truefalse的函数includeElement作为参数,对原数组元素调用includeElement时,只有返回true的元素会通过筛选

    */

    var moneyArr2:[Int] = []

    moneyArr2 = moneyArr.filter({ (money:Int) ->Bool in

        money > 40

    })

    print("\(moneyArr2)")

    //简写

    moneyArr2 = moneyArr.filter({$0 >20})

    print("\(moneyArr2)")



    Reduce函数

    /*

    reduce方法把数组元素组合计算为一个值。

    接收两个参数,一个为类型U的初始值,另一个为把类型为U的元素和类型为T的元素组合成一个类型为U的值的函数。最终结果整个数组就变成了一个类型为U的值。


    在事例中UTInt,初始值是0combine函数计算两个Int之和

    */


    var sumMoney:Int

    //初始值为0,计算0+10+20+30+40+50

    sumMoney = moneyArr.reduce(0, combine: { (sum:Int, money:Int) -> Int in

        return sum + money

    })

    //简写

    sumMoney = moneyArr.reduce(0, combine: { $0 + $1})

    print("\(sumMoney)")


    //初始值为2,计算2*10*20*30*40*50

    sumMoney = moneyArr.reduce(2, combine: { $0 * $1})

    print("\(sumMoney)")


    var sumMoneyStr:String;

    sumMoneyStr = moneyArr.reduce("sum = ", combine: { (sum:String, money:Int) -> String in

        return sum + "plus \(money) "

    })

    print(sumMoneyStr)



    展开全文
  • blog.csdn.net/hello_hwc前言:和OC不同,Swift有很多全局的函数,这些全局函数对简化代码来说很有用,目前Swift出到了2.0,不过我这篇文章还是用Swift1.2写的示例代码。Count-统计数量文档func count(x: T) -> T....
  • SequenceType协议中定义的map函数功能很强大,这个函数起源于函数式编程,能够很方便的对数组中的每个元素进行变换处理,关于它的实现原理和使用方法可以参考我的这篇文章:Swift数组变换。今天突然想到,如果数组...
  • map 和 flatMap 是 Swift 中两个常用的函数,它们体现了 Swift 中很多的特性。对于简单的使用来说,它们的接口并不复杂,但它们内部的机制还是非常值得研究的,能够帮助我们够好的理解 Swift 语言map 简介 ...
  • Swift的高阶函数

    2019-08-08 08:40:28
    Swift的高阶函数swift常用高阶函数1. map2. flatMap3. filter4. reduce swift常用高阶函数 swift中比较常用的高阶函数有:map、flatMap、filter、reduce 1. map map可以对数组中的每一个元素做一次处理 // 计算...
  • Swift 这个语言,速度快,更加安全,代码少,易于阅读维护. 所以一些高阶函数在项目实际使用中也是蛮方便的总结如下: 高阶函数的定义:一个函数如果可以以某个函数作为参数,或者返回值,那么这个函数就称之为高阶函数,如...
  • let testArray = ["test1","test1234","","test56"]mapmap函数能够被数组调用,它接受一个闭包作为参数,作用于数组中的每个元素,闭包返回一个变换后的元素,接着将所有这些变换后的元素组成一个新的数组。...
  • 在第二部分,我将会精简我们的代码来让它看起来更 “Swift”,同时向你介绍 map() 和 flatMap() 方法。 今天这篇文章我们将要讨论数组的 map() 和 flatMap() 方法。 本系列文章的第一篇里这是我们上次留下的代码。...
  • iOS swift常用函数

    2018-02-25 15:39:32
    Swift包含了74个内置函数,但在 The Swift Programming Langage 一书中只介绍了其中的7个,其它的都没有在文档中体现。 这篇文章列举出了所有的Swift库函数。文中所谓的 内置函数 是指无需引入任何模块(比如说...
  • map 和 flatMap 是 Swift 中两个常用的函数,它们体现了 Swift 中很多的特性。对于简单的使用来说,它们的接口并不复杂,但它们内部的机制还是非常值得研究的,能够帮助我们够好的理解 Swift 语言
  • 如果一个函数接受别的函数作为参数 ,或者一个函数的返回值是函数,那么这样的函数就叫做高阶函数 (higher-order function)Swift 为我们提供很多高级函数,这也从另一方面说明了swift 比 Objective-C 高级之处 map—...
  • Swift 提供了map、flatMap、compactMap、filer、reduce这几个高阶函数支持。1,map : 可以对数组中的每一个元素做一次处理// 计算字符串的长度 let stringArray = ["Objective-C", "Swift", &...
  • Swift语言中使用Map、Filter、Reduce对Array、Dictionary等集合类型(collection type)进行操作可能对一部分人来说还不是那么的习惯。对于没有接触过函数式编程的开发者来说,对集合类型中的数据进行处理的时候第...
  • map映射一个新数组 在这个例子中,“map”将第一个数组中的 element 转换为小写的字符串,然后计算他们的characters。 let cast = ["Vivien", "Marlon", "Kim", "Karl"] let lowercaseNames = cast.map { $0....
  • Swift语言有很多函数式编程的特性,常见的map,reduce,filter都有,初看和python差不多,下面简单介绍下闭包介绍:闭包是自包含的功能代码块,可以在代码中使用或者用来作为参数传值。假设我们需要两个函数,其中一...
1 2 3 4 5 ... 20
收藏数 4,670
精华内容 1,868
热门标签