définition de fonction
func 函数名(形参列表) -> 返回值类型 {
// 函数体...
}
Le format de la liste des paramètres formels :
nom du paramètre formel 1 : type de paramètre formel 1, nom du paramètre formel 2 : type de paramètre formel 2, …
func num() -> Double {
return 3.1415926
}
num()
func sum(v1: Int, v2: Int) -> Int {
return v1 + v2
}
sum(v1: 20, v2: 30)
- Le paramètre formel est par défaut let et ne peut être let
Si une fonction n'a pas de valeur de retour, il existe trois façons de l'écrire.
Si une fonction n'a pas de paramètres formels, les parenthèses après le nom de la fonction ne peuvent pas être omises.
func 函数名(形参列表) -> Void {
// 函数体...
}
func 函数名(形参列表) -> () {
// 函数体...
}
func 函数名(形参列表) {
// 函数体...
}
//无返回值写法
func sayGo() -> Void {
print("Go")
}
sayGo()
func saySiri() -> (){
print("Siri")
}
saySiri()
func sayBye() {
print("Bye")
}
sayBye()
retour implicite
- Si le corps entier de la fonction est une expression unique, la fonction renverra implicitement cette expression
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
sum(v1: 30, v2: 40)
Tuple de retour : implémenter plusieurs valeurs de retour
//返回这组数的和、差、平均值
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
Commentaires de documentation pour les fonctions
- Option touche de raccourci + commande + /
/// 求和【概述】
///
///将2个整数相加【更详细的描述】
///
/// - Parameters:
/// - v1: 第一个整数
/// - v2: 第二个整数
/// - Returns: 2个整数的和
///
/// - Note: 传入2个整数即可【批注】
///
func sum(v1: Int, v2: Int) -> Int {
v1 + v2
}
sum(v1: 30, v2: 40)
- Se référer à la documentation officielle
Étiquette d'argument
- Les étiquettes des paramètres peuvent être modifiées
nom de la fonction func (nom du paramètre externe nom du paramètre local : type de paramètre formel)
func goToWork(at time: String) {
print("this time is \(time)")
}
goToWork(at: "10:00")
//this time is 10:00
- Les traits de soulignement peuvent être utilisés pour omettre les étiquettes de paramètres
func sum(_ v1: Int, _ v2: Int) -> Int {
v1 + v2
}
sum(30, 40)
Valeur du paramètre par défaut
nom de la fonction func (nom du paramètre formel : type de paramètre formel = valeur par défaut)
- Les paramètres peuvent avoir des valeurs par défaut
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
- Les valeurs des paramètres par défaut du C++ ont une restriction : elles doivent être définies de droite à gauche. Puisque Swift a des étiquettes de paramètres, il n'y a pas de telle restriction
- Lors de l'omission des étiquettes de paramètres, une attention particulière est requise pour éviter les erreurs.
// 这里的middle 不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30){
}
Paramètre variadique
- Un paramètre variadique peut accepter une ou plusieurs valeurs
- Lors de l'appel d'une fonction, vous pouvez utiliser des paramètres variables pour transmettre un nombre incertain de paramètres d'entrée.
- Les paramètres de variable sont définis en ajoutant ... après le nom du type de variable
- La valeur transmise en tant que paramètre variable est traitée comme un tableau de ce type dans le corps de la fonction. Par exemple, un paramètre de variable de type Int... appelé nombres peut être traité comme une constante de tableau de type Int[] appelée nombres dans le corps de la fonction.
func sum(_ numbers: Int...) -> Int {
var total = 0
for number in numbers{
total += number
}
return total
}
sum(10, 20, 30, 40) // 100
- un
最多只能有1个paramètre variadique de fonction - L'étiquette du paramètre qui suit immédiatement le paramètre variable ne peut pas être omise.
//参数string不能省略参数标签
func test1(_ numbers: Int..., string: String, _ other: String){
}
test1(10, 20, 30, string: "Jack", "Rose")
La propre fonction d'impression de Swift
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.
Paramètre d'entrée-sortie
- Vous pouvez utiliser inout pour définir un paramètre d'entrée et de sortie : la valeur du paramètre externe peut être modifiée à l'intérieur de la fonction
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)
- Les paramètres variables ne peuvent pas être marqués comme inout
- les paramètres inout ne peuvent pas avoir de valeurs par défaut
- Le paramètre inout ne peut être transmis que et peut être attribué plusieurs fois.
- L'essence des paramètres inout est le passage d'adresse (passage par référence)
Surcharge de fonction
- règle
-
- Les noms de fonctions sont les mêmes
-
- Le nombre de paramètres est différent || Les types de paramètres sont différents || Les étiquettes des paramètres sont différentes
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
Notes sur la surcharge de fonctions
- Le type de valeur de retour n'a rien à voir avec la surcharge de fonction
- Lorsque les valeurs des paramètres par défaut et la surcharge de fonctions sont utilisées ensemble pour créer une ambiguïté, le compilateur ne signalera pas d'erreur (il signalera une erreur en C++)
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)
- Lorsque des paramètres variables, des étiquettes de paramètres omises et une surcharge de fonctions sont utilisés ensemble pour créer une ambiguïté, le compilateur peut signaler une erreur.
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)
Fonction en ligne
- Si l'optimisation du compilateur est activée (le mode Release activera l'optimisation par défaut), le compilateur transformera automatiquement certaines fonctions en fonctions en ligne.
-
- Développer les appels de fonction dans les corps de fonction
- Développer les appels de fonction dans les corps de fonction
- Quelles fonctions ne seront pas automatiquement intégrées ?
-
- Le corps de fonction est relativement long
-
- Contient des appels récursifs
-
- Y compris la distribution dynamique, etc.
@en ligne
//永远不会被内联（即使开启了编译器优化）
@inline(never) func test(){
print("test")
}
// 开启编译器优化后，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）
@inline(__always) func test() {
print("test")
}
- En mode Release, le compilateur a activé l'optimisation et déterminera automatiquement quelles fonctions doivent être intégrées, il n'est donc pas nécessaire d'utiliser @inline
Type de fonction
- Un type de fonction est un type de données
- Chaque fonction a un type, et le type de fonction
形式参数类型se compose返回值类型de - Trois étapes : 1. Définir la fonction ; 2. Déclarer des variables ou des constantes de type fonction ; 3. Attribuer des valeurs aux variables de type fonction (les étapes 2 et 3 peuvent être combinées)
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 调用时不需要参数标签
type de fonction comme paramètre de fonction
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
type de fonction comme valeur de retour de fonction
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)
- La valeur de retour est une fonction de type fonction, appelée
高阶函数(Fonction d'ordre supérieur)
alias
- typealias est utilisé pour alias les types
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
}
- Selon la définition de la bibliothèque standard Swift,
Voidil s'agit du tuple vide()
Fonction imbriquée
- Définir la fonction à l'intérieur de la fonction
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