Swift基础语法-函数-对比OC

1. 函数的概念:

完成某个特定任务的代码块, 给代码起一个合适的名称称之为函数名称.

以后需要执行代码块只需要利用函数名称调用即可.

好比每个人都有一个名字, 叫名字就能找到对应的人

在 Swift 中函数是可以嵌套定义, 在其他语言是不可嵌套定义函数(方法)

Swift中函数的格式:

func 函数名称(参数名:参数类型, 参数名:参数类型…) -> 函数返回值 {函数实现部分}

2. OC 的方法与 Swift 中函数比较

OC中的对象方法

//不带参数
- (void)say{
NSLog(@"hello");
}

//带有一个参数
- (void)sayWithName:(NSString *)name{
NSLog(@"hello %@", name);
}

//带有多个参数
- (void)sayWithName:(NSString *)name age:(NSInteger)age{
NSLog(@"hello %@ , I'm %tu years old", name, age);
}

//有返回值
- (NSString *)info{
return @"name = CDH, age = 20";
}

//有返回值,并且带有返回值
- (NSString *)infoWithName:(NSString *)name age:(NSInteger)age{
return [NSString stringWithFormat:
@"name = %@,
age = %tu", name, age];
}

Swift 中的函数

//无参无返回值
func say() -> Void{
print("hello")
}
say()
//输出结果: hello

func say1() {  //如果没有返回值可以不写
print("hello")
}
say1()
//输出结果: hello

//有参无返回值
func sayWithName(name:String){
print("hello \(name)")
}
sayWithName("CDH")
//输出结果: hello CDH

//带有多个参数
func sayWithName(name:String, age:Int){
print("hello \(name) , I'm \(age) years old ")
}
sayWithName("CDH", age: 20)
//输出结果: hello CDH , I'm 20 years old

//无参有返回值
func info() -> String{
return "name = cdh, age = 20"
}
print(info())
//输出结果: name = cdh, age = 20

//有参有返回值
func info(name:String, age:Int) -> String{
return "name = \(name), age = \(age)"
}
print(info("cdh", age:20))
//输出结果: name = cdh, age = 20

//嵌套函数
var arr:Array<String> = ["cdh","Aarak","520"]
func showArray(array:[String]){
for number in array{
print("\(number), ")
}
}
showArray(arr)
//输出结果:
//cdh,
//Aarak,
//520,

func bubbleSort(inout array:[Int]){
func swap(inout a:Int, inout b:Int){
let temp = a
a = b
b = temp
}
let count = array.count;
for var i = 1; i < count; i++ {  // 推荐写成 i += 1
for var j = 0; j < (count - i); j++ {
if array[j] > array[j + 1] {
swap(&array[j], b: &array[j + 1])
}
}
}
}
var arr1:Array<Int> = [50,20,30,80]
bubbleSort(&arr1)
print(arr1)
//输出结果: [20, 30, 50, 80]

3. 内部函数与外部函数

内部函数: 默认情况下的参数都是内部参数

外部函数: 如果有多个参数的情况, 调用者并不知道每个参数的含义, 只能通过查看头文件的形式理解参数的含义, 那么能不能和OC一样让调用者直观的知道参数的含义呢? 使用外部参数, 外部参数只能外部用, 函数内部不能使用, 函数内部只能使用内部参数

在swift2.0时, 除第一个函数参数默认情况还是内部参数,其他参数都是外部参数, 在3.0 之后默认所有的参数都是外部参数

func divisionOpertaion1(a: Double, b:Double) -> Double{
return a / b
}
func divisionOpertaion2(dividend: Double, divisor:Double) -> Double{
return dividend / divisor
}
func divisionOpertaion3(dividend a: Double, divisor b:Double) -> Double{
return a / b
}
print(divisionOpertaion3(dividend: 10, divisor: 3.5))
func divisionOpertaion4(a: Double, divisor b:Double) -> Double{
return a / b
}
print(divisionOpertaion4(10, divisor: 3.5))
//输出结果:
//2.85714285714286
//2.85714285714286

func divisionOpertaion(dividend: Double, divisor:Double) -> Double{
return dividend / divisor
}
print(divisionOpertaion(10, divisor: 3.5))
//输出结果:2.85714285714286

//默认参数:
//可以在定义函数的时候给某个参数赋值, 当外部调用没有传递该参数时会自动使用默认值
func joinString(s1:String ,toString s2:String, jioner s3:String) ->String
{
return s1 + s3 + s2;
}

func joinString2(s1:String ,toString
s2:String, jioner
s3:String = "❤️") ->String
{
return s1 + s3 + s2;
}
print(joinString2("hi", toString:"beauty"))
//输出结果:hi❤️beauty

如果指定了默认参数, 但是没有声明外部参数时, 系统会自动把内部参数名称既作为内部参数也作为外部参数名称

func joinString3(s1:String ,toString s2:String,jioner:String = "❤️") ->String{
return s1 + jioner + s2;
}
print(joinString3("hi", toString:"beauty", jioner:"��"))
//输出结果: hi��beauty

在其它语言中默认参数智能出现在参数列表的最后面, 但是在Swift中可以出现在任何位置

func joinString4(s1:String ,
jioner:String = "❤️",
toString s2:String) ->String
{
return s1 + jioner + s2;
}
print(joinString4("hi", jioner:"��", toString:"beauty"))
//输出结果: hi��beauty

常量参数和遍历参数:

默认情况下Swift中所有函数的参数都是常量参数

如果想在函数中修改参数, 必须在参数前加上var,

func swap(var a:Int, var b:Int){
print("交换前 a = \(a) b = \(b)")
let temp = a;
a = b;
b = temp;
print("交换后 a = \(a) b = \(b)")
}

inout参数

在 Swift 中没有指针这一概念, 但使用了 inout 也就相当于指针

如果想在函数中修改外界传入的参数

可以将参数的var换成inout, 这回会传递参数本身而不是参数的值

func swap(inout a:Int, inout b:Int)
{
let temp = a;
a = b;
b = temp;
}
var x1 = 10;
var y1 = 20;
print("交换前 a = \(x1) b = \(y1)")
swap(&x1, b: &y1)
print("交换后 a = \(x1) b = \(y1)")
//输出结果:
//交换前 a = 10 b = 20
//交换后 a = 20 b = 10

变参函数

如果没有变参函数 , 并且函数的参数个数又不确定那么只能写多个方法或者用将函数参数改为集合

变参只能放到参数列表的最后一位, 变参必须指定数据类型, 变参只能是同种类型的数据

func add(num1:Int, num2:Int, num3:Int) -> Int {
let sum = num1 + num2 + num3
return sum
}
print(add(1, num2: 2, num3: 3))
//输出结果:6

func add(nums:[Int]) -> Int {
var sum = 0;
for num in nums {
sum += num
}
return sum
}
print(add([1, 2, 3]))
//输出结果:6

func add(nums:Int...) -> Int{
var sum = 0;
for num in nums{
sum += num
}
return sum
}
print(add(1, 2, 3))
//输出结果:6

func add(other:Int, nums:Int...) -> Int {
var sum = 0;
for num in nuts {
sum += num
}
return sum
}
print(add(99, nums: 1, 2, 3))
//输出结果:6

4. 函数类型

Swift 中函数的类型类似于C语言的指向函数的指针

Swift 中函数的类型类似于OC语言的block

函数类型是由函数的参数类型和返回值类型组成的

//这两个函数的类型是 (Int, Int) -> Int
func sum(a: Int, b: Int) ->Int {
return a + b;
}

func sub(a: Int, b: Int) ->Int{
return a - b;
}

可以利用函数类型定义函数变量和常量

//可以利用函数类型定义函数变量和常量
var funcP:(Int, Int) -> Int = sum
funcP = sub
print(funcP(10, 20))
//输出结果: -10

函数类型可以作为函数的参数

//函数类型可以作为函数的参数
func calFunc(a: Int, b: Int ,Option:(Int, Int) -> Int) ->Int{
return Option(a, b)
}
print(calFunc(10, b: 20, Option: sum))
print(calFunc(10, b: 20, Option: sub))
//输出结果:
//30
//-10

函数类型可以作为函数返回值

//函数类型可以作为函数返回值
func max(a: Int, b: Int) -> Int{
return a > b ? a : b
}
func min(a: Int, b: Int) -> Int{
return a < b ? a : b
}

func chooseFunc(getMax:Bool) -> (Int , Int) -> Int{
return getMax ? max : min
}

var funcP2:(Int , Int) -> Int = chooseFunc(false)
print(funcP2(10, 20))
//输出结果: 10