Funktionsdefinition
func 函数名(形参列表) -> 返回值类型 {
// 函数体...
}
Das Format der formalen Parameterliste:
formaler Parametername 1: formaler Parametertyp 1, formaler Parametername 2: formaler Parametertyp 2, …
func num() -> Double {
return 3.1415926
}
num()
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
sum(v1: 20, v2: 30)
- Der formale Parameter ist standardmäßig let und kann nur let sein
Wenn eine Funktion keinen Rückgabewert hat, gibt es drei Möglichkeiten, ihn zu schreiben:
Wenn eine Funktion keine formalen Parameter hat, dürfen die Klammern nach dem Funktionsnamen nicht weggelassen werden.
func 函数名(形参列表) -> Void {
// 函数体...
}
func 函数名(形参列表) -> () {
// 函数体...
}
func 函数名(形参列表) {
// 函数体...
}
//无返回值写法
func sayGo() -> Void {
print("Go")
}
sayGo()
func saySiri() -> (){
print("Siri")
}
saySiri()
func sayBye() {
print("Bye")
}
sayBye()
implizite Rückkehr
- Wenn der gesamte Funktionskörper ein einzelner Ausdruck ist, gibt die Funktion diesen Ausdruck implizit zurück
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
sum(v1: 30, v2: 40)
Rückgabetupel: Implementieren Sie mehrere Rückgabewerte
//返回这组数的和、差、平均值
func calculate (v1: Int, v2: Int) -> (sum : Int, dif: Int, ave: Int){
let sum = v1 + v2
return (sum, v1 - v2, sum >> 1)
}
let result = calculate(v1: 30, v2: 20)
result.sum // 50
result.dif // 10
result.ave // 25
Dokumentationskommentare für Funktionen
- Tastenkombination Option + Befehl + /
/// 求和【概述】
///
///将2个整数相加【更详细的描述】
///
/// - Parameters:
/// - v1: 第一个整数
/// - v2: 第二个整数
/// - Returns: 2个整数的和
///
/// - Note: 传入2个整数即可【批注】
///
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
sum(v1: 30, v2: 40)
- Weitere Informationen finden Sie in der offiziellen Dokumentation
Argumentbezeichnung
- Parameterbezeichnungen können geändert werden
func-Funktionsname (externer Parametername, lokaler Parametername: formaler Parametertyp)
func goToWork(at time: String) {
print("this time is \(time)")
}
goToWork(at: "10:00")
//this time is 10:00
- Unterstriche können verwendet werden, um Parameterbezeichnungen wegzulassen
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
sum(30, 40)
Standardparameterwert
func-Funktionsname (formeller Parametername: formaler Parametertyp = Standardwert)
- Parameter können Standardwerte haben
func check(name: String = "nobody", age: Int, job: String = "none"){
print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor") // name=Jack, age=20, job=Doctor
check(name: "Rose", age: 18) //name=Rose, age=18, job=none
check(age: 10, job: "Batman") //name=nobody, age=10, job=Batman
check(age: 15)//name=nobody, age=15, job=none
- Die Standardparameterwerte von C++ unterliegen einer Einschränkung: Sie müssen von rechts nach links festgelegt werden. Da Swift über Parameterbezeichnungen verfügt, gibt es keine solche Einschränkung
- Beim Weglassen von Parameterbezeichnungen ist besondere Aufmerksamkeit erforderlich, um Fehler zu vermeiden.
// 这里的middle 不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30){
}
Variadischer Parameter
- Ein variadischer Parameter kann einen oder mehrere Werte annehmen
- Beim Aufruf einer Funktion können Sie variable Parameter verwenden, um eine unbestimmte Anzahl von Eingabeparametern zu übergeben.
- Variablenparameter werden durch Hinzufügen von ... nach dem Namen des Variablentyps definiert
- Der als variabler Parameter übergebene Wert wird im Funktionskörper als Array dieses Typs behandelt. Beispielsweise kann ein Variablenparameter vom Typ Int... mit dem Namen „Numbers“ als Array-Konstante vom Typ Int[] mit dem Namen „Numbers“ im Funktionskörper behandelt werden.
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers{
total += number
}
return total
}
sum(10, 20, 30, 40) // 100
- ein funktionsvariadischer
最多只能有1个
Parameter - Die Parameterbezeichnung unmittelbar nach dem variablen Parameter kann nicht weggelassen werden
//参数string不能省略参数标签
func test1(_ numbers: Int..., string: String, _ other: String){
}
test1(10, 20, 30, string: "Jack", "Rose")
Swifts eigene Druckfunktion
print(1, 2, 3, 4, 5) // 1 2 3 4 5
print(1, 2, 3, 4, 5, separator: "_") // 1_2_3_4_5
print("My name is Jake.", terminator: "")
print("My age is 18.")
// My name is Jake.My age is 18.
In-Out-Parameter
- Mit inout können Sie einen Eingabe- und Ausgabeparameter definieren: Der Wert des externen Parameters kann innerhalb der Funktion geändert werden
var number = 20
func test (_ num: inout Int){
num = 30
}
test(&number)
print(number) // 30
//交换两个值
func swapValues(_ v1: inout Int, _ v2: inout Int){
let tmp = v1
v1 = v2
v2 = tmp
}
var num1 = 20
var num2 = 30
swapValues(&num1, &num2)
print(num1, num2)
//可以用元组实现交换两个值
func swapValues(_ v1: inout Int, _ v2: inout Int){
(v1, v2) = (v2, v1)
}
var num1 = 20
var num2 = 30
swapValues(&num1, &num2)
print(num1, num2)
- Variable Parameter können nicht als inout markiert werden
- Inout- Parameter dürfen keine Standardwerte haben
- Der Inout- Parameter kann nur übergeben und mehrfach zugewiesen werden.
- Die Essenz von Inout -Parametern ist die Adressübergabe (Übergabe als Referenz).
Funktionsüberlastung
- Regel
-
- Funktionsnamen sind gleich
-
- Die Anzahl der Parameter ist unterschiedlich. || Die Parametertypen sind unterschiedlich. || Die Parameterbezeichnungen sind unterschiedlich
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int) -> Int {
v1 + v2 + v3
}// 参数个数不同
func sum(v1: Int, v2: Double) -> Double {
Double(v1) + v2
}// 参数类型不同
func sum(v1: Double, v2: Int) -> Double {
v1 + Double(v2)
}// 参数类型不同
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}// 参数标签不同
func sum(x v1: Int, y v2: Int) -> Int {
v1 + v2
}// 参数标签不同
func sum(a: Int, b: Int) -> Int {
a + b
}// 参数标签不同
sum(v1: 10, v2: 20) // 30
sum(v1: 10, v2: 20, v3: 30) // 60
sum(v1: 10, v2: 20.0) // 30.0
sum(v1: 10.0, v2: 20) // 30.0
sum(10, 20) // 30
sum(x: 10, y: 20) // 30
sum(a: 10, b: 20) // 30
Hinweise zur Funktionsüberladung
- Der Rückgabewerttyp hat nichts mit Funktionsüberladung zu tun
- Wenn Standardparameterwerte und Funktionsüberladung zusammen verwendet werden, um Mehrdeutigkeit zu erzeugen, meldet der Compiler keinen Fehler (in C++ meldet er einen Fehler).
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(v1: Int, v2: Int, v3: Int = 10) -> Int{
v1 + v2 + v3
}
// 会调用 sum(v1: Int, v2: Int)
sum(v1: 10, v2: 20)
- Wenn variable Parameter, ausgelassene Parameterbezeichnungen und Funktionsüberladung zusammen verwendet werden, um Mehrdeutigkeiten zu erzeugen, meldet der Compiler möglicherweise einen Fehler.
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers {
total += number
}
return total
}
// error: Ambiguous use of 'sum'
sum(10, 20)
Inline-Funktion
- Wenn die Compiler-Optimierung aktiviert ist (im Release-Modus ist die Optimierung standardmäßig aktiviert), wandelt der Compiler einige Funktionen automatisch in Inline-Funktionen um
-
- Erweitern Sie Funktionsaufrufe zu Funktionskörpern
- Erweitern Sie Funktionsaufrufe zu Funktionskörpern
- Welche Funktionen werden nicht automatisch integriert?
-
- Der Funktionskörper ist relativ lang
-
- Enthält rekursive Aufrufe
-
- Einschließlich dynamischer Verteilung usw.
@im Einklang
//永远不会被内联(即使开启了编译器优化)
@inline(never) func test(){
print("test")
}
// 开启编译器优化后,即使代码很长,也会被内联(递归调用函数、动态派发的函数除外)
@inline(__always) func test() {
print("test")
}
- Im Release-Modus hat der Compiler die Optimierung aktiviert und ermittelt automatisch, welche Funktionen eingebunden werden müssen, sodass @inline nicht verwendet werden muss
Funktionstyp
- Ein Funktionstyp ist ein Datentyp
- Jede Funktion hat einen Typ und der Funktionstyp
形式参数类型
besteht返回值类型
aus - Drei Schritte: 1. Funktion definieren; 2. Funktionstypvariablen oder Konstanten deklarieren; 3. Funktionstypvariablen Werte zuweisen (Schritte 2 und 3 können kombiniert werden)
func test(){
}// () -> Void 或者 () -> ()
func sum(a: Int, b: Int) -> Int {
a + b
}// (Int, Int) -> Int
//定义变量
var fn: (Int, Int) -> Int = sum
fn(2,3) // 5 调用时不需要参数标签
Funktionstyp als Funktionsparameter
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
func difference(v1: Int, v2: Int) -> Int {
v1 - v2
}
func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result:\(mathFn(a, b))")
}
printResult(sum, 5, 2) //Result: 7
printResult(difference, 5, 2) //Result: 3
Funktionstyp als Funktionsrückgabewert
func next(_ input: Int) -> Int {
input + 1
}
func previous(_ input: Int) -> Int {
input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int {
forward ? next : previous
}
var fn: (Int) -> Int = forward(true)
fn(3)
forward(false)(3)
- Der Rückgabewert ist eine Funktion vom Funktionstyp namens
高阶函数
(Funktion höherer Ordnung).
Typalias
- typealias wird zum Aliasieren von Typen verwendet
typealias Byet = Int8
typealias Short = Int16
typealias Long = Int64
var num1: Byet = 0
var num2: Short = 0
var num3: Long = 0
typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date) {
print(date.0)
print(date.year)
}
test((2022, 10, 13))
//2022
//2022
typealias IntFn = (Int, Int) -> Int
func difference(v1: Int, v2: Int) -> Int {
v1 - v2
}
let fn: IntFn = difference
fn(30, 10) // 20
func setFn(_ fn: IntFn){
}
setFn(difference)
func getFn() -> IntFn {
difference
}
- Gemäß der Definition der Swift-Standardbibliothek
Void
handelt es sich um das leere Tupel()
Verschachtelte Funktion
- Definieren Sie die Funktion innerhalb der Funktion
func forward(_ forward: Bool) -> (Int) -> Int {
func next(_ input: Int) -> Int {
input + 1
}
func previous(_ input: Int) -> Int {
input - 1
}
return forward ? next : previous
}
forward(true)(3) // 4
forward(false)(3) //2