Die Anleitung zu Swift Function

1- Ein Projekt erstellen

Zuerst sollen Sie ein Projekt erstellen um die Praxis durchzuführen. Öffnen Sie XCode und erstellen Sie ein Project:

2- Die Definition von Funktion

Im  Swift wird eine Funktion mit dem Schlüsselwort  "func" definiert. Die Funktion hat einen konkreten Name. Die Funktion kann 0 oder viele Parameter haben oder ein oder kein Rückgabetyp haben
Die Syntax zur Definierung einer Funktion
// A function has return type

func functionName(parameters) -> returntype  
{
   // Statements.
   return value;
}


// The function has no return type
func functionName(parameters)
{
    // Statements.
}
Unten ist das die Funktion mit dem Name von sayHello, mit dem Parameter vom  String, und Rückgabetyp vom  String.
MyFirstFunction.swift
import Foundation


// Define a function
// Function name: sayHello
// Parameter: name, type of String
// Return: String

func sayHello(name:String) -> String {
    
    // If name is empty.
    if name.isEmpty  {
        // Ends the function
        return "Hello every body!"
    }
    // If name is not empty, this code will be executed.
    return "Hello " + name
    
}

// Define a function, no parameters, no returns type.

func test_sayHello()  {
    
    // Call sayHello function, pass empty string.
    var greeting1 = sayHello("")
    
    
    print("greeting1 = " + greeting1);
    
    // Call sayHello function, pass "Swift" as parameter.
    var greeting2 = sayHello("Swift")
    
    print("greeting2 = " + greeting2);
    
}
Ändern Sie die Quellefile von main.swift um die von Ihnen erstellten Funktion zu prüfen
main.swift
import Foundation


// Call test_sayHello() function.

test_sayHello()
das Beispiel durchführen

3- Die Regelung für die Aufruf von Funktion und Methode

Swift 2.1 stellt einen Grundsatz zur Aufruf der Funktion, und unten ist der Grunsatz sogenannt
  • Der erste Paramter für die Funktion (oder die Methode) fordert keinen Label für den Parameter 
  • Die anderen Parameter für die Funktion (oder die Methode) müssen die Label für den Parameter fordern.
  • Alle Parameter für den Constructor fordern den Laben für den Parameter
RulesCallFunc.swift
import Foundation

// name1, name2 are Labels
func sayHello(name1: String, name2: String)   {
    
    print("Hello " + name1);
    print("Hello " + name2);
    
}



func test_sayHello()    {
    
    
    let tom = "Tom"
    let jerry = "Jerry"
    
    // Call function (Or method)
    // First parameter should not have required argument labels
    // Others parameter should have required argument labels.
    
    sayHello(tom, name2: jerry)

    
}
 

4- Die Funktion gibt eine Wert rück

Der Befehl return in der Funktion stoppt die Durchführung der Funktion und eine Wert rückgeben
FunctionExample1.swift
import Foundation


// Define a function to add 3 number type of Int, return Int.

func sum(a: Int, b: Int, c: Int) -> Int  {
    
    // Declare a variable type of Int
    var ret:Int = a + b + c
    
    return ret
    
}


// Define a function to find the largest number in 3 numbers.

func max(a: Int, b: Int, c: Int) -> Int {
    
    // Declare varriable m, assign value = a.
    var m = a
    
    // Check if m < b then assgin m = b.
    if m < b  {
        m = b
    }
    
    // If m > c then return m.
    if m >  c  {
        
        // End function.
        return m;
    }
    
    return c
    
}

5- Die Funktion gibt viele Werte rück

Im  Swift kann eine Funktion viele Werte rückgeben. Auf die Natur gibt diese Funktion eine Tuple (die Werte Reihe).   Tuple ist eine Wertreihe, die in ( ) geleget wird und durch ein Komma getrennt werden. Jede Wert hat einen Namen zum Zugriff
ReturningTupleExample.swift
import Foundation


// Defina a function named getMinMax
// Input is an array of Int.
// The function returns two values: the largest number in the array,
// and the smallest number in the array.

func getMinMax(arr: [Int]) -> (min: Int, max: Int)   {
    
    // If array has no elements, return (0,0).
    if arr.count == 0  {
        // End function
        return (0, 0)
    }
    
    // Declare 2 variables mi, ma.
    // assigned by the first element of the array.
    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 getMinMax function.
func test_returningTupleExample()    {
    
    // An array of Int.
    var years: [Int] = [2000, 1989, 1975, 2005, 2016]
    
    // Call getMinMax function.
    
    var y = getMinMax(years)
    
    print("Max = \(y.max)")
    
    print("Min = \(y.min)")
    
    
}
Ändern Sie die Quelle File   main.swift um das Beispiel zu prüfen
main.swift
import Foundation

test_returningTupleExample()
das Beispiel durchführen

6- Die Funktion mit dem Parameter Variadic

Swift benutzt  "variableName: DataType..." um einen Parameter   Variadic zu markieren. Sehen Sie das folgende Beispiel über ein Funktion mit dem Parameter Variadic und die Benutzung dieser Funktion
VariadicParamsFunction.swift
import Foundation


// A function with Variadic parameter: nums
// Parameter nums: Like an array of Int.
func sum(nums: Int...) -> Int {
    
    var retNumber : Int = 0
    
 
    for n in nums {
        retNumber = retNumber + n
    }
    
    return retNumber
    
}

// Using function, with Variadic parameter:

func test_sum()    {
    
    // Call sum function, pass 3 parameters.
    var sum1 = sum(1, 2, 3)
    
    print("sum(1, 2, 3) = \(sum1)")
    
    // Call sum function, pass 4 parameters.
    var sum2 = sum(1,4, 5, 7)
    
    print("sum(1,4, 5, 7) = \(sum2)")
    
}
Das Beispiel durchführen

7- Die Funktion innerhalb einer Funktion

Swift erlaubt Sie, eine Funktion innerhalb einer anderen Funktion zu schreiben. Diese Funktion wird in der internen Vater-Funktion benutzt
NestedFunction.swift
import Foundation

// Function return tax amount, base on country & salary.
func getTaxAmount(countryCode:String, salaryAmount:Int) -> Int  {
    
    // A function to caculate tax amount in United States.
    func getUsaTaxAmount( salaryAmount: Int)  -> Int {
        // 15%
        return 15*salaryAmount/100
    }
    
    // A function to caculate tax amount in Vietnam.
    func getVietnamTaxAmount( salaryAmount:Int)  -> Int {
        // 10%
        return 10 * salaryAmount/100
    }
    
    if countryCode == "US" {
        
        return getUsaTaxAmount(salaryAmount)
        
    } else if countryCode == "VN" {
        
        return getVietnamTaxAmount(salaryAmount)
        
    }
    
    // Other countries (5%)
    return  5 * salaryAmount / 100
    
}

8- Das Funktionstyp

Im  Swift hat jede Funktion ein Funktionstyp. Sehen Sie eine folgende Funktion

func sum(a: Int,  b: Int)  -> Int   {
    return a + b;
}
Die oben Funktion hat das Typ: 
(Int,Int) -> (Int)

9- Die Funktion gibt eine Funktion rück

ReturningFunction.swift
import Foundation

// A function to caculate tax amount in United States.
// Function type is: (Int) -> (Int)
func getUsaTaxAmount(salary: Int)  -> Int {
    
    return 15 * salary / 100
}

// A function to caculate tax amount in Vietnam.
// Function type is: (Int) -> (Int)
func getVietnamTaxAmount(salary: Int) -> Int  {
    
    return 10 * salary / 100
}

// A default function to caculate tax amount.
// Function type is: (Int) -> (Int)
func getDefaultTaxAmount(salary: Int) -> Int {
    
    return 5 * salary / 100
}

// Function return a function.
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)")
}
Ändern Sie main.swift um Beispiel zu prüfen:
main.swift
import Foundation
 

test_returningFunction()
Das Beispiel durchführen