Swift_学习笔记_控制语句和函数

控制语句

分支结构

if语句

switch语句

区间匹配

var age = 1000
switch age {
case 0...3:
    print("3岁以下儿童")
case 3...12:
    print("童年")
case 12...18:
    print("少年")
case 18...200:
    print("成年")
default:
    print("不可能还活着")
}

元组

var boy = (10,"boy")
switch boy {
case (0...20,"boy"):
    print("男孩")
case (20...100,"boy"):
    print("男人")
default:
    print("不可能还活着")
}

值绑定

var boy = (10,"girl")
switch boy {
case (let age,"boy"):
    print("男孩:\(age)")
case (let age,"man"):
    print("男人:\(age)")
case(let age,let sex):
    print("\(sex)：\(age)")
}
// girl：10

如果前面的条件都不满足，则会进入最后一个case，同时接收两个值，因此不需要使用default语句

where语句

利用元组和where语句进行配合使用实现更复杂的条件

var boy = (10,"man")
switch boy {
case let (age,sex) where age<12 && sex!="boy" && sex!="man":
    print("女孩：\(age)岁")
case let (age,sex) where age>12 && sex=="man":
    print("男人：\(age)岁")
case let(age,sex):
    print("\(sex):\(age)岁")

}
// 男人：10岁

语句作用域

• 代码块内可以调用代码块外的变量，代码块外不能调用代码块内变量
• 代码块内外存在相同变量名的变量，则根据就近原则，调用代码块内的变量

循环结构

for循环

• 目前for循环已被废弃，采用的是for-in循环

var array = ["你好","欢迎","慢走","不送"]
for value in array {
    print("\(value)")
}

while循环

• 分为do-while循环和while循环
• while循环先判定条件是否符合、do-while循环先执行语句，因此do-while循环无论条件成功与否，都会执行一次。

跳转语句及块标签

• continue语句、break语句用法同Object-C内语法
• fallthrough语句用于switch语句，Swift中的switch-case中默认添加break语句
• 为了实现贯穿的效果，即上一个case语句满足依旧进入下一个case语句，这时就需要在上一个case语句中添加fallthrough语句
• 如果case语句中fallthrough语句位置中部，则后续的代码将不执行，直接跳转到下一个case语句代码块。

块标签

• 可以为循环体定义一个标签，便于利用break跳出特定的循环体

wang:while true{
    wang1:for i in 0...10 {
        print("\(i)")
        if i == 5 {
            break wang // wang、wang1均为循环体标签
        }
    }
    print("---")
}

函数

• 函数的语法

func 函数名(参数名1:参数类型1,参数名2:参数类型2,参数名3:参数类型3) -> 返回值类型{
    函数代码
}
func show (name:String,age:Int) {
    print("\(name):\(age)岁")
}
show(name: "wang", age: 18)
// wang:18岁

• 函数也可以作为参数或者返回值

// 函数的高级使用
// 1.函数作为参数

// 两个数相加
func addTwoNumber(value1:Int,value2:Int)->Int{
    return value1 + value2
}
// 两个数相乘
func mutiplyTwoNumber(value1:Int,value2:Int)->Int{
    return value1 * value2
}
//  函数作为参数
func selectFunc(funcName:(Int,Int)->Int,number1:Int,number2:Int)->Int{
    //调用(Int,Int)->Int类型的形参函数
    return funcName(number1,number2)
}
// 调用selectFunc函数
var returnInt = selectFunc(mutiplyTwoNumber, 10, 20)
print(returnInt)



// 2.函数作为返回值
// 函数无论作为参数传递还是返回值，传递的都是函数的名字，不能加()，即不能写成函数名()，这样是函数的调用

func returnFunc(judge:Bool)->(Int,Int)->Int{
    return judge ? addTwoNumber : mutiplyTwoNumber
}
var houFunc3 = returnFunc(true)
var houFunc3Int = houFunc3(10,20)
print(houFunc3Int)

• 函数体内还可以嵌套函数
  嵌套在函数内部的函数，外界不能直接访问，只能通过最外层的嵌套函数去访问，保证了一些函数的安全性，类似OC中的私有方法。

func embedFunc(_ judge:Bool,number1:Int){
    // 嵌套函数1
    func addNumber(_ value:Int){
        var value = value
        value += 1
        print(value)
    }
    //嵌套函数2
    func jianNumber(_ value:Int){
        var value = value
        value -= 1
        print(value)
    }
    let funcName = judge ? addNumber : jianNumber
    funcName(number1)
}
// 调用嵌套函数
embedFunc(false, number1: 10) // 9

• 函数内交换两个值

// 当形参不指定变量或者常量的时候，形参都会被当做常量来处理,因此，需要将参数声明成变量，即添加var关键字
// 我们想要在函数内部完成地址的交换，首先在函数声明的时候，形参需用inout关键字修饰，在调用函数的时候，实参需要加取地址符
func SwiftTwoNumber( _ number1:inout Int, number2:inout Int){
    let number = number1
    number1 = number2
    number2 = number
}
var number1 = 20;var number2 = 56
SwiftTwoNumber(&number1, number2: &number2)
print("number1 = \(number1),number2 = \(number2)")
// number1 = 56,number2 = 20

• 验证元组(多个返回值)

func returnPersonDetailInfo(_ name:String,age:Int,height:Float)->(String,Int,Float){
    return (name,age,height)
}
var tube1 = returnPersonDetailInfo("xixiix", age: 25, height: 125)
print("\(tube1.0)")
// xixiix
// 验证函数类型   
// 函数的类型跟别的类型（Int类型）可以当成一样来理解，就是长一点而已(包括参数类型和返回值类型)
var checkFunc:(String,Int,Float)->(String,Int,Float) = returnPersonDetailInfo
var tube2 = checkFunc("36553", 14, 1215)
print(tube2.0) // 36553