Hướng dẫn sử dụng Swift Function
Công ty Vĩnh Cửu tuyển dụng lập trình viên Java

1- Tạo một project

Trước hết, để thực hành, bạn cần tạo một project. Mở XCode và tạo mới một Project:

2- Định nghĩa Function

Trong Swift, một hàm được định nghĩa bởi từ khóa "func", hàm có tên cụ thể, hàm có thể có 0 hoặc nhiều tham số, và có hoặc không có kiểu trả về.
Cú pháp định nghĩa một hàm:
// Một hàm có kiểu trả về

func functionName(parameters) -> returntype  
{
   // Các câu lệnh ....
   return value;
}


// Hàm không có kiểu trả về
func functionName(parameters)
{
    // Các câu lệnh.  
}
Dưới đây là một hàm có tên sayHello, có một tham số kiểu String, và trả về kiểu String.
MyFirstFunction.swift
import Foundation

// Định nghĩa một function
// Tên hàm: sayHello
// Tham số: name, có kiểu String
// Kiểu trả về: String

func sayHello(name:String) -> String {
 
   // Kiểm tra nếu name là rỗng
   if name.isEmpty  {
       // Hàm sẽ kết thúc ở lệnh return.
       return "Hello every body!"
   }
   // Nếu name không rỗng, đoạn code dưới đây sẽ được chạy.
   return "Hello " + name
 
}


// Định nghĩa một hàm khác không có tham số, không có kiểu trả về.

func test_sayHello()  {
 
   // Gọi hàm sayHello, truyền vào tham số String rỗng.
   var greeting1 = sayHello("")
 
 
   print("greeting1 = " + greeting1);
 
 
   // Gọi hàm sayHello, truyền vào tham số String là "Swift"
   var greeting2 = sayHello("Swift")
 
   print("greeting2 = " + greeting2);
 
}
Sửa file nguồn main.swift để test function bạn vừa tạo ra.
main.swift
import Foundation


// Gọi hàm test_sayHello()

test_sayHello()
Chạy ví dụ:

3- Quy tắc gọi hàm, phương thức

Swift 2.1 đặt ra một quy tắc gọi hàm, dưới đây là các quy tắc:
  • Tham số đầu tiên truyền cho hàm (hoặc phương thức) không yêu cầu nhãn tham số (Label)
  • Các tham số khác truyền cho hàm (hoặc phương thức) yêu cầu phải có nhãn tham số.
  • Tất cả các tham số truyền vào cho Constructor yêu cầu phải có nhãn tham số (Label)
RulesCallFunc.swift
import Foundation


// name1, name2 là nhãn (Label) của các tham số.
func sayHello(name1: String, name2: String)   {
 
   print("Hello " + name1);
   print("Hello " + name2);
 
}



func test_sayHello()    {
 
 
   let tom = "Tom"
   let jerry = "Jerry"
 
 
   // Gọi hàm (Hoặc phương thức).
   // Tham số đầu tiên không yêu cầu nhãn (Label).
   // Các tham số khác yêu cầu phải có nhãn.
 
   sayHello(tom, name2: jerry)

 
}

4- Function trả về một giá trị

Lệnh return trong function sẽ dừng việc thực thi hàm và trả về một giá trị từ hàm đó.
FunctionExample1.swift
import Foundation


// Định nghĩa một hàm tính tổng 3 số Int, và trả về kiểu Int.

func sum(a: Int, b: Int, c: Int) -> Int  {

  // Khai báo một biến ret kiểu Int
  var ret:Int = a + b + c

  return ret

}



// Định nghĩa một hàm tìm số lớn nhất trong 3 số.

func max(a: Int, b: Int, c: Int) -> Int {

  // Khai báo một biến m, gán nó = a
  var m = a

  // Kiểm tra nếu m < b thì gán m = b
  if m < b  {
      m = b
  }

  // Nếu m > c thì trả về m.
  if m >  c  {
      // Hàm kết thúc ở đây.
      return m;
  }

  return c

}

5- Hàm trả về nhiều giá trị

Trong Swift một hàm có thể trả về nhiều giá trị, về bản chất hàm đó trả về một Tuple (Dẫy giá trị),  Tuple là một dẫy giá trị được đặt trong một cặp dấu ngặc (), và ngăn cách nhau bởi đấu phẩy. Mỗi giá trị có một tên để có thể truy cập vào nó.
ReturningTupleExample.swift
import Foundation



// Định nghĩa một hàm có tên getMinMax
// Tham số đầu vào là một mảng các số Int.
// Hàm trả về 2 giá trị: Số lớn nhất trong mảng, và số nhỏ nhất trong mảng.
// Tuple trả về có 2 giá trị, được đặt tên là min và max.

func getMinMax(arr: [Int]) -> (min: Int, max: Int)   {


 // Nếu mảng không có phần tử nào trả về cặp (0,0).
 if arr.count == 0  {
     // Hàm kết thúc ở đây.
     return (0, 0)
 }

 // Khai báo 2 biến mi,ma gán bằng phần tử đầu tiên của mảng.
 var mi: Int = arr[0]
 var ma: Int = arr[0]

 // Duyệt trên mảng.

 for a in arr  {
 
     if mi > a  {
         mi = a
     }
     if  ma  <  a  {
         ma = a
     }
 }

 return (mi, ma)
}


// Test hàm getMinMax.
func test_returningTupleExample()    {

 // Khai báo một mảng các số Int
 var years: [Int] = [2000, 1989, 1975, 2005, 2016]


 // Gọi hàm getMinMax
 // Hàm trả về một Tuple.
 var y = getMinMax(years)

 print("Max = \(y.max)")

 print("Min = \(y.min)")


}
Sửa file nguồn main.swift để test ví dụ:
main.swift
import Foundation

test_returningTupleExample()
Chạy ví dụ:

6- Hàm với tham số Variadic

Swift sử dụng "variableName: DataType..." để đánh đấu một tham số là Variadic. Xem ví dụ dưới đây về một hàm có tham số Variadic và cách sử dụng hàm này.
VariadicParamsFunction.swift
import Foundation


// Một hàm với tham số Variadic: nums
// Tham số nums: Có thể coi như là một mảng các Int.
func sum(nums: Int...) -> Int {
 
   var retNumber : Int = 0
 
   // Duyệt trên mảng nums.
   for n in nums {
       retNumber = retNumber + n
   }
 
   return retNumber
 
}


// Sử dụng hàm, với tham số Variadic:

func test_sum()    {
 
   // Gọi hàm sum, truyền vào 3 tham số.
   var sum1 = sum(1, 2, 3)
 
   print("sum(1, 2, 3) = \(sum1)")
 
   // Gọi hàm sum, truyền vào 4 tham số.
   var sum2 = sum(1,4, 5, 7)
 
   print("sum(1,4, 5, 7) = \(sum2)")
 
}
Chạy ví dụ:

7- Hàm bên trong một hàm

Swift cho phép bạn viết một hàm bên trong một hàm khác, hàm này được sử dụng trong nội bộ của hàm cha.
NestedFunction.swift
import Foundation


// Hàm trả về thuế thu nhập dựa vào quốc gia & tiền lương
func getTaxAmount(countryCode:String, salaryAmount:Int) -> Int  {
 
   // Một hàm tính thuế thu nhâp tại Mỹ.
   func getUsaTaxAmount( salaryAmount: Int)  -> Int {
       // 15%
       return 15*salaryAmount/100
   }
 
   // Một hàm tính thuế thu nhập tại Vietnam.
   func getVietnamTaxAmount( salaryAmount:Int)  -> Int {
       // 10%
       return 10 * salaryAmount/100
   }
 
   if countryCode == "US" {
     
       return getUsaTaxAmount(salaryAmount)
     
   } else if countryCode == "VN" {
     
       return getVietnamTaxAmount(salaryAmount)
     
   }
 
   // Các quốc gia khác (5%).
   return  5 * salaryAmount / 100
 
}

8- Kiểu hàm (Function Type)

Trong Swift mỗi hàm có một kiểu hàm, hãy xem một hàm dưới đây:

func sum(a: Int,  b: Int)  -> Int   {
    return a + b;
}
Hàm trên có kiểu hàm là:
(Int,Int) -> (Int)

9- Hàm trả về một hàm

ReturningFunction.swift
import Foundation


// Một hàm tính thuế thu nhập tại Mỹ.
// Hàm này có kiểu:  (Int) -> (Int)
func getUsaTaxAmount(salary: Int)  -> Int {
 
   return 15 * salary / 100
}

// Một hàm tính thuế thu nhập tại Vietnam.
// Hàm này có kiểu:  (Int) -> (Int)
func getVietnamTaxAmount(salary: Int) -> Int  {
 
   return 10 * salary / 100
}

// Một hàm tính thuế thu nhập mặc định
// Hàm này có kiểu:  (Int) -> (Int)
func getDefaultTaxAmount(salary: Int) -> Int {
 
   return 5 * salary / 100
}

// Hàm trả về hàm tính thuế.
func getTaxFunction(countryCode: String) ->  ( Int -> Int )  {
 
   if countryCode == "US"  {
       // Trả về hàm tính thuế tại Mỹ
       return getUsaTaxAmount
     
   } else if countryCode == "VN"  {
     
       return getVietnamTaxAmount
   }
   return getDefaultTaxAmount
 
}


// Test
func  test_returningFunction()  {
 
   var countryCode = "US"
   print("Country Code = " + countryCode)
 
   // Lấy ra hàm tính thuế ứng với nước Mỹ.
   var taxFunction =  getTaxFunction(countryCode)
 
 
   var salary = 10000
 
   print("Salary = \(salary)")
 
   var taxAmount = taxFunction(salary)
 
   print("Tax Amount = \(taxAmount)")
}
Sửa main.swift để test ví dụ:
main.swift
import Foundation
 

test_returningFunction()
Chạy ví dụ: