Swift 闭包 简单

先吐槽 那些也在上 解释swift 闭包的人 你们他么的是猪嘛 看到别人写好的就他妈知道复制粘贴，你们自己明白嘛 乱七八糟 跟猪一样，看的一脸懵逼，还有 有些写那么详细 干嘛 你们是把apple 的文档 翻译成中文粘过来的嘛 ，有几把毛用，本来就不懂闭包的人 看完更他么不懂，所以你们也是猪

1. 好了 现在开始我的简单教程

/// : Playground - noun: a place where people can play

import UIKit

/// 1.0 初始化一个数组 这每个人都懂
var usernames = ["Lves", "Wildcat", "Cc", "Lecoding"]

/// 2.0 定义一个函数
func backWards(s1: String, s2: String) -> Bool
{
    return s1 > s2
}


/// 3.0 .sorted() 这个是系统特有的
var resultName1 = usernames.sorted(by:backWards)

/// 4.0 打印数组 你会发现 resultName1 的元素 进行了有序的排序
print(resultName1)

/// 5.0 好的 看到这里 你会发现 上面的那部分跟闭包 毛关系没有 真正的闭包从下面开始（上面的只是为了和闭包做个对比，防止混乱）

/// 6.0 闭包开始 首先是闭包的格式

/**
 
     { (parameters) -> returnType in
         statements
     }
 
     { (参数) -> 返回值 in
         闭包代码块
     }
 
 
 *  1.0 闭包必须用 {} 扩起来
 *  2.0 闭包包括 （参数 返回值）（闭包代码块） 而且两者必须用 in 连接起来
 *
 */

/// 7.0 把闭包作为一个参数 代替函数 注意这是一个闭包
/*
        {  (s1: String, s2: String) -> Bool in
 
            return s1 > s2
        }
 */
var resultName2 = usernames.sorted(by:{(s1: String, s2: String) -> Bool in
    
    return s1 > s2
    
})

/// 8.0 函数的最后一个参数是闭包时 () 可省略 只是把括号 （）和 by: 去掉了;
var resultName3 = usernames.sorted{(s1: String, s2: String) -> Bool in
    
    return s1 > s2
}

print(resultName3)

/// 9.0 类型推导 因为 usernames 存储的为字符串 那么这里用到的上下文推到 s1 s2 为 字符串 所以又可以省去一部分 如果数组中存储的是Int 类型 那么类型推导出来就是Int
var resultName4 = usernames.sorted { s1, s2 in
    return s1 > s2
}

/// 10.0 其实我们可以把 return关键字也省了  直接把  s1 > s2  表达式 返回
var resultName5 = usernames.sorted { s1, s2 in s1 > s2 }

/// 11.0 更甚之 swift 还支持 还建议 这样写 果然变态 妈的 看的我都懵逼 忒省了 这些swift 都支持 我觉得我们没必要这样写 看个人喜好
var resultName6 = usernames.sorted(by:>)

/// 12.0 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用： CaluFunction: (_ num3:Int,_ num4:Int) -> Int 这么长一串其实就是一个参数
func caculateTwoNumbers(num1: Int, num2: Int, CaluFunction: (_ num3:Int,_ num4:Int) -> Int) -> Int{
    return CaluFunction(num1, num2)
}

/// 12.1 那么问题 来了 上面这个是如何执行的呢 咋一看 很懵逼 不要纠结 千万不要纠结 看不懂 或者什么的
let resulet1 = caculateTwoNumbers(num1: 2, num2: 3, CaluFunction: {(num3:Int,num4:Int) -> Int in return num3+num4})

/// 答案来 resulet1 = 5 为什么呢 回顾一点 这里的闭包是作为最后一个参数调用的  闭包是什么 是一个参数  CaluFunction: {(num3:Int,num4:Int) -> Int in return num3+num4} 这么长是什么 是一个参数  我们 把 2 3 作为参数传递给 caculateTwoNumbers 这个函数 在这个 函数内部 又调了 CaluFunction: {(num3:Int,num4:Int) -> Int in return num3+num4} 这个闭包  分别把 2 3 赋值给 num3 num4 执行了 return num3+num4 说到这里明白了嘛 不明白 再读一遍 我都写这么清楚了


/// 13.0 什么是逃逸闭包 什么又不是 非逃逸闭包
/// 13.1 闭包只有在函数中做参数时才会区分逃逸闭包和非逃逸闭包  Swift 3.0之后，传递闭包到函数中的时候，系统会默认为非逃逸闭包类型（NonescapingClosures)@noescaping，逃逸闭包在闭包前要添加@escaping关键字。

func doSomething1(num1: Int, num2: Int, CaluFunction: (_ num3:Int,_ num4:Int) -> Int) -> Int{
    print("这就是一个非逃逸的 因为前面没有加@escaping关键字")
    return CaluFunction(num1, num2)
}

func doSomething2(num1: Int, num2: Int, CaluFunction:@escaping (_ num3:Int,_ num4:Int) -> Int) -> Int{
    print("这就是一个逃逸的 因为前面加@escaping关键字")
    return CaluFunction(num1, num2)
}

/// 13.2 那这两个又什么区别呢 为了方便理解 我又拷贝了一份

func doSomething3(num1: Int, num2: Int, CaluFunction: (_ num3:Int,_ num4:Int) -> Int) -> Int{
   
    CaluFunction(num1, num2)
    /// 这里是函数体内部 当执行到  return 2 时 此函数就停止了 闭包也不执行了 这个函数的生明周期就结束了 这个函数中就被释放了 也可以这么理解 包括闭包
    
    return 2
}

func doSomething4(num1: Int, num2: Int, CaluFunction:@escaping (_ num3:Int,_ num4:Int) -> Int) -> Int{
    
    
    /// 而逃逸的 虽然 return 2 执行完毕了 但异步线程中的 还没执行玩 也就是说 异步线程执行完毕仍然会执行闭包 这也是最本质的区别 记住这么多就行了
    DispatchQueue.global().async {
        DispatchQueue.main.async {
            CaluFunction(num1, num2)
        }
    }

    return 2
}

好了 点赞个 收藏一下吧 最好评论一下 不为别的 就是想让那些 复制粘贴的猪们 看看 你写那么多 你复制粘贴那么多 有用嘛 有人看嘛 有人看的懂嘛