2014年8月4日 星期一

Swift Language Guide - Functions

Swift Language Guide - Functions

Functions without return values does return a special value Void and it is simply an empty tuple

External Parameter Names

func join(string s1: String, toString s2: String, withJoiner joiner: String) -> String {
    return s1 + joiner + s2
}

println(join(string: "hello", toString: "world", withJoiner: ", "))
func total(productPrice price: Int, numberOfTimes times: Int) -> Int {
    return price * times
}

func total(productSize size: Int, numberOfTimes times: Int) -> Int {
    return size * times * 3
}

func total(amount: Int,times: Int) -> Int {
    return amount * times * 2
}

func total(x: Int, y: Int) -> Int { <- Error
    return x + y
}


println(total(productPrice: 10, numberOfTimes: 20))  <-- 200
println(total(productSize: 10, numberOfTimes: 20))   <-- 600
println(total(10, 20))                               <-- 400

Shorthand External Parameter Names

Using #

func total(#productPrice: Int, #numberOfTimes: Int) -> Int {
    return productPrice * numberOfTimes
}

func total(#productSize: Int, #numberOfTimes: Int) -> Int {
    return productSize * numberOfTimes * 3
}

func total(amount: Int,times: Int) -> Int {
    return amount * times * 2
}

println(total(productPrice: 10, numberOfTimes: 20))
println(total(productSize: 10, numberOfTimes: 20))
println(total(10, 20))

Default Values with External Parameter Names

Swift AUTOMATICALLY provides an extenal parameter name for the defaulted parameter.

func join(s1: String, s2: String, joiner: String = " ") -> String {
    return s1 + joiner + s2
}

func join(string s1: String, toString s2: String, withJoiner joiner: String = ", ") -> String {
    return s1 + joiner + s2
}

println(join("hello", "world"))

println(join("hello", "world", "-")) <-- Error, MUST use external parameter name (joiner: "-")

println(join("hello", "world", joiner: "-"))

println(join(string: "hello", toString: "world"))

println(join(string: "hello", toString: "world", withJoiner: "@"))

Parameter Passing

Constants

Paramters are CONSTANTS. It can not be assign new value.

func abc(a: Int, b: Int) -> Int {
    a = 20  <-- Error
    return a + b
}

Variable

Using var

var def = "def"
func test(var str: String) -> String {
    str = "abc"     <-- str is a local variable, NOT constant. 
    return str
}

println(test(def))  <-- abc
println(def)        <-- still, def

In-Out

  • In-Out will change original values, and pass with &.

      func swap(inout a: Int, inout b: Int) {
          (a, b) = (b, a)
      }
    
      var a = 10, b = 20
    
      println("(a, b) = (\(a), \(b))")
      swap(&a, &b)
      println("(a, b) = (\(a), \(b))")
    
  • Can NOT pass CONSTANT and LITERAL value

      func abc(inout a: Int) {
          a += 1
      }
    
      let a = 10
      abc(&a)      <-- Error
      println(a)
      abc(20)      <-- Error
    
  • Can NOT apply on var parameters

      func abc(var inout a: Int) {    <-- inout is an external parameter name
          a += 1
      }
    
      abc(inout: 20)
    
      func def(inout var a: Int) {    <-- Error
          a += 1
      }
    
  • Can NOT apply on VARIADIC parameters

      func abc(inout a: Int...) {     <-- Error
    
      }
    

Function Type

func swap(inout a: Int, inout b: Int) {
    (a, b) = (b, a)
}

var a = 10, b = 20

println("(a, b) = (\(a), \(b))")
swap(&a, &b)
println("(a, b) = (\(a), \(b))")

let mySwap: (inout Int, inout Int) -> () = swap

mySwap(&a, &b)

println("(a, b) = (\(a), \(b))")
張貼留言