Hướng dẫn sử dụng Swift Function

Xem thêm các chuyên mục:

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  
{
   // Statements....
    return value;
}

// Một hàm không có kiểu trả về
func functionName(parameters)
{
    // Statements...
}
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 hàm (function)
// Tên hàm: sayHello
// Tham số: name, kiểu String
// Trả về (return): String
func sayHello(name:String) -> String {
    
    // Nếu 'name' rỗng (empty).
    if name.isEmpty  {
        // Trả về, và kết thúc hàm.
        return "Hello every body!"
    }
    // Nếu 'name' không rỗng, đoạn code này sẽ được thực thi.
    return "Hello " + name
    
}

// Định nghĩa một hàm, không có tham số, không có kiểu trả về.
func test_sayHello()  {
    
    // Gọi hàm sayHello, truyền vào một String rỗng.
    var greeting1 = sayHello("")
    
    
    print("greeting1 = " + greeting1);
    
    // Gọi hàm sayHello, truyền vào giá trị cho tham số là "Swift".
    var greeting2 = sayHello("Swift")
    
    print("greeting2 = " + greeting2);
    
}
Sửa file nguồn main.swift để test hàm 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 (Label) cho tham số
  • 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 (Label) cho tham số.
RulesCallFunc.swift
import Foundation

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



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

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

Lệnh return trong hàm 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, trả về kiểu Int.
func sum(a: Int, b: Int, c: Int) -> Int  {
    
    // Khai báo một biến kiểu Int.
    var ret:Int = a + b + c
    
    return ret
    
}


// Định nghĩa một hàm để tìm kiế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 giá trị 0 cho nó.
    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ề (return) m.
    if m >  c  {
        
        // Kết thúc hàm
        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 ( ),   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
// Đầu vào là một mảng các số Int.
// Hàm này trả về 2 giá trị:
// Số lớn nhất và số nhỏ nhất trong mảng.
func getMinMax(arr: [Int]) -> (min: Int, max: Int)   {
    
    // Nếu mảng không có phần tử, thì trả về (0,0).
    if arr.count == 0  {
        // Kết thúc hàm.
        return (0, 0)
    }
    
    // Khai báo 2 biến là 'mi', 'ma'
    // Gán giá trị của phần tử đầu tiên trong mảng cho chúng.
    var mi: Int = arr[0]
    var ma: Int = arr[0]
    
    
    for a in arr  {
        
        if mi > a  {
            mi = a
        }
        if  ma  <  a  {
            ma = a
        }
    }
    
    return (mi, ma)
}

// Test hàm getMinMax.
func test_returningTupleExample()    {
    
    // Một mảng các số Int.
    var years: [Int] = [2000, 1989, 1975, 2005, 2016]
    
    // Gọi hàm getMinMax.
    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 các tham số Variadic: nums
// Tham số nums: Giống như một mảng các số Int.
func sum(nums: Int...) -> Int {
    
    var retNumber : Int = 0
    
    
    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ề tiền thuế, dựa trên mã quốc gia và lương.
func getTaxAmount(countryCode:String, salaryAmount:Int) -> Int  {
    
    // Một hàm tính thuế của nước Mỹ.
    func getUsaTaxAmount( salaryAmount: Int)  -> Int {
        // 15%
        return 15*salaryAmount/100
    }
    
    // Một hàm tính thuế của 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ế tại Mỹ.
// Kiểu hàm là: (Int) -> (Int)
func getUsaTaxAmount(salary: Int)  -> Int {
    
    return 15 * salary / 100
}

// Một hàm tính thuế tại Vietnam.
// Kiểu hàm là: (Int) -> (Int)
func getVietnamTaxAmount(salary: Int) -> Int  {
    
    return 10 * salary / 100
}

// Một hàm tính thuế mặc định.
// Kiểu hàm là: (Int) -> (Int)
func getDefaultTaxAmount(salary: Int) -> Int {
    
    return 5 * salary / 100
}

// Hàm này trả về một hàm.
func getTaxFunction(countryCode: String) ->  ( Int -> Int )  {
    
    if countryCode == "US"  {
        return getUsaTaxAmount
        
    } else if countryCode == "VN"  {
        
        return getVietnamTaxAmount
    }
    return getDefaultTaxAmount
    
}


// Test
func  test_returningFunction()  {
    
    var countryCode = "US"
    print("Country Code = " + countryCode)
    
    // Get function.
    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ụ:

Xem thêm các chuyên mục: