// 函数嵌套 : 函数作用域中定义了一个另外一个函数, 内层函数的作用域中可以使用外层函数的参数
func hellocLanou(var num :Int ) {
num++
func hello23() {
num++
print(num)
}
hello23()
num
}
hellocLanou(10)
func hellocLanou2() -> ((Int) ->String) {
func hanshu(i:Int) -> String {
return "\(i)"
}
return hanshu
}
hellocLanou2()
let hanshu = hellocLanou2()
let i = hanshu(2)
// 声明一个函数, 实现功能:(传入"+", "-", "*", "/")的字符串, 返回对应运算的函数:"+"--返回Int + Int = Int
// 返回值是函数, 可以用函数嵌套的形式实现, 但是并不是必须使用嵌套实现
func sumNumber(c:NSString) ->((Int , Int) ->Int)? {
func sun(a:Int, b:Int) ->Int {
return a + b
}
func sub(a:Int, b:Int) ->Int {
return a - b
}
func mul(a:Int, b:Int) ->Int {
return a * b
}
func div(a:Int, b:Int) ->Int {
return a / b
}
switch c {
case "+":
return sun
case "-":
return sub
case "*":
return mul
case "/":
return div
default:
return nil
}
}
//-----------------同上
func sun(a:Int, b:Int) ->Int {
return a + b
}
func sub(a:Int, b:Int) ->Int {
return a - b
}
func mul(a:Int, b:Int) ->Int {
return a * b
}
func div(a:Int, b:Int) ->Int {
return a / b
}
func sumNumber1(c:NSString) ->((Int , Int) ->Int)? {
switch c {
case "+":
return sun
case "-":
return sub
case "*":
return mul
case "/":
return div
default:
return nil
}
}
//func number(c:String) -> ((a:Int, b:Int) ->Int) {
//
//
//}
sumNumber1("+")
let hanshu2 = sumNumber1("+")
let result = hanshu2!(2, 4)
// 指定类型别名
typealias funcType = ((Int, Int) -> Int)
func func3() -> funcType {
func hanshu5 (num1: Int, num2: Int) -> Int {
return 0
}
return hanshu5
}
//****************闭包 相当于block
// 闭包有作匿名函数
//{
//
//(参数列表) -> 返回值 in
// 函数的实现体
//}
// 使用系统排序函数对闭包的省略机制进行说明
var numbers = [11, 33, 4, 55, 77]
var numbers_result = numbers.sort({
(n1:Int, n2:Int) -> Bool in
return n1 > n2
})
// 闭包的参数类型可以省略
// 根据上下文进行类型推断
var number_result1 = numbers.sort({
(n1, n2) -> Bool in
return n1 > n2
})
// in 前面的语句可以省略
// 此时没有参数名, 自动生成$0, $1进行代替使用
var numbers_result2 = numbers.sort({
return $0 > $1 })
var numbers_result3 = numbers.sort({
$0 > $1 // return也可以省略, 条件是:函数条件体内只有return语句
})
// 极简模式
var numbers_result4 = numbers.sort(>)
//n*****************此处以上是闭包的省略机制
// 尾随机制
// 尾随闭包
// 当闭包作为参数列表的最后一个参数是, 并且内容相对复杂, 可以尾随在参数列表的外面
var numbers_result5 = numbers.sort(){
(n1, n2) -> Bool in
return n1 > n2
}
typealias myType = ((String) -> String)
func getPigName(name:String) -> String {
return "pig = \(name)"
}
func pig(canshu:myType) -> myType {
return getPigName
}
pig({
(name:String) -> String in
return "pig = \(name)"
})
// 闭包常用于参数, 函数常用与返回值
// "3" + "4" = "7"
// "3" + "4" = 7
typealias myType2 = ((String, String) -> Int)
func closure (clo:myType2) -> String {
let result_clo = clo("3" , "4")
// description 转成字符串
return result_clo.description
}
closure({
(a:String, b: String) -> Int in
return Int(a)! + Int(b)!
})
func hellocLanou(var num :Int ) {
num++
func hello23() {
num++
print(num)
}
hello23()
num
}
hellocLanou(10)
func hellocLanou2() -> ((Int) ->String) {
func hanshu(i:Int) -> String {
return "\(i)"
}
return hanshu
}
hellocLanou2()
let hanshu = hellocLanou2()
let i = hanshu(2)
// 声明一个函数, 实现功能:(传入"+", "-", "*", "/")的字符串, 返回对应运算的函数:"+"--返回Int + Int = Int
// 返回值是函数, 可以用函数嵌套的形式实现, 但是并不是必须使用嵌套实现
func sumNumber(c:NSString) ->((Int , Int) ->Int)? {
func sun(a:Int, b:Int) ->Int {
return a + b
}
func sub(a:Int, b:Int) ->Int {
return a - b
}
func mul(a:Int, b:Int) ->Int {
return a * b
}
func div(a:Int, b:Int) ->Int {
return a / b
}
switch c {
case "+":
return sun
case "-":
return sub
case "*":
return mul
case "/":
return div
default:
return nil
}
}
//-----------------同上
func sun(a:Int, b:Int) ->Int {
return a + b
}
func sub(a:Int, b:Int) ->Int {
return a - b
}
func mul(a:Int, b:Int) ->Int {
return a * b
}
func div(a:Int, b:Int) ->Int {
return a / b
}
func sumNumber1(c:NSString) ->((Int , Int) ->Int)? {
switch c {
case "+":
return sun
case "-":
return sub
case "*":
return mul
case "/":
return div
default:
return nil
}
}
//func number(c:String) -> ((a:Int, b:Int) ->Int) {
//
//
//}
sumNumber1("+")
let hanshu2 = sumNumber1("+")
let result = hanshu2!(2, 4)
// 指定类型别名
typealias funcType = ((Int, Int) -> Int)
func func3() -> funcType {
func hanshu5 (num1: Int, num2: Int) -> Int {
return 0
}
return hanshu5
}
//****************闭包 相当于block
// 闭包有作匿名函数
//{
//
//(参数列表) -> 返回值 in
// 函数的实现体
//}
// 使用系统排序函数对闭包的省略机制进行说明
var numbers = [11, 33, 4, 55, 77]
var numbers_result = numbers.sort({
(n1:Int, n2:Int) -> Bool in
return n1 > n2
})
// 闭包的参数类型可以省略
// 根据上下文进行类型推断
var number_result1 = numbers.sort({
(n1, n2) -> Bool in
return n1 > n2
})
// in 前面的语句可以省略
// 此时没有参数名, 自动生成$0, $1进行代替使用
var numbers_result2 = numbers.sort({
return $0 > $1 })
var numbers_result3 = numbers.sort({
$0 > $1 // return也可以省略, 条件是:函数条件体内只有return语句
})
// 极简模式
var numbers_result4 = numbers.sort(>)
//n*****************此处以上是闭包的省略机制
// 尾随机制
// 尾随闭包
// 当闭包作为参数列表的最后一个参数是, 并且内容相对复杂, 可以尾随在参数列表的外面
var numbers_result5 = numbers.sort(){
(n1, n2) -> Bool in
return n1 > n2
}
typealias myType = ((String) -> String)
func getPigName(name:String) -> String {
return "pig = \(name)"
}
func pig(canshu:myType) -> myType {
return getPigName
}
pig({
(name:String) -> String in
return "pig = \(name)"
})
// 闭包常用于参数, 函数常用与返回值
// "3" + "4" = "7"
// "3" + "4" = 7
typealias myType2 = ((String, String) -> Int)
func closure (clo:myType2) -> String {
let result_clo = clo("3" , "4")
// description 转成字符串
return result_clo.description
}
closure({
(a:String, b: String) -> Int in
return Int(a)! + Int(b)!
})
// 字符串转 Int Int (String)!