Die Anleitung zu Swift Function

View more Tutorials:

1- Ein Projekt erstellen
2- Die Definition von Funktion
3- Die Regelung für die Aufruf von Funktion und Methode
4- Die Funktion gibt eine Wert rück
5- Die Funktion gibt viele Werte rück
6- Die Funktion mit dem Parameter Variadic
7- Die Funktion innerhalb einer Funktion
8- Das Funktionstyp
9- Die Funktion gibt eine Funktion rück

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 
// Eine Funktion mit Rückgabestyp
func functionName(parameters) -> returntype  
{
   // Statements....
    return value;
}

// Eine Funktion ohne Rückgabestyp
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

// Die Definition von einer Funktion (function)
// Der Name der Funktion: sayHello
// Der Parameter: name, kiểu String
// Zurückgeben (return): String
func sayHello(name:String) -> String {
    
    // Wenn 'name' leer ist (empty).
    if name.isEmpty  {
        // Zurückgeben und die Funktion enden.
        return "Hello every body!"
    }
    // Wenn 'name' nicht leer ist, wird die Code durchgeführt.
    return "Hello " + name
    
}

// Die Definition einer Funktion ohne Parameter ohne das Typ vom Rückgabe.
func test_sayHello()  {
    
    // Die Aufruf auf die Funktion sayHello, in dem leeren String übertragen.
    var greeting1 = sayHello("")
    
    
    print("greeting1 = " + greeting1);
    
    // Die Aufruf auf die Funktion sayHello, 
    // die Wert "Swift" in dem Parameter übertragen.
    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

// Die Aufruf auf die Funktion test_sayHello()
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 sind die Label.
func sayHello(name1: String, name2: String)   {
    
    print("Hello " + name1);
    print("Hello " + name2);
    
}



func test_sayHello()    {
    
    
    let tom = "Tom"
    let jerry = "Jerry"
    
    // Der Regel um die Funktion aufzurufen (oder die Methode):
    // Der erste Parameter fordert kein Label.
    // Die anderen Parameter fordert die Label
    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

// Die Definition einer Funktion zur Kakulation der Summe von 3 Int 
// und das Typ Int zurückgeben.
func sum(a: Int, b: Int, c: Int) -> Int  {
    
    // Eine Variable von dem Typ int erklären.
    var ret:Int = a + b + c
    
    return ret
    
}


// Die Definition einer Funktion zur Findung der größten Zahl in der obengemeinten 3 Zählen.
func max(a: Int, b: Int, c: Int) -> Int {
    
    // Eine Variable  'm' erklären, die Wert von 0 übertragen.
    var m = a
    
    // Prüfen, ob m < b ist, dann  m = b anweisen
    if m < b  {
        m = b
    }
    
    // Wenn m > c ist, dann m zurückgeben
    if m >  c  {
        
        // Die Funktion enden
        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

// Die Definition einer Funktion mit dem Name vom  getMinMax
// Die Eingabe ist ein Array von der int Zahlen.
// Die Funktion gibt 2 Wert zurück
// Die größte und kleinste Zahl im Array
func getMinMax(arr: [Int]) -> (min: Int, max: Int)   {
    
    // Wenn der Array kein Elemente hat, (0,0) zurückgeben.
    if arr.count == 0  {
        // Die Funktion enden.
        return (0, 0)
    }
    
    // Die 2 Variable 'mi', 'ma' erklären
    // Die  Wert von dem ersten Elemente im Array für sie übertragen.
    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)
}

// Die Funktion getMinMax testen.
func test_returningTupleExample()    {
    
    // Ein Array von int Zahlen.
    var years: [Int] = [2000, 1989, 1975, 2005, 2016]
    
    // Die Aufruf nach der Funktion getMinMax.
    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

// Eine Funktion mit dem Parameter Variadic: nums
// Der Parameter nums: wie ein Array von Int Zahlen.
func sum(nums: Int...) -> Int {
    
    var retNumber : Int = 0
    
    
    for n in nums {
        retNumber = retNumber + n
    }
    
    return retNumber
    
}

// Die Funktion mit dem Parameter Variadic benutzen:
func test_sum()    {
    
    // Die Aufruf auf die Funktion sum, und 3 Parameter übertragen.
    var sum1 = sum(1, 2, 3)
    
    print("sum(1, 2, 3) = \(sum1)")
    
    // Die Aufruf auf die Funktion sum und 3 Parameter übertragen
    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

// Die Funktion gibt die Steuer nach der Staatscode und dem Gehalt zurück.
func getTaxAmount(countryCode:String, salaryAmount:Int) -> Int  {
    
    // Eine Funktion zur Steuerkalkulation von USA.
    func getUsaTaxAmount( salaryAmount: Int)  -> Int {
        // 15%
        return 15*salaryAmount/100
    }
    
    // Eine Funktion zur Steuerkalkulation von Vietnam
    func getVietnamTaxAmount( salaryAmount:Int)  -> Int {
        // 10%
        return 10 * salaryAmount/100
    }
    
    if countryCode == "US" {
        
        return getUsaTaxAmount(salaryAmount)
        
    } else if countryCode == "VN" {
        
        return getVietnamTaxAmount(salaryAmount)
        
    }
    
    // Die restlichen Staaten (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

// Eine Funktion zur Steuerkalkulation von USA.
// Das Funktionstyp: (Int) -> (Int)
func getUsaTaxAmount(salary: Int)  -> Int {
    
    return 15 * salary / 100
}

// Eine Funktion zur Steuerkalkulation von Vietnam.
// Das Funktionstyp : (Int) -> (Int)
func getVietnamTaxAmount(salary: Int) -> Int  {
    
    return 10 * salary / 100
}

// Eine Default Funktion zur Steuerkalkulation .
// Das Funktionstyp: (Int) -> (Int)
func getDefaultTaxAmount(salary: Int) -> Int {
    
    return 5 * salary / 100
}

// Die Funktion gibt eine Funktion zurück
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

View more Tutorials: