swift-2

swift-2

//元组

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

//元组的长度是任意的

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

//元组的定义

var userInfo2 = (“zhangsan”, “man”, 20)

//读取元组中的数据

//print(userInfo2.2)

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

//在这里 name == “zhangsan”

//print(name)

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

var userInfo3 = (name:”list”, isMale:”woman”, age:22)

println(userInfo3.name)

//在元组中 我们可以跳过我们不关心的值 用下划线带过，这样我们就访问不到userInfo2.1 这个数据

let (name, _ , age) = userInfo2

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

//1、可变元组

var list = (“香瓜”, “西瓜”, “黄瓜”)

list.1 = “小瓜”

println(list)

//2、不可变元组

let list1 = (“香瓜”, “西瓜”, “黄瓜”)

//list1.1 = “1”

println(list1)

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

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

var myVar: String? = nil

myVar = “775”

println(myVar)

var myVar1 : String

//println(myVar1)

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

println(myVar!)

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

if let name = myVar

{

print(name)

}

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

var hello : String? = “小明你好”

println(hello!)

if let mm = hello{

println(mm)

}

//var optionalName:String? = “Susan”

//var greeting:String = “hello”

//函数

//OC

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

//函数的实现部分

//}

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

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

//实现部分

//}

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

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

}

//函数调用

print(问候语(“Lisa”,”星期三”))

//元组作为函数返回值

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

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

var max = 数组[0]var min = 数组[0]var sum = 0for item in 数组{    if max < item{        max = item    }    if min > item{        min = item    }    sum += item}return (max, min, sum)

}

//调用这个函数

let 计算结果 = 计算([10, 20, 23, 45, 68, 99])

print(计算结果)

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

func returnFifteen()->Int{

var ten = 10func addFive(){    ten += 5}addFive()addFive()addFive()addFive()return ten

}

print(returnFifteen())

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

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

func addTwo(a:Int)->Int{    return a+5}return addTwo

}

var func1 = makeFunc()

//print(func1(12))

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

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

func add(a:Int, b:Int)->Int{    switch fuHao{    case "+":     return a + b    case "-":        return a - b    case "*":        return a * b    case "/":        return a / b    default:        return 0    }}

return add

}

var func2 = makeComputerFunc(“*”)

print(func2(12, 5))

//函数作为参数的情况

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

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

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 > 10{    return true}else{    return false}

}

print(hasAnyMatches([2, 4, 4, 6, 8], moreThanTen))