《Swift 4.0 语言学习之路》第一章 语法基础篇（2）

1.7 函数

 

1.7.1函数定义

func 函数名（参数列表）->返回值类型{

函数体

}

其中参数列表：

[参数标签1]形式参数1：类型,[参数标签2]形式参数2：类型,........................

e.g.

func add(n1:Int,n2:Int)->{

return n1+n2

}

var n=add(n1:12,n2:13)

 

1.7.2 函数返回多个值(用元组实现)

func compare(_ numbers: [Int]) -> (min: Int, max: Int, sum: Int) {
   var min = numbers[0]
   var max = numbers[0]
   var sum = 0
   for score in numbers {
       if score > max {
           max = score
       } else if score < min {
           min = score
       }
       sum += score
   }   
   return (min, max, sum)
}
let result = compare([11,2,34,56,1])
print (result) //(min: 1, max: 56, sum: 104)

1.7.3 函数的参数标签

函数使用它们的参数名称作为它们参数的标签，在参数名称前可以自定义参数标签，或者使用 _ 表示不使用参数标签,或者省略标签，使用参数名作为标签。

func hi2(_ name: String) -> String {      //不使用标签
    return "Hello \(name)."
}
print( hi2("aven"))//Hello aven.   //hi2("aven")



func hi2(nickname name: String) -> String {   //标签nikname
    return "Hello \(name)."
}
print( hi2(nickname:"aven")) //Hello aven.  //hi2(nickname:"aven")


func hi2(name: String) -> String {      //不使用标签,无 “_” 默认函数参数名作为参数标签
    return "Hello \(name)."
}
print( hi2(name:"aven"))//Hello aven.   //hi2("aven")

1.7.4 函数参数默认值

func sayHi(name :String="world"){

print("Hi,\(name)")

}

sayHi()  // 默认参数

sayHi(name:"aab")  //aab

1.7.5 可变参数

在函数参数后面加 ... 表示该参数接受0或多个值

unc data(numbers: Int...) -> Double {
    var sum = 0
    let count = numbers.count
    for number in numbers {
        sum += number
    }
    if count == 0 {
        return 0
    }
    return Double(sum/count)
 }
 print(data(numbers: 1,2,111))//38.0
 print(data(numbers: 22,1,43,12,53))//26.0
 print(data())//0.0

1.7.6 输入输出参数

一般函数的实际参数值不会因为函数的调用而改变，如果要改变，可在参数前 加 inout 关键字

func swap(a:inout String,b:inout String){
(a,b)=(b,a)
}

var a:String ="string1",b:String = "string2"

swap（%a,%b）

1.7.7 函数类型

(int,int)->int

int->int  //当参数类型只有一个时，可省略括号

let maxfunc:(num1:Int,num2:Int)->Int=max  //参数类型中还可以指定外部参数名，此处max表示函数，maxfunc为外部参数名 调用方法

                                                                     //为：maxfunc(n1:10,n2:1)

注意：函数也可以作为另一个函数的参数,也可以当做参数传入另一个函数

func hasAnyMatches(bumber: Int, condition: (Int) -> Bool) -> Bool {
    if condition(bumber) {
        return true
    }
    return false
 }

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        print (number)
        return 1 + number
    }
    return addOne //((Int) -> Int)
 }

1.7.8 函数嵌套。(被嵌套的函数可以访问外侧函数的变量)

unc newdata(_ number: Int) -> Int {
    var y = number;
    func add() {
       y += 5
    }
    add()
    return y
}
print(newdata(18)) //23

1.7.9函数参数的修饰符

函数内参数不能被修改，默认为let类型，想改得用inout.

func a(pp:Int){

pp= - pp

}    // 错误！！！不能修改let类型的pp

 

1.8 程序控制流

 

1.8.1条件判断

• if 表达式

格式：

if   条件表达式 {         //这里条件表达式必须为Bool类型

语句

}

else if{

语句

}

else if{

语句

}

.....

else{        //最后为else，{  }不可省略！

语句

}

• switch 语句

与c++不同的是执行完一条case语句以后，不会向下执行其他的case语句，每一个case语句后面必须至少有一个可执行语  句，一般会在最后加上default语句,表示当前面的case条件全部判断完后,还有其他条件就执行default后的语句。

 

格式：

    

1.8.2循环

• for-in 循环：

var arrData=[1,2,3]
for item in arrData{
    print("item=/(item)")  //item=1
                           //item=2
}                          //item=3


for _ in 1...5{    //不需要用到变量时，可用_代替
    print("hi")


for index in 1...3{
    print("index time 3 is\(index*2)")//index time 3 is 2
}                                     //index time 3 is 4
                                      //index time 3 is 8

• while 循环

格式：

• repeat-while循环（至少执行一次语句）

格式：

1.8.3 控制转移语句

break

continue

fallthrough // 继续执行switch中的下一个case语句

1.9闭包

闭包是一组用{}括起的自含功能语句块，可在代码中传递和使用。闭包参数的使用与函数类似，但不能提供参数默认值。

格式：

var max:(Int,Int)->Int={  //定义
    (num1:Int,num2:Int)->Int in

    return num1>num2?num1:num2

}


let m=max(10,2)//使用

闭包的一些省略写法

//: 参数类型及返回值由推断决定，可省略，此时表示参数部分的圆括号，也可省略
typealias MyClosure = (Int,Int) -> Int
var max2:MyClosure = { num1,num2 in
    return num1>num2 ? num1 : num2
}
let mValue2 = max2(10,2)
//: 由 $0、$1 等表示第一、第二、。。。等参数，省略参数部分以及 in 关键字
var max3:(Int,Int)->Int = {
    return $0>$1 ? $0 : $1
}
let mValue3 = max3(10,2)
//: 如果只有一个语句，则 return 可省略
var max4:(Int,Int)->Int = {
    $0>$1 ? $0 : $1
}
let mValue4 = max4(10,2)

闭包的內联（in-line）使用

/*函数functionTakesClosureAsParam的第一个参数 value 被传递作为myClosure 的参数。myClosure 的类型为(Int)->Int，这里无须指定参数名。*/
//以下为函数functionTakesClosureAsParam 定义

func functionTakesClosureAsParam(value: Int, myClosure: (Int) -> Int) -> Int {
    
/*函数内使用 myClosure 时，其参数（Int）可通过capturing value 机制获取函数外的变量值而得，或在函数内部通过某种途径得到，如本例获取函数的第一个参数而得*/
    
return myClosure(value)
}


//: functionTakesClosureAsParam 函数参数 Closure 的使用(非 inline)
let paramClosure = {(param:Int) -> Int in
    return param>0 ? param : -param
}
let v0 = functionTakesClosureAsParam(value: -2, myClosure:paramClosure)


//: functionTakesClosureAsParam 函数参数 Closure 的in-line调用：
let v1 = functionTakesClosureAsParam(value: 2, myClosure: {(value:Int) -> Int  in
    value * 3
})


//: Closure 参数可以通过 $0、$1、... 等引用。由于函数的第一个参数作为myClosure 的参数，故本例 $0 为 2
let v2 = functionTakesClosureAsParam(value: 2, myClosure: {$0 * 3})
print(v2)

//: 尾随闭包(Trailing Closure)。当 Closure 是函数的最后一个参数时，可以简写为：
let v3 = functionTakesClosureAsParam(value: 2) {$0 * 3}

1.10枚举(enum)

一般情况下枚举的各个值并不是自动从0开始的，而是特定的枚举类型，但有时需要用到特定类型（如Int、string等）的值（原始值raw value）来表示。下图的枚举的值默认从0开始（第一张图），也可以定义从其他值开始（见第二张图）。

raw values 规则：

• 相同类型
• 每个枚举内raw values 值必须唯一
• 如果某个枚举成员的值没有指定，会通过前一个值自动增加赋予

 

未完待续。。。