//1.使用"func"来声明一个函数,通过在函数名后面添加包含参数列表的花括号来执行函数,使用"->"来分离参数和返回类型
func greet(name:String, day:String)->String{
return"Hello\(name), toady is\(day)"
}
greet(name: "Bob", day:"Tuesday") -> "Hello Bob, toady isTuesday"
//2.使用元祖(tuple)来返回多个值
func getGasPrices()->(Double,Double,Double){
return(3.56,34.5,435.5)
}
getGasPrices() -> "(.0 3.56, .1 34.5, .2 435.5)"
//3.函数可以有可变长度额参数,通过数组来包含他们
func sumOf(num:Int...) ->Int{
var sum =0
for numberin num {
sum += number
}
return sum
}
sumOf()
sumOf(num:42,32,42,432) -> "548"
//4.函数可以嵌套,嵌套函数可以访问在外部函数中声明变量,可以使用嵌套函数来包装复杂的代码
func returnFifteen() -> Int{
var y =10
func add(){
y += 5
}
add()
return y
}
returnFifteen() -> "15"
//5.函数是一级类型,这表明在一个函数中可以返回另一个函数
func makeIncrementer() -> (Int){
func addoOne(number:Int) ->Int{
return1+number
}
returnaddoOne(number: 1)
}
var increment = makeIncrementer() -> "2"
//6.一个函数可以使用另一个函数作为参数(判断数组是否有一个数小于10)
func hasAny(list:[Int],condition:(Int) ->Bool) ->Bool{
for itemin list {
if condition(item) {
returntrue
}
}
returnfalse
}
//判断数字小于10
func lessThanTen(number:Int) ->Bool{
return number <10
}
var numbers = [23,32,9,12]
hasAny(list: numbers, condition:lessThanTen) -> "true"
//7.函数其实是一种特殊的闭包,可以通过使用花括号包装一段代码来创建一个闭包,使用"in"来分离参数和返回类型
var numbers = [23,32,9,12]
numbers.map({
(number:Int) ->Int invar result = 3 * number
if result %2 == 1{
result = 0
}
return result
})
//当闭包的类型已知,可以忽略他的参数或者返回值,或者两者都忽略,单一闭包隐式地返回值
print(numbers.map({numbersin 3 * numbers})) -> "[69, 96, 27, 36]"
//8.使用sort方法和闭包进行数组排序 sort方法返回一个数组的有序版本
//1.通过参数实现排序
var numbers2 = [12,24,23,42,32]
numbers2.sort(){(n1:Int, n2:Int) ->Bool in
return n2 > n1
}
print(numbers2) -> "[42, 32, 24, 23, 12]"
//2.通过sort实现降序排序
var numbers1 = [12,24,23,42,32]
numbers1.sort(){$1 < $0}
print(numbers1)-> "[12,23,24,32,42]"
//3.通过sort实现升序排序
var numbers2 = [12,24,23,42,32]
numbers2.sort(){$1 > $0}
print(numbers2)->"[42, 32, 24, 23, 12]"