定义一个方法。
func greet(firstStr:String, secondStr:String) -> String {
return "first is \(firstStr), second is \(secondStr)"
}
参数放在方法名字后面用括号，使用->指向返回值类型。
元组
func calculateStatistics(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)
}
看一下这个方法，返回值有多个int类型的数。其实这些返回值是一个整体，称为元组。
元祖可以将多个值组合在一起，这些值可以是不同的类型。
然后可以类似于数组通过索引去访问，
元祖中每个数值都可以有一个他的名字，可以像OC上的对象通过点名字去获取具体的值。
let person = (name: "lnj", age: 30, score: 100.0)
let values: (String, Int, Double) = ("lnj", 30, 99.9)
let values = ("lnj", 30, 99.9);
let (String, Int, Double) = values
// 通过名称访问
person.name
person.age
person.score
具体的用法就是当要返回多个数值的时候，直接返回一个元祖就可以了。
元祖的特性：
1.跳过无关的值：
当元祖中的某个数值无关紧要，可以跳过。
let (name, _, age) = yuanzu //使用下划线去忽略
let yuanzu = (name:"gyz" ,true, age:22) //或者不给它指定变量名
使用这两个方法都不能访问中间那个数值。
2.元祖的可变和不可变
用var定义的元祖就是可变元祖，用let定义的元祖就是不可变元祖。
但是不管是可变或者不可变的元祖都不能对元祖的长度改变，即不能增加和删除某个数值。
可变和不可变的区别就是可变的元祖可以修改某个数据的值。但是不能修改这个数据的数据类型。
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)
函数可以接受多个参数，然后把它们存放在数组中。但是传入参数都得是同一种类型。像本例中传入的类型就全是Int类型。
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
函数可以内嵌，里面的函数可以访问外面函数的变量。常使用内嵌函数来解决函数里面代码过长。
func bigFunc() -> ((Int) -> Int) {
func littleFunc (LittleN : Int) -> Int {
return LittleN;
}
return littleFunc
}
let myFunc = bigFunc()
print(myFunc(9))
函数可以作为返回值返回，返回后定义一个常量myFunc指向它，这个常量myFunc本身的类型就是函数。
//获取数组中等于二的数值个数
func getMax(list: [Int], condition: (Int) -> (Bool)) -> Int {
var count = 0
for number in list {
if condition(number) {
count += 1
}
}
return count
}
func compare(number :Int) -> Bool {
if number == 2 {
return true
} else {
return false
}
}
let myList = [2,6,2,0,10,44,2]
print(getMax(list: myList, condition: compare))
函数可以作为参数传入某个函数中。
闭包
一般形式：{
(parameters) -> returnType in
statements
}
这里的参数(parameters)，可以是in-out(输入输出参数)，但不能设定默认值。如果是可变参数，必须放在最后一位，不然编译器报错。元组也可以作为参数或者返回值。
"in"关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。即由in引入函数
//一般形式
let calAdd:(Int,Int)->(Int) = {
(a:Int,b:Int) -> Int in
return a + b
}
print(calAdd(100,150))
//Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
let calAdd2:(Int,Int)->(Int) = {
a,b in //也可以写成(a,b) in
return a + b
}
print(calAdd2(150,100))
//上面省略了返回箭头和参数及返回值类型，以及参数周围的括号。当然你也可以加括号，为了好看点，看的清楚点。(a,b)
//单行表达式闭包可以隐式返回，如下，省略return
let calAdd3:(Int,Int)->(Int) = {(a,b) in a + b}
print(calAdd3(50,200))
//如果闭包没有参数，可以直接省略“in”
let calAdd4:()->Int = {return 100 + 150}
print("....\(calAdd4())")
//这个写法，我随便写的。打印出“我是250”
//这个是既没有参数也没返回值，所以把return和in都省略了
let calAdd5:()->Void = {print("我是250")}
calAdd5()
总结： let calAdd:(Int,Int)->(Int)类似于这样的写法，=后面的代码段就是表示一个闭包。整个的意思就是声明一个常量 calAdd，这个常量的类型是(Int,Int)->(Int)， 也可以说 这个常量的类型是闭包类型。 类似于OC中的block
闭包可以像OC中的block一样使用typedef起别名，swift上使用的typealias
typealias MyClosePage = (Int, Int) -> Int
let a: MyClosePage = {
b, c in
return b + c;
}
print(a(3,4));
函数和闭包都属于引用类型， 只有当一个变量指向它的时候它可以保持存在，不被释放，同事内部的变量的值也存在，可以累积计算。
例如：
定义一个函数
func captureValue(sums:Int) -> Int{
var total = 0
total += 1
return total
}
如果单纯的调用captureValue() , 调用完成，这个方法会释放，内部的值total也会释放。
如果使用
let a = captureValue()
这样去调用，函数被引用了，只要a不被释放，方法一直存在，方法里面的total的值保留。
使用闭包，同理。
逃逸闭包
func doSomething(some: @escaping () -> Void){
//延时操作，注意这里的单位是秒
DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1) {
//1秒后操作
some()
}
print("函数体")
}
doSomething {
print("逃逸闭包")
}
逃逸闭包指的是闭包当做参数出入到函数中，会在函数返回之后再去执行闭包。多用于线程的异步操作，一般用于网络请求完成后成功或者失败后的回调。
逃逸闭包的标志就是 @escaping 在参数和返回值之前添加。
自动闭包
顾名思义，自动闭包是一种自动创建的闭包，封装一堆表达式在自动闭包中，然后将自动闭包作为参数传给函数。而自动闭包是不接受任何参数的，但可以返回自动闭包中表达式产生的值。
var array = ["I","have","a","apple"]
print(array.count)
//打印出"4"
let removeBlock = {array.remove(at: 3)}//测试了下，这里代码超过一行，返回值失效。
print(array.count)
//打印出"4"
print("执行代码块移除\(removeBlock())")
//打印出"执行代码块移除apple" 这里自动闭包返回了apple值
print(array.count)
//打印出"3"
当自动闭包调用的时候，才会去执行里面的代码。 类似于OC中的懒加载。
