swift swift学习笔记--函数和闭包

使用 func来声明一个函数。通过在名字之后在圆括号内添加一系列参数来调用这个方法。使用 ->来分隔形式参数名字类型和函数返回的类型

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

默认情况下，函数使用他们的形式参数名来作为实际参数标签。在形式参数前可以写自定义的实际参数标签，或者使用 _ 来避免使用实际参数标签

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

使用元组来创建复合值——比如，为了从函数中返回多个值。元组中的元素可以通过名字或者数字调用

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[]
    var max = scores[]
    var sum = 

    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [, , , , ])
print(statistics.sum)
print(statistics.)

函数同样可以接受多个参数，然后把它们存放进数组当中

func sumOf(numbers: Int...) -> Int {
    var sum =
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: , , )

函数可以内嵌。内嵌的函数可以访问外部函数里的变量。你可以通过使用内嵌函数来组织代码，以避免某个函数太长或者太过复杂

func returnFifteen() -> Int {
    var y =
    func add() {
        y +=
    }
    add()
    return y
}
returnFifteen()

函数是一等类型，这意味着函数可以把函数作为值来返回

func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return  + number
    }
    return addOne
}
var increment = makeIncrementer()
increment()

函数也可以把另外一个函数作为其自身的参数

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number <
}
var numbers = [, , , ]
hasAnyMatches(list: numbers, condition: lessThanTen)

函数其实就是闭包的一种特殊形式：一段可以被随后调用的代码块。闭包中的代码可以访问其生效范围内的变量和函数，就算是闭包在它声明的范围之外被执行——你已经在内嵌函数的栗子上感受过了。你可以使用花括号（ {}）括起一个没有名字的闭包。在闭包中使用 in来分隔参数和返回类型

numbers.map({
    (number: Int) -> Int in
    let result =  * number
    return result
})

你有更多的选择来把闭包写的更加简洁。当一个闭包的类型已经可知，比如说某个委托的回调，你可以去掉它的参数类型，它的返回类型，或者都去掉。

单语句闭包隐式地返回语句执行的结果

let mappedNumbers = numbers.map({ number in  * number })
print(mappedNumbers)

你可以调用参数通过数字而非名字——这个特性在非常简短的闭包当中尤其有用。当一个闭包作为函数最后一个参数出入时，可以直接跟在圆括号后边。如果闭包是函数的唯一参数，你可以去掉圆括号直接写闭包

let sortedNumbers = numbers.sort { $ > $ }
print(sortedNumbers)

转自：https://www.cnswift.org/a-swift-tour

swift里面的所有笔记，均参考字网上的博客，纯属自己学习记录专用，谢各位大神！