swift 4.x 函数

//使用 func 来声明一个函数，使用名字和参数来调用函数。使用 -> 来指定函数返回值的类型,可以使用Any不强调返回值类型。
 
let string = greet(person: "蜗牛", day: "2018-05-22")
print(string)

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

   
//默认情况下，函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签。

print(greet("John", on: "Wednesday"))

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

//使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。

let statistics = calculateStatistics(numbers: [2533,63336,5256,5526,52333])
print(statistics.min,statistics.max,statistics.sum)

func calculateStatistics(numbers: [Int]) -> (min:Int,max:Int,sum:Int) {
    
    var min = numbers[0]
    var max = numbers[0]
    var sum = 0
    for score in numbers {
        
        if score > max {
            
            max = score
            
        } else if score < min {
            
            min = score
            
        }
        sum += score
        
    }

    return (min,max,sum)

}


//函数可以带有可变个数的参数，这些参数在函数内表现为数组的形式
    
print(sunmOf())

func sunmOf(numbers : Int...) -> Int {
    
    var num = 0
    
    for number in numbers {
        num  += number
    }
    
    return num
    
}
  


//练习: 写一个计算参数平均值的函数。

print("平均数:\(average(numbers: [10,25,35,65]))")


func average(numbers : [Int]) -> (Float) {
    
    var average = 0
    
    for num in numbers {
        
        average += num
        
    }
    
    
    print(average,numbers.count)
    
    return Float(average) / Float(numbers.count)
    
}
   
//函数可以嵌套。被嵌套的函数可以访问外侧函数的变量，你可以使用嵌套函数来重构一个太长或者太复杂的函数。

print("函数嵌套:\(returnFifteen())")

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

   
//函数可以作为另一个函数的返回值
    
let number = sunmOf(num: 8)
    
print(number(5))

func sunmOf(num : Int) -> ((Int) -> Int) {
    
    func addOne(number : Int) -> Int {
        
        return num + number
        
    }
    
    return addOne

}

    
//函数也可以当做参数传入另一个函数。
let numbers = [20, 19, 7, 12]
print(hasAnyMatches(list: numbers, condition: lessThanTen(number: 1)))


func hasAnyMatches(list: [Int], condition: (Int)) -> Int {
    
    var num = 0
    
    for item in list {
        
        if item > condition {
            
            num += condition
            
            
        }else{
            
            num -= condition
            
        }
        
    }
    
    return num
    
}

func lessThanTen(number: Int) -> Int {
    
    return  number + 10
}

   
//函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变 量和函数，即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用 {} 来创建 一个匿名闭包。使用 in 将参数和返回值类型声明与闭包函数体进行分离。
    
    let numbers = [20, 19, 7, 12]
    let mappedNumbers =  numbers.map({
        (number: Int) -> Int in
        let result = 3 * number
        return result
    })
    
    print(mappedNumbers)
    
//有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知，比如作为一个回调函数，你可以忽略参数的类型和返回值。单个语句闭包会把它语句的值当做结果返回。
    
let mapped = numbers.map({ number in 3 * number })
print(mapped)