Swift学习之十三：函数（Functions）

/*
  函数（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 
}