/* 函数（Function） 函数是为执行特定功能的自包含的代码块。函数需要给定一个特定标识符（名字），然后当需要的时候， 就调用此函数来执行功能。 */ // 函数的定义与调用 // 定义函数时，使用关键字func，返回值类型通过->指明，如下： // 函数名：sayHello， // 参数列表中只有一个参数，叫personName,参数类型是String // 函数返回值类型：String func sayHello(personName: String) -> String { let greeting = "Hello, " + personName + "!" return greeting } // 函数调用 println(sayHello("Anna")) // prints "Hello, Anna" println(sayHello("Brian")) // prints "Hello, Brian" // 简化函数体 func sayHelloAgain(personName: String) -> String { return "Hello, " + personName + "!" } println(sayHelloAgain("Anna")) // 函数可以有多个参数 /*! * @brief 返回两个值的差 * @param start Int类型，范围区间的起点 * @param end Int类型，范围区间的终点 * @return 返回值为Int类型，表示终点-起点的值 */ func halfOpenRangeLength(start: Int, end: Int) -> Int { return end - start } println(halfOpenRangeLength(1, 10)) // prints "9" // 无参数函数 func sayHelloWorld() -> String { return "Hello, world" } println(sayHelloWorld()) // 无返回值的函数,其实这里没有指定返回值，也会返回一个特殊的值，Void func sayGoodbye(personName: String) { println("Goodbye, \(personName)!") } sayGoodbye("David") // 函数返回值是可以忽略的 func printAndCount(stringToPrint: String) -> Int { println(stringToPrint) return countElements(stringToPrint) // 计算字符串的长度 } // 不带返回值 func printWithoutCounting(stringToPrint: String) { printAndCount(stringToPrint) } printAndCount("Hello,world") printWithoutCounting("hello, world") /* * @brief 函数可以返回元组（多个值） * @param string 字符串 * @return (vowels: Int, consonants: Int, others: Int) * vowels:元音， consonants:辅音，others：其它字符 */ func count(string: String) ->(vowels: Int, consonants: Int, others: Int) { var vowels = 0 var consonants = 0 var others = 0 for c in string { switch String(c).lowercaseString { case "a", "o", "e", "i", "u": ++vowels case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z": ++consonants default: ++others } } return (vowels, consonants, others) } let total = count("some arbitrary string!") println("\(total.vowels) vowels and \(total.consonants) consonants") // 外部参数名(External Parameter Names) // 有时候使用外部参数名是很有用的，这直到提示的作用，就好像OC语法中的参数一样，见名知意 func someFunction(externalParameterName localParameterName: Int) { // do something } // 看例子： func join(lhsString: String, rhsString: String, joiner:String) -> String { return lhsString + joiner + rhsString } // 这里调用的时候，没有外部参数名 join("hello", "world", ",") // prints "hello,world" // 加上#号后，参数名与外部名相同，这是快捷方式 func join(#lhsString: String, #rhsString: String, #joiner:String) -> String { return lhsString + joiner + rhsString } // 调用方式 join(lhsString: "hello", rhsString: "world", joiner: ",") // prints "hello,world" // 可以不使用快捷方式 func join(lhsString: String, rhsString: String, withJoiner joiner: String) -> String { return lhsString + joiner + rhsString } join("hello", "world", withJoiner: ",")// prints "hello,world" // 函数参数默认值 // 参数参数可以提供默认值，但是默认值只能是参数列表的最后，也就是说 // 如果arg1提供默认值，后面的都需要提供默认值。 func join(#originalString: String, #destinationString: String, #withJoiner: String = " ") -> String { return originalString + withJoiner + destinationString } join(originalString: "hello", destinationString: "world", withJoiner: "-") // prints "hello-world" join(originalString: "hello", destinationString: "world") // prints "hello world" // 如果提供了参数默认值，Swift会自动把这个参数名也作为外部参数名 // 这里withJoiner相当于加上了#:#withJoiner func join(lhsString: String, rhsString: String, withJoiner: String = " ") -> String { return lhsString + withJoiner + rhsString } join("hello", "world", withJoiner: "-")// // prints "hello-world" // 可变参数 // 可变参数接受0个或者多个指定类型的值。可变参数使用...表示 // 函数最多只能有一个可变参数，并且如果有可变参数，这个可变参数必须出现在参数列表的最后 // 如果参数列表中有一或多个参数提供默认值，且有可变参数，那么可变参数也要放到所有最后一个 // 提供默认值的参数之后（先是默认值参数，才能到可变参数） func arithmeticMean(numbers: Double...) -> Double { var total = 0.0 for number in numbers { total += number } return total / Double(numbers.count) } arithmeticMean(1, 2, 3, ,4 5) // return 3.0 arithmeticMean(1, 2, 3) // return 2.0 // 常量和变量参数 // 在函数参数列表中，如果没有指定参数是常量还是变量，那么默认是let，即常量 // 这里Str需要在函数体内修改，所以需要指定为变量类型，即用关键字var func alignRight(var str: String, count: Int, pad: Character) -> String { let amountToPad = count - countElements(str) // 使用_表示忽略，因为这里没有使用到 for _ in 1...amountToPad { str = pad + str } return str } // 输入/输出参数 // 有时候，在函数体内修改了参数的值，如何能直接修改原始实参呢？就是使用In-Out参数 // 使用inout关键字声明的变量就是了 // 下面这种写法，是不是很像C++中的传引用？ func swap(inout lhs: Int, inout rhs: Int) { let tmp = lhs lhs = rhs rhs = tmp } // 如何调用呢？调用的调用，对应的实参前面需要添加&这个符号 // 因为需要修改，所以一定是var类型的 var first = 3 var second = 4 // 这种方式会修改实参的值 swap(&first, &second) // first = 4, second = 3 // 使用函数类型 // 这里是返回Int类型 // 参数类型是：(Int, Int) -> Int func addTwoInts(first: Int, second: Int) -> Int { return first + second } // 参数类型是：(Int, Int) -> Int func multiplyTwoInts(first: Int, second: Int) -> Int { return first * second } var mathFunction: (Int, Int) -> Int = addTwoInts mathFunction(1, 2) // return 3 mathFunction = multiplyTwoInts mathFunction(1, 2) // return 2 // 参数可以作为参数 func printMathResult(mathFunction: (Int, Int) -> Int, first: Int, second: Int) { println("Result: \(mathFunction(first, second))") } printMathResult(addTwoInts, 3, 5) // prints "Result: 8" printMathResult(multiplyTwoInts, 3, 5) // prints "Result: 15" // 函数作为返回类型 func stepForward(input: Int) -> Int { return input + 1 } func stepBackward(intput: Int) -> Int { return input - 1 } func chooseStepFunction(backwards: Bool) -> ((Int) -> Int) { return backwards ? stepBackward : stepForward } var currentValue = 3 let moveNearerToZero = chooseStepFunction(currentValue > 0) // call stepBackward() function // 参数可以嵌套定义，在C、OC中是不可以嵌套的哦 func chooseStepFunction(backwards: Bool) -> ((Int) -> Int) { func stepForward(input: Int) -> Int { return input + 1 } func stepBackward(input: Int) -> Int { return input + 1 } return backwards ? stepBackward : stepForward }
使用函数类型
在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将函数赋值给它：
var mathFunction: (Int, Int) -> Int = addTwoInts这个可以读作：
“定义一个叫做
mathFunction的变量，类型是‘一个有两个Int型的参数并返回一个Int型的值的函数’，并让这个新变量指向addTwoInts函数”。
addTwoInts和mathFunction有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。函数类型作为参数类型也可以作为返回类型,如上代码