美文网首页
swift-函数

swift-函数

作者: AlliumLiu | 来源:发表于2019-04-21 14:30 被阅读0次

要了解swift的函数和闭包，首先要了解三件事

  1. 函数可以像String 和 Int 那样可以赋值给变量，也可以作为另一个函数的参数和返回值。（函数是头等对象，这一点最重要）
  2. 函数能捕获存在于其作用域之外的变量。
  3. 有两种方式可以创建函数。一种是使用func关键字，另一种是 {}。在swift中后一种被称为闭包。
var str = "Hello, playground"
/// MARK: ---------------------变量
func printInt(i: Int) {
    print("you passed \(i)")
}

// 函数赋值 不加括号
let funVar = printInt

funVar(1)

// 一个接收函数作为参数的函数

func useFunction(function: (Int) -> Void) {
    function(2)
}

useFunction(function: printInt)

useFunction(function: funVar)

// 也可以返回一个 函数

func returnFunc() -> (Int) -> String {
    func innerFunc(i: Int) -> String {
        return "you passed \(i)"
    }
    return innerFunc
}

let myFunc = returnFunc()
myFunc(3)

/// MARK: ---------------------值捕获
// 当函数应用了函数作用域外部的变量时， 这个变量就被捕获了，它将在超出函数作用域后继续存在，而不是结束。

func counterFunc() -> (Int) -> String {
    var counter = 0
    func innerFunc(i: Int) -> String {
        counter += i
        return "running total: \(counter)"
    }
    return innerFunc
}
// counter 将会保存在堆上
let f = counterFunc()
f(3)
f(4)
// 创建新的函数会生成新的counter 不会影响f
let g = counterFunc()

g(2)
g(3)
// 在 编程中 一个函数和它捕获的环境变量组合起来称之为闭包

/// MARK: ---------------------闭包
// 函数可以用{}来声明闭包表达式 使用闭包来定义函数可以称之为函数的字面量 类似于 1 就是整数的字面量， “hello” 是字符串的字面量。
// 闭包与函数区别在于 它没有名字 只能直接赋值给一个变量
// 但是它和函数完全等价 甚至拥有同一个 命名空间
func doubler(i: Int) -> Int {
    return i*2
}

let doubilerAlt = { (i: Int) -> Int in return i*2 }

[1, 2, 3, 4].map(doubilerAlt)

// 闭包可以简写

[1, 2, 3, 4].map{ $0*2 }

// 闭包可以不声明变量类型 也可以事先指定 闭包使用时一般已经有上下文所以第二种写法不重要


let isEven = {$0 % 2 == 0} ///会默认推定为 （Int） -> Bool

let isEvenAlt = {(i: Int) -> Bool in
    return i % 2 == 0
}

/// 总结：闭包是函数和捕获变量的组合，{}创建的函数是闭包表达试 我们称之为闭包但其实它与函数并无区别，它们都可以是函数也都可以是闭包

函数的灵活性

// 实现排序
let myArray = [3, 1, 2]

myArray.sorted(by: >)

/// 或者提供一个复杂的函数 来任意规则排序

let annimals = ["elephant", "zebra", "dog"]

annimals.sorted { v1, v2 in
    let l = v1.reversed()
    let r = v2.reversed()
    return l.lexicographicallyPrecedes(r)
}

/// 使用OC 写一个复杂的排序

final class Person: NSObject {
    @objc var first: String
    @objc var last: String
    @objc var yearOfBrith: Int

    init(first: String, last: String, year: Int) {
        self.first = first
        self.last = last
        self.yearOfBrith = year
    }
}

let people = [
    Person(first: "jo", last: "smith", year: 1970),
    Person(first: "joe", last: "smith", year: 1970),
    Person(first: "joe", last: "smyth", year: 1970),
    Person(first: "joanne", last: "smith", year: 1985),
    Person(first: "joanne", last: "smith", year: 1970),
    Person(first: "robet", last: "smith", year: 1970),
]

/// OC 中 类型不安全 依赖运行时的方式
let lastDesciptor = NSSortDescriptor(key: #keyPath(Person.last), ascending: true, selector: #selector(NSString.localizedCaseInsensitiveCompare(_:)))
let firstDesciptor = NSSortDescriptor(key: #keyPath(Person.first), ascending: true, selector: #selector(NSString.localizedCaseInsensitiveCompare(_:)))
let yearDesciptor = NSSortDescriptor(key: #keyPath(Person.yearOfBrith), ascending: true)

let descriptors = [lastDesciptor, firstDesciptor, yearDesciptor]

(people as NSArray).sortedArray(using: descriptors)


/// 使用swift函数 不能实现 year排序  （lexicographicallyPrecedes 顺序执行 成功一个就返回）

people.sorted { (p0, p1) -> Bool in
    let left = [p0.last, p0.first]
    let right = [p1.last, p1.first]
    return left.lexicographicallyPrecedes(right, by: { (v1, v2) -> Bool in
        return v1.localizedCaseInsensitiveCompare(v2) == .orderedAscending
    })
}
/// MARK: ---------------------函数作为数据 用函数来描述对象的数据
typealias SortDescriptor<Value> = (Value, Value) -> Bool

let sortByYear: SortDescriptor<Person> = { $0.yearOfBrith < $1.yearOfBrith }
let sortByLastName: SortDescriptor<Person> = { $0.last.localizedCaseInsensitiveCompare($1.last) == .orderedAscending }
let sortByFirstName: SortDescriptor<Person> = { $0.first.localizedCaseInsensitiveCompare($1.first) == .orderedAscending }

/// 封装一个 和 NSSortDescriptor 类似的函数 但不涉及运行时 接受一个键 和一个 比较方法 返回一个排序描述 SortDescriptor 函数
/// 在这里key 也是一个 函数 (用于取值)

func sortDescriptor<Value, Key>(key: @escaping (Value) -> Key,
                                _ areInIncreaingOrder: @escaping (Key, Key) -> Bool) -> SortDescriptor<Value> {
    return { areInIncreaingOrder(key($0), key($1)) }
}

let sortByYearAt: SortDescriptor<Person> = sortDescriptor(key: {$0.yearOfBrith}, <)
people.sorted(by: sortByYearAt)

/// 为Compareable 重载一个函数

func sortDescriptor<Value, Key>(key: @escaping (Value) -> Key) -> SortDescriptor<Value> where Key: Comparable {
    return { key($0) < key($1) }
}

/// 上面的 sortDescriptor 返回都是 Bool 函数 NSSortDescriptor 有一种返回 升序 降序 相等的初始化
func sortDescriptor<Value, Key>(key: @escaping (Value) -> Key,
                                ascending: Bool = true,
                                _ comparetor: @escaping (Key)
    -> (Key) -> ComparisonResult)
    -> SortDescriptor<Value> {
    return { lhs, rhs in
        let order: ComparisonResult = ascending ? .orderedAscending : .orderedDescending
        return comparetor(key(lhs))(key(rhs)) == order
    }
}
/// 这样 我们就实现了 一个 NSSortDescriptor 相同能力的函数 但是它具有类型安全 不依赖运行时
let sortByFirstNameAt: SortDescriptor<Person> = sortDescriptor(key: {$0.first}, String.localizedCaseInsensitiveCompare)
people.sorted(by: sortByFirstNameAt)

/// 再写一个 工作方式 类似于 sortedArra(using:) 的功能的函数
func combine<Value> (sortDescriptors: [SortDescriptor<Value>]) -> SortDescriptor<Value> {
    return { lhs, rhs in
        for areInIncreasingOrder in sortDescriptors {
            if areInIncreasingOrder(lhs, rhs) {
                return true
            }
            if areInIncreasingOrder(rhs, lhs) {
                return false
            }
        }
        return false
    }
}
/// 这样我们就可以重写OC的方法了

let combind: SortDescriptor<Person> = combine(sortDescriptors: [sortByLastName, sortByFirstName, sortByYear])

people.sorted(by: combind)
/// swift作为编译时就确定了静态类型的语言 也能 实现部分动态行为
/// combine 展示了这种合并函数的函数的用法

/// MARK: --------------------- 定义一个合并函数的运算符

infix operator <||> : LogicalDisjunctionPrecedence

func <||><A>(lhs: @escaping(A, A) -> Bool, rhs: @escaping(A, A) -> Bool) -> (A, A) -> Bool {
    return { x, y in
        if lhs(x, y) {
            return true
        }
        if lhs(y, x) {
            return false
        }
        if rhs(x, y) {
            return true
        }
        return false
    }
}

/// 再次优化

let combindAt = sortByLastName <||> sortByFirstName <||> sortByYear

people.sorted(by: combindAt)

/// 实现 localizedCaseInsensitiveCompare 应用到可先值

func lift<A>(_ compare: @escaping (A) -> (A) -> ComparisonResult)
    -> (A?) -> (A?) -> ComparisonResult {
        return { lhs in { rhs in
            switch (lhs, rhs) {
            case (nil, nil):
                return .orderedSame
            case (nil, _):
                return .orderedAscending
            case (_, nil):
                return .orderedDescending
            case let (l?, r?):
                return compare(l)(r)
            default:
                 fatalError()
            }
        }
    }
}

let lcic = lift(String.localizedCaseInsensitiveCompare)

/// swift 使用内省排序 不能保证相同值的顺序 是不稳定的

局部函数和变量捕获

  • 实现一个 稳定排序归并排序，首先拆分待排序的数组，然后进入合并merge，我们将merge单独定义为一个函数，但是merge需要一个临时的存储空间。
extension Array where Element: Comparable {
    private mutating func merge(lo: Int, mi: Int, hi: Int) {
        print("lo:\(lo) mi:\(mi) hi:\(hi)")
        var temp: [Element] = []
        var i = lo, j = mi
        while i != mi && j != hi {
            if self[j] < self[i] {
                temp.append(self[j])
                j += 1
            } else {
                temp.append(self[i])
                i += 1
            }
            print(temp)
        }
        print(temp)
        temp.append(contentsOf: self[i..<mi])
        print(temp)
        temp.append(contentsOf: self[j..<hi])
        print(temp)
        replaceSubrange(lo..<hi, with: temp)
        print(self)
    }

    mutating func mergeSortInPlaceInefficient() {
        let n = count
        var size = 1

        while size < n {
            for lo in stride(from: 0, to: n - size, by: size * 2) {
                merge(lo: lo, mi: lo + size, hi: Swift.min(lo + size * 2, n))
            }
            size *= 2
        }
    }
}
//var array: [Int] = [10, 5, 5, 100, 80, 200, 6, 4, 88, 700]
//array.mergeSortInPlaceInefficient()

/// 只用一个局部变量

extension Array where Element: Comparable {
    mutating func mergeSortInPlace() {
        // 定义所有merge的临时储存
        var temp: [Element] = []
        // 保证它足够大
        temp.reserveCapacity(count)

        func merge(lo: Int, mi: Int, hi: Int) {
            print("lo:\(lo) mi:\(mi) hi:\(hi)")
            temp.removeAll(keepingCapacity: true)
            var i = lo, j = mi
            while i != mi && j != hi {
                if self[j] < self[i] {
                    temp.append(self[j])
                    j += 1
                } else {
                    temp.append(self[i])
                    i += 1
                }
                print(temp)
            }
            print(temp)
            temp.append(contentsOf: self[i..<mi])
            print(temp)
            temp.append(contentsOf: self[j..<hi])
            print(temp)
            replaceSubrange(lo..<hi, with: temp)
            print(self)
        }

        let n = count
        var size = 1

        while size < n {
            for lo in stride(from: 0, to: n - size, by: size * 2) {
                merge(lo: lo, mi: lo + size, hi: Swift.min(lo + size * 2, n))
            }
            size *= 2
        }
    }
}

var array: [Int] = [10, 5, 5, 100, 80, 200, 6, 4, 88, 700]
array.mergeSortInPlace()

函数作为代理

  • 如果代理只是一个简单的方法那么可以使用函数来取代
var str = "Hello, playground"
/// MARK: ---------------------归并排序

//protocol AlertViewDelegate: class {
//    func buutonTapped(index: Int)
//}

//class AlertView {
//    var buttons: [String]
//    weak var delegate: AlertViewDelegate?
//    init(buttons: [String] = ["ok", "cancel"]) {
//        self.buttons = buttons
//    }
//
//    func fire() {
//        delegate?.buutonTapped(index: 1)
//    }
//}
// 有时候 我们希望一个结构体实现代理 那么 weak 就不能用了 就有可能内存泄漏
//protocol AlertViewDelegate {
//    mutating func buutonTapped(index: Int)
//}
//
//class AlertView {
//    var buttons: [String]
//    var delegate: AlertViewDelegate?
//    init(buttons: [String] = ["ok", "cancel"]) {
//        self.buttons = buttons
//    }
//
//    func fire() {
//        delegate?.buutonTapped(index: 1)
//    }
//}
//
//// 我们创建一个记录所有事件的结构体 它会被复制 还会失去 结构体信息
//
//struct TapLogger: AlertViewDelegate {
//    var taps: [Int] = []
//    mutating func buutonTapped(index: Int) {
//        taps.append(index)
//    }
//}
//
//let av = AlertView()
//var logger = TapLogger()
//av.delegate = logger
//logger.taps

// 两者都有缺陷  那么 就 使用函数而非代理

class AlertView {
    var buttons: [String]
    var callback: ((Int) -> Void)?
    init(buttons: [String] = ["ok", "cancel"]) {
        self.buttons = buttons
    }

    func fire() {
        callback?(1)
    }
}

struct TapLogger {
    var taps: [Int] = []
    mutating func buutonTapped(index: Int) {
        taps.append(index)
    }
}

let av = AlertView()

var logger = TapLogger()

av.callback = { logger.buutonTapped(index: $0) }
// 额外好处是命名解耦  甚至我们可以用匿名函数

class Test {
    func buttonTapped(index: Int) {
        print(index)
    }
}


let test = Test()
av.callback = test.buttonTapped

/// 这样av 就强引用了一个 test
av.callback = { [weak test] index in
    test?.buttonTapped(index: index)
}

inout 参数和可变方法

�* 不要被C和C++ 的& 误导 swift 中 inout 不是执行引用传递 而是值传递。它把值传入修改最后替换原来的值。

*为了了解什么样表达式可以当做inout 先要了解 lvalue：描述一个内存地址(array[0]); rvalue ：描述一个值(4)

*对于inout函数 传入的是lvalue, 我们不可能对一个 rvlaue修改

func increment(value: inout Int) {
    value += 1
}

var i = 0 // 此处不能使用let
increment(value: &i)

var array = [1, 2, 3]

increment(value: &array[0]) // 所有的下标都适用 所有 有 get 和 set 都可以

struct Point {
    var x: Int
    var y: Int
}

var po = Point.init(x: 1, y: 2)
increment(value: &po.x)


extension Point {
    var square: Int {
        return x*x + y*y
    }
}

/// 嵌套函数inout

func incrementTenTimes(value: inout Int) {
    func inc() {
        value += 1
    }
    for _ in 0..<10 {
        inc()
    }
}

var x = 0
increment(value: &x) //不能让这个inout参数逃逸
// inout的值 会在函数返回之前复制回去 那么函数返回之后怎么办 值改变后在复制吗？资源不存在怎么办

//func escapeIncrement(value: inout Int) -> () -> () {
//    func inc () {
//        value += 1
//    }
//    return inc // 不行🚫
//}

计算属性和下标

  • 有两种方法和其他方法是不同的 那就是 计算属性和下标
  • 计算属性看起来像属性 但是它不使用内存， 而下标则是遵守特殊规定 定义和调用的方法
import CoreLocation
//struct GPSTrak {
//    var record: [(CLLocation, Date)] = []
//}

struct GPSTrack {
    private(set) var record: [(CLLocation, Date)] = [] // 外部只读 内部可读写
}

extension GPSTrack {
    var date: [Date] { // 计算属性
        return record.map{ $0.1 }
    }
}

/// 延时储存属性 自动声明为mutating 因此必须声明为var

class GPSTrackViewController: UIViewController {
    var track = GPSTrack() // track发生变化 preview 不会自动更新.

    lazy var preview: UIImage = { // 可以把它 推迟到首次调用
        for po in self.track.record {
            // 昂贵计算
        }
        return UIImage()
    }()
}

自动闭包

  • 例如&&这种操作符叫短路求值 只有左边true时右边才会求值
  • 几乎所有的语言 短路求值都是内建在语言的值中无法自己定义
  • swift支持闭包 我们可以通过闭包模拟短路求值
let events = [2, 4, 6]

if !events.isEmpty && events[0] > 10 {
    // 执行
}

func and(_ l: Bool, _ r: @autoclosure () -> Bool ) -> Bool { // && 类似的函数
    guard l else {
        return false
    }
    return r()
}

if and(events.isEmpty, events[0] > 10) {
    // 执行
}

/// 自动闭包实 条件true 现日志输出

func log(condition: Bool,
         message: @autoclosure () -> String,
         file: String = #file,
         function: String = #function,
         line: Int = #line) {
    if condition {
        return
    }
    print("myAssert failed:\(message()), \(file):\(function):(line:\(line))")
}

log(condition: true, message: "this is test")
log(condition: false, message: "this is test")

/// 在处理闭包试 我们要格外小心内存 为了避免循环引用我们使用 [weak xxx]
/// 一个保存在某个地方等待调用的闭包称为 逃逸闭包（比如函数返回以后）， 而像map这种闭包被直接使用不会改变闭包中值捕获的引用计数
/// 是否要声明 @escaping 编译器会验证

相关文章

  • 跟着洲洲哥一块学习Swift-函数

    本文首发地址 Swift-函数 当你定义一个函数时，你可以选择性地定义一个或多个名称，类型值作为函数的输入（称为形...

  • Swift-函数

    函数的定义与调用 无参数函数，有返回值（返回值类型String） 多参数函数,有返回值（返回值类型String） ...

  • Swift-函数

    1.函数的定义和调用 定义一个函数时,可以定义一个或多个有名字和类型的值,作为函数的输入,称为参数,也可以定义某种...

  • swift-函数

    函数也可以作为一个类型（引用类型） 变长的参数类型一个函数最多只有一个变长的参数类型 交换2个数的值inout 代...

  • Swift-函数

  • Swift-函数

    e.g.1 e.g.2: 使用元组返回多个值 e.g.3: 调用时隐藏变量名 e.g.4: 默认参数和可变参数 e...

  • Swift-函数

    重新阅读了Swift中文文档的函数章节，总结出以下文档中提到的13种函数，归纳如下:

  • Swift-函数

    定义和调用函数 在下面的例子中的函数叫做greet（person :)，因为这是它的作用 - 它需要一个人的名字作...

  • Swift-函数

    定义函数 定义：func 函数名(参数1: 类型, 参数2: 类型, ...) -> 返回结果的类型 {执行语句}...

  • Swift-函数

    一、函数1、定义一个无参无返回值的函数并进行调用：func eat(){print(“eating”)}调用函数：...

网友评论

      本文标题：swift-函数

      本文链接：https://www.haomeiwen.com/subject/ibxjgqtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|swift-函数|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！