Swift-函数

Posted on | In | | Visitors:

文章是根据The Swift Programming Language 来总结的，今天就学习一下最基础的函数用法，本文总结的是函数的声明与使用

OC的方法声明与使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 没有参数，没有返回值
- (void)sayHolle{
    NSLog(@"Hello, Objective-C");
}
// 一个参数，没有返回值
- (void)oneParam:(NSString *)name{
    NSLog(@"%@", name);
}
// 多个参数，没有返回值
- (void)moreParam:(NSString *)name age:(NSInteger)age score:(double)score{
    NSLog(@"%@--%@--%@", name, @(age), @(score));
}
// 没有参数，有返回值
- (NSString *)returnMyName{
    return @"daisuke";
}
// 多个参数，有返回值
- (NSString *)getInfoWithName:(NSString *)name age:(NSInteger)age score:(double)score{
    return [NSString stringWithFormat:@"%@--%@--%@", name, @(age), @(score)];
}
- (void)viewDidLoad {
    [super viewDidLoad];
    [self getInfoWithName:@"daisuke" age:24 score:99];
}

Swift的函数声明与使用

  • 函数的格式：func 函数名(参数: 参数类型...) -> 返回值 { // 代码实现 }

  • 没有返回值的时候， -> 返回值可以省略

  • 默认情况下，在调用函数时，第一个参数名是省略的

没有参数，没有返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
// 没有参数，没有返回值
func printlOut(){
    print("Hello,Swift")
}
// 调用函数
printlOut()
// 或者
func printlOut1() ->Void{
    // 没有返回值的时候，->void可以省略
    print("Hello,Swift")
}
// 调用函数
printlOut1()

声明一个参数的函数

1
2
3
4
5
6
// 声明一个参数的函数
func testOneParam (age:(Int)){
    print("My age is \(age)")
}
// 调用函数
testOneParam(10)

声明多个参数的函数

1
2
3
4
5
6
// 声明多个参数的函数
func testMoreParam (age:(Int), name:(String), score:(Double)){
    print("My name is \(name) and age is \(age) and score is \(score)")
}
// 调用函数,注意调用的时候为了方便传入的参数能对应起来，并且方便阅读，参数前面需要些参数的名称加冒号，第一个不写
testMoreParam(10, name: "daisuke", score: 100.0)

_的作用

1
2
3
4
5
6
// 当然，如果你觉得这样写不好，可以省略参数名，就是在声明函数的时候参数名前面加入下划线_,而且默认第一个已经省略了
// 声明多个参数的函数
func testMoreParam1 (age:(Int), _ name:(String), _ score:(Double)){
    print("My name is \(name) and age is \(age) and score is \(score)")
}
testMoreParam1(10, "daisuke", 100.0)

有返回值，没有参数

1
2
3
4
5
6
// 有返回值，没有参数
func getMyName() ->String{
    return "daisuke"
}
var name = getMyName()
print(name)

有返回值，有参数

1
2
3
4
5
6
// 有返回值，有参数
func getMyInfo(name:String, age:Int) ->String{
    return "my name is \(name) and age is \(age)"
}
var info = getMyInfo("daisuke", age: 24)
print(info)

嵌套函数

1
2
3
4
5
6
7
// 嵌套函数
func getAllInfo(name:String, _ age:Int, score:Double) ->String{
    let info = getMyInfo(name, age: age)
    return "\(info)  and score is \(score)"
}
let allInfo = getAllInfo("daisuke", 23, score: 100)
print(allInfo)

Swift的类型

函数类型：1、类似于C语言的指向函数的指针。2、类似OC语言的block。3、函数类型是由函数的参数类型和返回值类型组成的

先定义两个通用函数

1
2
3
4
5
6
7
8
// 加法函数
func sum(a: Int, b: Int) ->Int{
    return a+b
}
// 减法函数
func sub(a: Int, b: Int) ->Int{
    return a-b
}

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

1
2
3
4
5
6
7
// 利用函数类型定义函数变量和常量
var funcSum :(Int, Int) ->Int = sum
print(funcSum(10, 20))
// 30
funcSum = sub
print(funcSum(10, 20))
// -10

这里解释一下，可以理解为sum函数的声明，跟变量的类型声明必须一样，那就相当于变量funcSum就是函数sum了，所以funcSum = sum,就相当于funcSum是加法函数，得出的值是30.而funcSum = sub就相当于减法函数，的出来的值是-10.

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

1
2
3
4
5
6
7
8
// 加法函数当做参数
func scoreFunc(math: Int, english: Int, sum:(Int, Int) ->Int) ->Int
{
    return sum(math, english)
}
var totalScore = scoreFunc(100, english: 60, sum: sum)
print(totalScore)
// 160
1
2
3
4
5
6
7
8
// 减法函数当做参数
func scoreFuncSub(totalScore: Int, math: Int, sub:(Int, Int) ->Int) ->Int
{
    return sub(totalScore, math)
}
var subScore = scoreFuncSub(100, math: 50, sub: sub)
print(subScore)
// 50

可以理解为参数就是一个函数，但是参数的类型跟函数的类型必须一样，无论参数还是返回值，sum:(Int, Int) ->Int就是跟func sum(a: Int, b: Int) ->Int两个类型必须一样，总结一句话，就是函数就是一个参数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 chooseTrue:(Int, Int) ->Int = chooseFunc(true)
print(chooseTrue(10,30))
// 30
var chooseFalse:(Int, Int) ->Int = chooseFunc(false)
print(chooseFalse(10,30))
// 10

chooseFunc函数的返回值就是一个函数，而且他是根据参数getMax判断是否取最大还是最小，当true的时候取最大的函数max，也教师返回max函数，而max函数赋值给类型一样的变量chooseTrue，前面已经有例子，所以chooseTrue也就相当于max函数，调用chooseTrue函数就是max函数