Swift.png
函数的简单说明
- 函数是一段完成特定任务的独立代码片段。
- 在定义一个函数时，有多个或者一个数据类型的值，作为函数的输入，成为参数
- 在一定某个类型的值作为返回值的时候，成为返回类型
- 以
func作为前缀，指定函数的返回类型时，用返回箭头->后跟返回类型的名称的方式表示
//表示如下:
func 函数名(参数1:参数类型，参数2:参数类型，参数3:参数类型...) -> 返回值类型 {
代码块
return 返回值
}
注意: 函数的参数默认是
let类型，不可以修改的，如果想要修改，必须使用inout关键字 就是后面说的引用类型指针传递
函数参数与返回值
- 无参数无返回值的函数
func hanshu() -> Void {
print("没有参数，没有返回值");
}
hanshu();
//打印结果: 没有参数，没有返回值
//简写的 没有返回值的话 直接简写
func hanshu(){
print("没有参数，没有返回值");
}
hanshu();
//注意：严格上来说，虽然没有返回值被定义，hanshu() 函数依然返回了值。没有定义返回类型的函数会返回一 个特殊的 Void 值。它其实是一个空的元组(tuple)，没有任何元素，可以写成()。
- 无参数有返回值的函数
func sayHello() ->String {
return "hello 你好";
}
let hello = sayHello();
print(hello);
//打印结果: hello 你好
- 有参数 没有返回值
//name:参数名 String:参数类型
func personName(name:String) {
print("我是\(name),哈哈");
}
personName(name: "CC");
//打印结果：我是CC,哈哈
- 有参数 有返回值，多个参数用 ， 分开
func sum(num1:Int,num2:Int,num3:Int) -> Int {
return num1+num2 + num3;
}
let numSum = sum(num1: 10, num2: 20, num3: 30);
print(numSum);
//打印结果：60
- 返回一组数据的函数 多重返回值函数
//元祖 是保存一组数据的，这个函数 返回值是一个 元祖
func tulpNum(PersonName:String,PersonAge:Int,PersonSex:String) -> (name:String,age:Int,sex:String){
return (PersonName,PersonAge,PersonSex);
}
let tulp = tulpNum(PersonName: "CC", PersonAge: 20, PersonSex: "男");
tulp.name;
//打印是 “CC
//参数是数组 返回是元祖
func minMax(array: [Int]) -> (min: Int, max: Int) {
var currentMin = array[0]
var currentMax = array[0]
for value in array[1..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
} }
return (currentMin, currentMax)
}
let arrayTulp = minMax(array: [1,2,3,10,5,9]);
print(arrayTulp.min);
print(arrayTulp.max);
//打印结果是 ： min是:1
max是：10
函数参数标签和参数名称
- 指定
参数标签- 可以在函数名称前指定它的
参数标签，中间以空格分隔
- 可以在函数名称前指定它的
func someFunction(argumentLabel parameterName: Int) {
// 在函数体内， parameterName 代表参数值
}
// from 参数标签
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill! Glad you could visit from Cupertino."
- 忽略参数标签
- 不希望为某个参数添加一个标签，可以使用一个
下划线( _ )来代替一个明确的参数标签。
- 不希望为某个参数添加一个标签，可以使用一个
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)
- 默认参数
- 某些情况,如果没有传入具体的参数,可以
使用默认参数
- 某些情况,如果没有传入具体的参数,可以
func makecoffee(type :String = "卡布奇诺") -> String {
return "制作一杯\(type)咖啡。"
}
let coffee1 = makecoffee("拿铁")
// "制作一杯拿铁咖啡。"
let coffee2 = makecoffee()
// 打印："制作一杯卡布奇诺咖啡。
- 可变参数
- swift中函数的参数
个数可以变化，它可以接受不确定数量的输入类型参数 - 它们必须具有相同的类型
- 我们可以通过在参数类型名后面加入（
...）的方式来指示这是可变参数
- swift中函数的参数
注意:一个函数，
最多只能有一个可变参数，紧跟在可变参数后面的参数不能省略参数标签
func sum(numbers:Double...) -> Double {
var total: Double = 0
for number in numbers {
total += number
}
return total
}
sum(100.0, 20, 30)
sum(30, 80)
//注意： 一个函数最多只能拥有一个可变参数。
- 引用类型(指针的传递)
- 默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
- 必须是变量,因为需要在内部改变其值
- Swift提供的
inout关键字就可以实现
// 函数一:值传递
func swap(var a : Int, var b : Int) {
let temp = a;
a = b;
b = temp
print("a:\(a), b:\(b)")
}
var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")
// 函数二:指针的传递
func swap1(a:inout Int, inout b : Int) {
let temp = a
a = b
b = temp
print("a:\(a), b:\(b)")
}
swap1(&a, b: &b)
print("a:\(a), b:\(b)")
函数的类型
// 函数类型 (Int, Int, Int) -> Int
//函数类型： 参数类型 和返回值类型 组成
func sum(num1:Int,num2:Int,num3:Int) -> Int {
return num1+num2 + num3;
}
//函数类型作为参数
func exen(n1:Int,n2:Int,n3:Int,fun:(Int,Int,Int) -> Int) -> Void{
let result = fun(n1,n2,n3);
print(result);
}
exen(n1: 10, n2: 10, n3:30,fun: sum);
//函数类型作为返回值
func getFunc() -> (Int,Int,Int) -> Int{
return sum;
}
let value1 = getFunc();
value1(20,30,20);
//打印： 70
//函数类型 作为 类的属性
//编辑器根据
1.函数的名称分别函数
2.根据外部参数名称 分别函数
3.根据 参数类型 + 返回值类型 = 函数类型 来区别
函数重载
- 函数名相同
- 参数个数不同 || 参数不同 || 参数标签不同
//函数名相同 参数标签不同
func f1(v1:Int,v2:Int){
print(v1 + v2);
}
func f1(v3:Int,v4:Int){
print(v3 + v4);
}
内联函数
- 内联函数:
在函数调用的时候， 把其展开成函数体，直接执行 - 以下函数是不会内联的
- 函数体过长
- 包含递归函数
- 包含动态派发
在Swift中的项目中，如果在打包函数或者调试中使用
Release模式,
image.png
image.png
