美文网首页
函数类型与闭包

函数类型与闭包

作者: 霏誠拜咬o | 来源:发表于2016-07-08 17:36 被阅读0次

函数类型

  • 函数类型定义:(参数类型1,参数类型2,……)->返回值类型
  • 函数类型是一种引用类型,类似于函数指针。可以将函数类型应用于任何使用类型的地方:变量、参数、返回值。
  • 函数类型实例化支持:
    • 全局函数
    • 嵌套函数
    • 成员函数(实例方法 与 静态方法)
func add(x:Double, y:Double)->Double{
  return x+y
}

func minus(x:Double, y:Double)->Double{
  return x-y
}

func mulitiply(x:Double, y:Double)->Double{
  return x*y
}

func divide(x:Double,y:Double)->Double{
  return x/y
}

class Matrix{
  var row=0.0
  var column=0.0

  init(row:Double ,colomn:Double){
    self.row=row
    self.column=column
}

  func process(x:Double, y:Double)->Double{
    return x*row+y*column
}
  
  static func invoke(x:Double, y:Double)->Double{
    return x*y+y*y
}
}
//函数类型作为变量
var compute:(Double, Double)->Double

compute=add //全局函数
let result1=compute(100,200)

compute=divide
let result2=compute(300,40)

var matrix=Matrix(row:10.0,column:20.0)
compute=matrix.process //实例方法
//compute.object=matrix
//compute.method=&process
compute(80,60)//JMP  compute.method

compute=Matrix.invoke //静态方法
compute(30,40)

//函数类型作为参数
func process(math: (Double,Double)->Double,x:double,y:Double){
  let result=math(x,y)
  print("result:\(result)")  
}

process(multiply,x:30,y:50)

//函数类型作为返回值
func calculateFunction(symbol:String)->(Double,Double)->Double{
  switch(symbol){
  case "+":
           return add
  case "-":
           return minus
  case "*":
           return multiply
  case "/":
           return divide
  default:
      return add
  }
}

var calculate=calculateFunction("-")
let result3 = calculate(300,80)

//嵌套函数
func algorithmFunction(symbol:String)-> (Double, Double)->Double{
  func add(x:Double, y:Double)->Double{
    return x+y
  }

  func minus(x:Double, y:Double)->Double{
    return x-y
  }

  func mulitiply(x:Double, y:Double)->Double{
    return x*y
  }

  func divide(x:Double,y:Double)->Double{
    return x/y
  }
  switch(symbol){
    case "+":
           return add
    case "-":
           return minus
    case "*":
           return multiply
    case "/":
           return divide
    default:
      return add
  }
}

var algorithm=algorithmFuntion("/")
let result4 = algorithm(600,80)
函数类型的内存模型.png

compute=全局函数时,对象指针为空
认识闭包Closure
=====================

  • 闭包是函数类型的实例,一段自包含的代码块,可被用于函数类型的变量,参数或返回值。

  • 三种闭包形式:

    • 全局函数:具名函数,但不捕获任何值
    • 嵌套函数:在函数内部嵌套定义具名函数,可捕获包含函数中的值
    • 闭包表达式:匿名函数类型实例,不具名的代码块,可捕获上下文中的值
  • 闭包是引用类型,闭包变量拷贝具有引用语义。

  • 闭包和函数类型实例拥有同样的内存模型。

class Rectangle {
  var width=0
  var length=0

  init(width:Int, length:Int){
    self.width=width
    self.length=length
  }
}

func <= (left: Rectangle, right: Rectangle) -> Bool {
  return left.width*left.length<=right.width*right.length
}

func compare(first:Rectangle, second: Rectangle)->Bool{
  return first.width*first.length<=second.width*second.length
}

var rects = [Rectangle(width:6,length:7),
             Rectangle(width:5,length:8),
             Rectangle(width:9,length:6)]

//函数类型对象
/*
func sort(@noescape isOrderedBefore: (Self.Generator.Element,Self.Generator.Element) -> Bool) -> [Self.Generator.Element]
*/
//func sort(isOrderedBefore:(Rectangle,Rectangle)->Bool)->[Rectangle]

var predict:  (Rectangle,Rectangle)->Bool
predict=compare
rects.sort(predict)

rects.sort(compare) //不用上面那样绕


//闭包表达式
rects.sort({(first:Rectangle, second:Rectangle)->Bool in

  return first.width*first.length<=second.width*second.length
})


let expression={(first:Rectangle, second:Rectangle)->Bool in
  return first.width*first.length<=second.width*second.length
}
rects.sort(exprssion)//也可以这么写

//自动类型推断
rects.sort({first,second in
  return first.width*first.length<=second.width*second.length
})

//单表达式省略return
rects.sort({first,second in first.width*first.length<=second.width*second.length})

//参数缩略形式
rects.sort({$0.width*$0.length<=$1.width*$1.length})

//操作符缩略式
rects.sort( <= ) //rects.sort(compare)

//尾随闭包
rects.sort{
  first,second in
  first.width*first.length<=second.width*second.length
}

rects.sort{$0.width*$0.length<=$1.width*$1.length}

//自动闭包
var cities = ["Beijing","shanghai","New York","Paris","London"]
print(cities.count)

let filter = {cities.removeLast()}//()->String
print(cities.count)

print("Deleting\(filter())!")
print(cities.count)

闭包表达式

{(参数1,参数2……)->返回值类型 in
语句块
}

  • 几种简化缩写形式:
    • 自动类型推断:省略参数类型和返回值类型
    • 单表达式闭包可以省去return关键词。
    • 使用参数缩略形式$0,$1...省略参数声明和in
    • 将操作符函数自动推导为函数类型
    • 尾随闭包:当闭包表达式为函数最后一个参数,可将其写在括号后
    • 自动闭包:不接受任何参数,直接返回表达式的值。允许延迟计算

函数类型与闭包的变量捕获

  • 函数类型和闭包可以捕获其所在上下文的任何值:

    • 函数参数
    • 局部变量
    • 对象实例属性
    • 全局变量
    • 类的类型属性
  • 如果捕获值生存周期小于闭包对象(参数和局部变量),系统会将被捕获的值封装在一个临时对象里,然后在闭包对象上创建一个对象指针,指向该临时对象。

  • 临时对象和闭包对象之间是强引用关系,生存周期跟随闭包对象。

var data=100

//捕获实例属性
class Rectangle{
  var width=0
  var length=0

  static var max=100

  init(width:Int,length:Int){
    self.width=width
    self.length=length
  }

  func getComputeHandler()->() -> Int{
    return {
      return self.width*self.length
    }
  }
}
var rect=Rectangle(width:10,length:20)
var handler=rect.getComputeHandler()
handler()

//捕获参数或局部变量
func addHandler(var step: Int) -> () -> Int {
  var sum = 0
  return {
    sum += step
    data++
    Rectangle.max++
    step++
    return sum
  }
/*  func add() ->Int {
    sum+=step

    return sum  
  }
  return add*/
  
}
let addByTen=addHandler(10)

addByTen()
addByTen()
addByTen()
print(data)
print(Rectangle.max)

let addBYSix=addHandler(6)

addBySix()
addBySix()
addBySix()
print(data)
print(Rectangle.max)

/*class AddHelper {
  var sum=0
  var step=0

  func add() -> Int {
    self.sum+=self.step
    return self.sum
  }
}

func addHandlerHelper(step: Int) -> () -> Int {
  let sum=0
  let obj=AddHelper()
  obj.sum=sum
  obj.step=step
  let closuer=obj.add
  return closuer
}

let addByTen=addHandlerHelper(10)

print(addByTen())
print(addByTen())
print(addByTen())

let addByTen=addHandlerHelper(6)

print(addBySix())
print(addBySix())
print(addBySix())*/
捕获值的内存模型.png

相关文章

  • 波哥Swift学习9.5~9.8学习总结

    这几次课程的内容对我来说最大的收获是函数类型与如何使用闭包让代码更加简洁。 本次内容有: 函数类型 闭包 函数类型...

  • Swift中的闭包定义

    定义闭包变量 定义可选闭包变量 定义闭包别名 定义闭包常量 在函数内部 作为函数参数 作为函数参数(隐式参数类型)...

  • 闭包

    闭包的基本语法 闭包的内容捕获 闭包和函数的引用类型

  • 函数类型与闭包

    函数类型 函数类型定义:(参数类型1,参数类型2,……)->返回值类型 函数类型是一种引用类型,类似于函数指针。可...

  • 2018-07-10swift4与swift 3.3 语法重拾(

    函数与闭包 闭包

  • Swift-闭包

    闭包的特点:一个函数有权访问另外一个函数内的变量和参数 闭包—匿名函数 结尾闭包 衍生 内容捕获 闭包和函数是引用类型

  • swift-闭包

    闭包 ≈ block, 函数, 匿名函数 (闭包和函数都是引用类型,能改变值)(值类型不能改变值) 对上面的传的函...

  • Swift 闭包浅解

    闭包的语法 {(参数:类型)-> 返回类型 in执行逻辑return 返回类型} 说明 :1. 闭包主要指向函数...

  • Swift闭包 gekaand

    闭包基础格式 :{(参数:类型) ->返回类型 in执行方法return 返回类型}说明:1;闭包主要指向函数类...

  • 菜鸡学Swift3.0 11.闭包

    1. 闭包 {(参数:参数类型 , 。。。) -> 返回值类型 in return 函数体 } 2. 尾随闭包 3...

网友评论

      本文标题:函数类型与闭包

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