//
// ViewController.swift
// 函数和闭包
//
// Created by mibo02 on 17/1/5.
// Copyright © 2017年 mibo02. All rights reserved.
//
import UIKit
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
//调用
let string:String =
greet(person: "fengfeng", day: "11号")
print(string)
let string1 =
somesthing(on: "xiaoming", "12号")
print(string1)
let string2 = newOtherSthing(scores: [5,3,100,3,9])
print(string2.sum)
print(string2.2)
let sumOF1 =
sumOF(numbers: 50,80,90)
print(sumOF1)
print(calAdd(100,150))
testFunction {
print("去掉括号的尾随闭包写法")
}
}
//函数
//使用func 声明一个函数。通过函数名称和参数调用一个函数。使用->区分参数名和函数返回的类型。
func greet(person:String,day:String) -> String {
return "Hello \(person), today is \(day)"
}
//函数的参数可以有外部参数名和内部参数名，外部参数名标记函数传入的参数，内部参数名在函数实现的地方使用。_表示没有外边参数名。
func somesthing(on person:String, _ day:String) -> String {
return "hell0 \(person), today is \(day)"
}
//一个函数需要返回多个值可以使用元组。元组中的元素可以使用名称和下标访问。
func newOtherSthing(scores:[Int]) -> (min:Int,max:Int,sum:Int) {
var min = scores[0]
var max = scores[0]
var sum = 0
for score in scores {
if score > max {
max = score
} else if score < min {
min = score
}
sum += score
}
return (min,max,sum)
}
//函数也可以有可变数量的参数，将这个参数看成是一个数组。
//一个可变参数可以接受零个或多个值 ...
func sumOF(numbers:Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
//函数可以被嵌套。里面的嵌套函数可以访问外面函数的变量。你可以在一个函数中使用嵌套函数是这个函数变得更长更复杂。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
// 一个函数也可以用其他函数作为参数。
func hasAnyMatches(list:[Int],condition:(Int)->Bool) -> Bool {
for item in list {
if condition(item) {
return true
}
}
return false
}
//闭包
let calAdd:(Int,Int)->(Int) = {
(a:Int,b:Int) -> Int in
return a + b
}
//或者Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
let callAdd2 :(Int,Int)->(Int) = {
a,b in
return a + b
}
//单行表达式闭包可以隐式返回，如下，省略return
let callAdd3:(Int,Int)->(Int) = {(a,b) in a + b}
//如果闭包没有参数，可以直接省略“in”
let callAdd4:()->Int = {return 100 + 200}
//
let callAdd5:()->Void = {print("这是一个什么也没有的函数")}
//起别名
typealias addBlock = (Int,Int)->(Int)
let Add:addBlock = {
(c, d) in
return c + d
}
//尾随闭包
// 若将闭包作为函数最后一个参数，可以省略参数标签,然后将闭包表达式写在函数调用括号后面
func testFunction(testBlock:()->Void) {
//这里需要传进来的闭包类型是无参数和无返回值的
testBlock()
}
//函数嵌套形式
//返回的是一个函数，()->Int类型的函数
func camtureValue(amount:Int) -> ()->Int {
var total = 0
//函数
func incrementer()->Int {
total += amount
return total
}
return incrementer
}
//闭包形式
func captureValue2(sums amount:Int) -> () ->Int {
var total = 0
//闭包
let addNewBlock:()->Int = {
total += amount
return total
}
return addNewBlock
}
//逃逸闭包
//当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。
func doSomething(some: @escaping () -> Void) {
//延时操作，注意这里的单位是秒
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1, execute: {
//一秒后操作
some(print("我是一秒之后才执行的"))
})
print("函数体")
}
//
var comletionHandle: ()->String = {"约吗？"}
func doSomething2(some: @escaping ()->String) {
comletionHandle = some
}
var completionHandlers:[() -> Void] = []
//逃逸
func someFunctionWithEscapingClosure(completionHandler: @escaping() -> Void) {
completionHandlers.append(completionHandler)
}
override func didReceiveMemoryWarning() {
super.didReceiveMemoryWarning()
// Dispose of any resources that can be recreated.
}
}