您的位置:时时app平台注册网站 > 编程知识 > 闭包

闭包

2019-11-08 01:35

 

//闭包表明式作为bubbleSort1三个函数的实参直接传送给函数
func bubbleSort1(inout array: [Int],cmp:(Int, Int) -> Int) {
let cnt = array.count
for var i = 1; i < cnt; i {
for var j = 0; j < cnt-i; j {
if (cmp(array[j], array[j 1]) == -1){
let t = array[j]
array[j] = array[j 1]
array[j 1] = t
}
}
}
}
let intCmp = {
(a: Int, b: Int) -> Int in
if a > b {
return -1
}else if a < b {
return 1
}else{
return 0
}
}
bubbleSort1(&array, cmp: intCmp)
showArray(array)

 

/*
(3)闭包表明式回调用法
*/

// 劣势, 不显著是小到大, 不必然是任何相比较, 有望只比较个位数

/*
(5)尾随闭包
*/

class SomeClass{

//使用系统方法排序
var array1 = [5,2,56,23,90,67]
//降序
array1.sortInPlace { (a, b) -> Bool in
return a > b
}
showArray(array1)
//升序
array1.sortInPlace {
$0 < $1
}
showArray(array1)

 

/*
(7)闭包捕获值
*/

 

func getIncFunc2(inc: Int) -> (Int) -> Int {
func incFunc(v: Int) -> Int {
//注解为二个里边时,两遍结果都以24
var mt = 10
mt
return inc v mt
}
return incFunc
}
let incFunc3 = getIncFunc2(3)
let incFunc4 = getIncFunc2(3)
print(incFunc3(10))
print(incFunc3(10))
//每种再次来到的闭包都是单身,所以说mt并不会互相的受影响
print(incFunc4(10))

    return a b

//对数组实行排序
var array = [23,2,5,89,56]
func showArray (array: [Int]) {
for x in array {
print("(x) ")
}
}
func bubbleSort(inout array: [Int]) {
let cnt = array.count
for var i = 1; i < cnt; i {
for var j = 0; j < cnt-i; j {
if (array[j] > array[i]){
let t = array[j]
array[j] = array[j 1]
array[j 1] = t
}
}
}
}
showArray(array)
bubbleSort(&array)
showArray(array)

print(incFunc(5))

func bubbleSortFunc(inout array: [Int]) {
let cnt = array.count
//能够在函数的里边宣称二个函数,效用域从它定义的伊始到它所在函数的利落,仅仅为该函数服务;
func swapValue(inout a:Int, inout b:Int){
//内部能够访问bubbleSortFunc函数内部定义的片段变量
print("数组个数(cnt)")
let t = a
a = b
b = t
}
for var i = 1; i < cnt; i {
for var j = 0; j < cnt-i; j {
if (array[j] > array[j 1]){
swapValue(&array[j], b: &array[j 1])
}
}
}
}
var array2 = [3,6,23,56,2,7]
bubbleSortFunc(&array2)
showArray(array2)

        return 1

//定义贰个有参函数,重回值为三个闭包
func getIncFunc(inc: Int) -> (Int) -> Int {
func incFunc(v: Int) -> Int {
//inc是在外界定义的
return inc v
}
return incFunc
}
let incFunc1 = getIncFunc(3)
//inc = 3,v = 10,结果是13
print(incFunc1(10))

        return 0;

/*
(1)闭包的概念和归类
自包含的函数代码块
大局函数 (知名)
闭包表明式 (无名氏) -- 能补货上下文中的常量恐怕变量
嵌套函数 (*)
*/

    }

/*
(6)嵌套函数:在函数内部定义完毕的函数
*/

say2("HaRi")

/*
闭包表达式语法的优化
*/
//可以简简单单参数的项目,前提是在bubbleSort1函数中已经宣称过类型,这里运用斯威夫特的编写翻译预计机制
bubbleSort1(&array) { (a, b) in
let x = a % 10, y = b % 10
if x > y {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
showArray(array)
//也得以优化为如下
bubbleSort1(&array) {
//第多个参数用$0表示,后边的参数三次类推
let x = $0 % 10, y = $1 % 10
if x > y {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
showArray(array)

bubbleSort(array: &arr){

//无参无重回值的闭包表明式
let sayHello = {
print("hello World")
}
sayHello()
//有参数有再次来到值
let add: (Int, Int) -> Int = { (a: Int, b: Int) -> Int in
return a b
}
print(add(1, 8))

// 2.重返值优化, 同理由于函数中曾经宣称了闭包的回来值类型,所以传入的实参可以不用写类型

//要是依据个位数大小实行排序,只需改过闭包里面包车型客车艺术即可
let intCmp1 = {
(a: Int, b: Int) -> Int in
let x = a % 10, y = b % 10
if x > y {
return -1
}else if x < y {
return 1
}else{
return 0
}
}
bubbleSort1(&array, cmp: intCmp1)
showArray(array)

}

/*
(2)闭包表明式的语法
//函数表明式
func funcName(参数) -> 再次回到值类型 {
试行语句
}
//闭包表明式
{ (参数) -> 再次来到值类型 in
实践语句
}
*/

    cloure()

func getIncFunc1(inc: Int) -> (Int) -> Int {
var mt = 10
func incFunc(v: Int) -> Int {
//mt为外界变量,incfunc能够捕获该值
mt
return inc v mt
}
return incFunc
}
let incFunc2 = getIncFunc1(3)
//v=10,inc=3,mt=11,结果24
print(incFunc2(10))
//v=10,inc=3,mt=12这时候记下了mt上次的值11,mt 之后成为12,结果为25;IncFunc捕获了mt值
print(incFunc2(10))

func showArray(array:[Int]) {

//别误操作产生了巡回引用!而非逃逸包能够隐式援用self。

// 完整写法

 

    }else

}

    {

/*

            }

}

    }

})

}

    }

 

//例子如下:

    print("逃逸闭包")

 语法: in关键字的指标是造福区分再次来到值和实施语句

*/

    {

}

//补充比较:

    completionHandlers.append(completionHandler)

 

func bubbleSort(array : inout [Int], cmp: (Int, Int) -> Int){

/*

 

// 假设闭包是最后三个参数, 能够直接将闭包写到参数列表前边, 那样能够压实阅读性, 称之为尾随闭包

 

 

 

showArray(array: arr)

 

//例1:

//若是闭包未有参数,能够一向省略“in”

        someFunctionWithNonescapingCloure {

 逃逸闭包:

    {

let say:(String) -> Void = {

 当叁个闭包作为参数字传送到二个函数中,须求以此闭包在函数再次来到之后才被施行,大家就称该闭包从函数种临阵退缩。平时如若闭包在函数体内涉及到异步操作,但函数却是超级快就能够进行达成并回到的,闭包应当要逃跑掉,以便异步操作的回调。

doSomthing2 { () -> String in

}

            if array[j] > array[j 1]

print(array.count) // 3

        return 0

    }else

{

        return -1

let say2:(String) -> Void = {

print("__________________________")

 闭包表明式(佚名函数) -- 能够捕获上下文中的值

var arr:Array<Int> = [23, 34, 56, 15, 8]

//=======================================================

        return 0;

                let temp = array[j]

 

 

 

    (a: Int, b:Int) ->Int in

    }

        return max x

    (a:Int,b:Int) -> Int in

 

print(array.count) // 4

        for j in 0..<(array.count - 1) {

        }

// 未有再次来到值写法

    if a > b{

    print("函数体")

    print("hello xiaohange")

    {

 

}

        return 0

}

/** 闭包表明式作为回调函数 **/

print(calAdd3(50,200))

 自动闭包让您可以预知延缓求值,直到调用这一个闭包,闭包代码块才会被实践。说白了,便是语法简洁了,有一点点懒加载的意味。

showArray(array: [1,2,3,4])

        print("incFunc函数甘休")

 

 

        }

        {

    var max = 10

}

                array[j 1] = temp

 函数是闭包的黄金年代种

            }

}

bubbleSort(array: &arr, cmp: cmp)

say3()

var completionHandlers: [() -> Void] = []

var array = ["1","100","hi","hello"]

    {

    (a: Int, b: Int) -> Int in

            {

    a,b in  //也能够写成(a,b) in

    return "还是不约吧!"

        someFuncionWithEscapingClosure {

    }

let say3:() ->Void = {

showArray(array: arr)

say("HaRi")

let calAdd:(Int,Int)->(Int) = {

}

 

    (name: String) -> Void in

 

    {

    return incFunc

print(incFunc(5))

 

    for num in array {

// 闭包表明式优化,

let calAdd3:(Int,Int)->(Int) = {(a,b) in a b}

    for var i = 1; i < count; i

       some()

        return 1

    comletionHandle = some

}

doSomething {

 平时格局:{

 看名就能够知道意思,自动闭包是生龙活虎种电动创制的闭包,封装一批表达式在机动闭包中,然后将电动闭包作为参数字传送给函数。而活动闭包是不采取任何参数的,但足以回来机关闭包中表明式发生的值。

 */

    var x = 10

        print("(num)")

    }

let hello = {

 

    // 同理, 当施行完这一句时max变量就被放出了, 可是由于在中间函数中运用到了它, 所以它被破获了.

 

    {

let incFunc2 = getIncFunc(inc: 5)

        }

{

}

    func doSomething()

print(calAdd(100,150))

}

// 所以, 怎样相比较能够提交调用者决定

 

//日常格局

        return 1;

 闭包表明式的系列和函数的体系相似, 是参数加上再次来到值, 也正是in以前的一些

calAdd5()

    //延时操作, 注意这里的单位是秒

 自动闭包:

bubbleSort(array: &arr){

        return 1

//Swift能够依靠闭包上下文揣度参数和重返值的类型,所以地点的事例能够简化如下

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() 1) {

// 如若独有一条语句能够简轻松单 return

       // 1s后操作

//例2:

//逃逸

 

            self.x = 100

 施行语句

//其实@escaping和self都以在提示您,那是贰个潜逃闭包,

 

    }

 

//非逃逸

    }else

        max = 1

//单行表明式闭包能够隐式重临,如下,省略return

 

    }

    let count = array.count;

 (parameters) -> returnType in

 

 

 }

            x = 200

print(comletionHandle())

 

    }

    {

func someFuncionWithEscapingClosure(completionHandler: @escaping () -> Void)

let calAdd5:()->Void = {print("我是250")}

 

    // 当施行到这一句时inc参数就相应被放飞了, 不过由于在里边函数中利用到了它, 所以它被擒获了;

func getIncFunc(inc: Int) -> (Int) -> Int

//那几个写法,我任由写的。打字与印刷出“作者是250”

 

    (name: String) -> Void in

 statements

 

func doSomthing2(some: @escaping() -> String) {

    func incFunc(x: Int) ->Int{

/*

func doSomething(some: @escaping() -> Void) {

print(calAdd2(150,100))

let removeBlock = {array.remove(at: 3)}

 

 

let calAdd2:(Int,Int)->(Int) = {

//当捕获的值回合与之对应的不二秘诀绑定在一块, 同意个主意中的变量会被绑定到区别的方法中

 

print("....(calAdd4())")

}

                array[j] = array[j 1]

 逃逸闭包日常用来异步函数的回调,比如互连网央求成功的回调弄整理停业的回调。语法:在函数的闭包行参前加关键字“@escaping”。

    print("hello (name)")

print("__________________________")

 

}

// 1.类型优化, 由于函数中风流倜傥度宣示了闭包参数的花色, 所以传入的实参能够不用写类型

}

 (参数) -> 重临值类型 in

    if $0 > $1{

}

        return -1

        }

print(incFunc2(5))

/*

                array[j] = array[j 1]

 

    }else if $0 < $1

    }else if a < b

    }else if a < b

    }else

                array[j 1] = temp

// 闭包捕获值

 

    if a > b{

 }

    print("getIncFunc函数截止")

        return -1;

// 3.参数优化, swift能够动用$索引的点子来做客闭包的参数, 默许从0起头

 类似于OC语言的block

    "I'm XiaoHange"

 

 

print(array.count) // 4

//下边省略了回去箭头和参数及重临值类型,甚至参数周边的括号。当然你也能够加括号,为了雅观点,看的清楚点。(a,b)

 

print("试行代码块移除(removeBlock())")

    }else if a < b

}

//这些是既未有参数也没重临值,所以把return和in都简单了

 */

    {

bubbleSort(array: &arr, cmp: {

//将叁个闭包标识为@escaping意味着你必得在闭包中显式的援用self。

 

{

print("__________________________")

{

            if array[j] > array[j 1] {

    for _ in 0..<array.count {

let cmp = {

 

func bubbleSort(inout array:[Int])

 */

}

                let temp = array[j]

    }

 {

    print("hi (name)")

// 闭包作为参数字传送递

print(hello())

var comletionHandle:() -> String = {"约吗?"}

    if a > b{

let incFunc = getIncFunc(inc: 5)

func someFunctionWithNonescapingCloure(cloure: () -> Void)

    return a b

    {

 闭包:

let calAdd4:()->Int = {return 100 150}

 

        for var j = 0; j < (count - i); j

    (a: Int, b: Int) -> Int in

        return -1

 

本文由时时app平台注册网站发布于编程知识,转载请注明出处:闭包

关键词: