`[Swift4](5) 函数基本使用 | 可变参数 | inout引用传递 | 函数类型返回值 | 函数嵌套`

函数基本使用

关键字:func

func hello(name:String) ->String
{
  let result =  "Hello,"+name
  return result
}
hello(name: "imagine")

可选型：

func hello(name:String?,greet:String) ->String
{
  let result =  greet+","+(name)!
  return result
}

var nickname:String?  //nil
nickname = "imagine"
hello(name: nickname,greet: "Good Night") //Good Night,imagine"

无参数函数，直接返回一个字符串类型的函数：

func sayHello() ->String
{
  return "Welcome to imaginecode"
}
sayHello() //"Welcome to imaginecode"

空类型void / () ,不返回任何值

func sayVoid() ->Void{
  print("it is a void func")
}

使用元组让函数返回多个值

func maxminScores( scores:[Int]) -> ( maxscore:Int,minscore:Int)? //元组的可选型
{
  if scores.isEmpty{
    return nil
  }
  var curmax = scores[0] ,curmin = scores[0]
  for score in scores[1..<scores.count]{
    curmax = max(curmax, score)
    curmin = min(curmin, score)
  }
  return (curmax,curmin)
}
var scores:[Int]? = [12,60,71,81,91,100] //可选型数组
scores = scores ?? []
if let result = maxminScores(scores: scores!)
{
  print(result.maxscore)
  print(result.minscore)
}

内部参数名和外部参数名

func hello(userName nickname:String,greeting greet:String) -> String{ //内部参数nickname,greet,属于函数体
  let result = greet+":"+nickname
  return result
}
hello(userName: "imagine", greeting: "codeing") //给参数nickname与greet起了外部参数名userName和greeting

参数的默认值

func hello(nickname:String,greet:String = "hello") -> String{ //给greet默认值hello
  let result = greet+":"+nickname
  return result
}
hello(nickname: "imagine") //"hello:imagine"

func hello(nickname:String,greet:String = "hello",other:String = "nihao") -> String{ //给greet默认值hello
  let result = greet+":"+nickname+other
  return result
}
hello(nickname: "imagine",other:"how do you do") //"hello:imaginehow do you do"

可变参数

一个函数最好只能设置一个可变参数，并且该可变参数只能放在这个函数参数列表的最后一个位置必须参数 > 默认值参数 > 可变参数

func add(a:Int,b:Int,others:Int ... ) ->Int //others是可变参数 ... 将其解析为数组
{
  var result = a + b
  for num in others
  {
    result += num
  }
  return result
}
var res = add(a: 2, b: 3)
res = add(a: 2, b: 3, others: 4,5,6)
NSLog(format: String, args: CVarArg...) //CvarArg也是可变参数

inout参数 - 引用传递

inout用于声明数据是地址传递，也称之为引用传递；inout修饰的参数是不能有默认值的，有范围的参数集合也不能被修饰；一个参数一旦被inout修饰，就不能再被var和let修饰了。

func swapTwoInts( a:inout Int,b:inout Int)
{
    let t = a;
    a = b
    b = t
}
var x = 0, y = 100

swapTwoInts(a: &x, b: &y) //传入引用参数

函数类型

func add(a:Int,b:Int) -> Int
{
    return a+b
}

let anotherAdd:(Int,Int)->Int = add //参数为两个Int,返回类型为Int  ,add 作为变量
anotherAdd(3,4)

func changeScores1(scores:inout [Int]) {
    for i in 0..<scores.count {
        scores[i] = Int(sqrt(Double(scores[i]))*10)
    }
}

func changeScores2(scores:inout [Int]) {
    for i in 0..<scores.count {
        scores[i] = Int(sqrt(Double(scores[i]))/150.0 * 100.0)
    }
}
func changeScores3(scores:inout [Int]) {
    for i in 0..<scores.count {
        scores[i] += 3
    }
}

var scores1 = [20,40,60,80,90]
changeScores1(scores: &scores1)

var scores2 = [20,40,60,80,90]
changeScores2(scores: &scores2)

var scores3 = [20,40,60,80,90]
changeScores3(scores: &scores3)

改进：

func changeScores(op:(Int)->Int, scores:inout [Int])
{
  for i in 0..<scores.count{
    scores[i] = op(scores[i])
  }
}
func op1(x:Int)->Int {return Int(sqrt(Double(x))*10)}
func op2(x:Int)->Int {return Int(sqrt(Double(x))/150.0*100.0)}
func op3(x:Int)->Int {return x + 3}

var scores1 = [20,40,60,80,90]
changeScores(op: op1, scores: &scores1)

var scores2 = [20,40,60,80,90]
changeScores(op: op2, scores: &scores2)

var scores3 = [20,40,60,80,90]
changeScores(op: op3, scores: &scores3)

var arr = [Int]()

for _ in 1...20
{
    arr.append(Int(arc4random()%100))
}
arr

func compareTwoInts(a:Int,b:Int) -> Bool{return a>b }

arr.sort()

返回函数类型的返回值、函数嵌套

//邮费计算
func mailcost1(weight:Int) -> Int
{
    return 1*weight
}
func mailcost2(weight:Int) -> Int
{
    return 2*weight
}
func chooseMailCostMethod(weight:Int) -> (Int)->Int //返回一个Int类型的函数，解耦作用
{
    return weight <= 10 ? mailcost1 : mailcost2
}

func totalCost(price:Int,weight:Int) -> Int
{
    let mailCost:(Int)->Int = chooseMailCostMethod(weight: weight)
    return mailCost(weight) + price*weight
}

另一种写法：函数嵌套

func mailcost1(weight:Int) -> Int
{
    return 1*weight
}
func mailcost2(weight:Int) -> Int
{
    return 2*weight
}

func totalCost(price:Int,weight:Int) -> Int
{
    func chooseMailCostMethod(weight:Int) -> (Int)->Int //函数嵌套
    {
        return weight <= 10 ? mailcost1 : mailcost2
    }
    
    let mailCost:(Int)->Int = chooseMailCostMethod(weight: weight)
    return mailCost(weight) + price*weight
}

本文由创作，采用知识共享署名4.0 国际许可协议进行许可。本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名。最后编辑时间为: 2021/05/26 10:20