iOS swift-2 (元组)

//元组

//和数组非常相似，区别在于什么？ 

//元组的长度是任意的、

//元组中的数据可以是不同类型的。

//元组的定义

var userInfo1 = ("zhangsan" , "man ",22)

//读取元组中的数据

print(userInfo1.1)

//let (name, isMale ,age) = userInfo1

//在这里   name ==  " zhangsan"

//print(name)

//元组定义的第二种方法

var userInfo2 = (name:"lisi" ,isMale:"woman",age:22)

userInfo2.name = "WANGWU"

print(userInfo2.name)

// 在元组中，我们可以跳过我们不关心的值,用下滑线带过。这样我们

//就访问不到 isMale  “man”这个数据

let (name , _ ,age) = userInfo1

// 元组中可变元组和不可变元组  

//一个用 let修饰   一个用 var 修饰

//  可选值 Optional,在类型后面加个？ 代表他是可选的 。

//  可选的意思是他可以为nil  也可以不为nil

var  myVar : String?

myVar = "小美"

//myVar = nil

print(myVar)//Optional（"小美")

var myVar1 :String

//print(myVar1)

//可选值的拆包,是因为可选值内部封装枚举类型的 。Optional (+some )

//print(myVar!)

// if和 let 组合可以去除Optional

if let name = myVar

{

    print(name)

}

//问候语   某某  类型后面必须要加？  打印出 某某你好

var optionalName : String?

var greeting :String = "hello"

optionalName = " susan "

greeting = ("hello \(optionalName!)")

print(greeting)

if let name1 = optionalName{

    greeting = ("hello \(name1)")

}

print(greeting)

//函数

//OC

//-（返回值类型）方法名 （参数）{

//函数的实现部分

//}

//swift  中函数的关键字 叫做 func

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

//实现部分}

//函数的声明与实现部分 ,

func问候语(name:String,day:String)->String{

    return "hello ,\(name) ,today is \(day)"

}

//函数调用

print(问候语("Lisa", day: "星期三"))

// 元组作为函数返回值  

//传入一个Int 型的数组，返回最大值，最小值，和、

func计算(var 数组:[Int])->(max:Int ,min:Int ,sum :Int){

    var max =数组[0]

    var min =数组[0]

    var sum = 0

    for item in数组{

        if max < item{

            max = item

        }

        if min > item{

            min = item

        }

        sum += item

    }

    return (max,min,sum)

 }

//调用这个函数

let计算结果 = 计算([10,22,54,23,13,67])

print(计算结果)

print("max = \(计算结果.max),min = \(计算结果.min) ,sum = \(计算结果.sum)")

// swift函数中可以嵌套函数

func returnFifteen() ->Int{

    var ten = 10

    func addFive(){

        ten += 5

    }

    addFive()

    addFive()

    addFive()

    return ten

}

print(returnFifteen())

//函数作为返回值的情况 返回函数的参数列表 ->返回函数的返回值

func makeFunc()->(Int->Int){

    func addFive(a:Int)->Int{

        return a+5

    }

    return addFive

}

var func1 = makeFunc()

print(func1(12))

//实现makeComputerFunc这个函数，传入一个 +-*/ 。返回值返回一个函数，调用函数传入两个值，然后返回计算结果

//返回函数的参数列表 ->返回函数的返回值

func makeComputerFunc(operation:String)->((Int,Int) -> Int){

    switch operation{

    case "+":

        func add(num1:Int,num2 :Int)->Int{

            return num1 + num2

        }

        return add

   

    case "-":

    func sub(num1:Int,num2 :Int)->Int{

        return num1 - num2

    }

    return sub

    case "*":

    func multi(num1:Int,num2 :Int)->Int{

        return num1 * num2

    }

    return multi

    case "/":

    func div(num1:Int,num2 :Int)->Int{

        return num1 / num2

    }

    return div

    default:

    func none(num1:Int,num2 :Int)->Int{

        return 0

    }

    return none

    }

}

//在这里func3   ===  sub 这个函数

var func3=makeComputerFunc("+")

print(func3(20,12))

//  函数作为参数的情况。

//第一层函数，参数为一个数组。和一个比较的函数。返回值是一个bool类型。

//比较函数  ，判断第一层函数传入的数组中是否有大于10的数，如果大于10 返回true ，如果小于10  返回false

func hasAnyMatches(numbers :[Int],condition :(Int)->Bool) ->Bool{

    for num in numbers{

        if condition(num){

            return true

        }

    }

    return false

}

func moreThanTen (num:Int) -> Bool{

    if num < 1{

        return true

    }else{

        return false

    }

}

print(hasAnyMatches([2,11,10,10,5,5,3], condition: moreThanTen))