Swift中元组及函数

/*
元组和数组非常相似 区别在于
1、元组的长度是任意的
2、元组的数据是不同类型的

*/

//元组定义
var userInfo = (“zhangsan”,”fsaf”,12)
读取数组元组中的数据
println(userInfo.0)
//
//let (name,isMale,age) = userInfo
//println(name)

//元组定义方法二
var userInfo2 = (namae:”lisi”,isMale:”woman”,age:20)

println(userInfo2.namae)
//在元组中可以跳过不关心的值

println(userInfo.1)

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

//可选值 Optional 在类型后面加一个？ 代表他是可选的
//可选的意思是它可以为nil 也可以不为nil

var myvar : String?
myvar = “hhhhhhh”
println(myvar)
//可选值拆包，是因为可选值 内部封装枚举类型的 optional（+some）
println(myvar!)//拆包

//if 和 let 组合可以去除optional
if let name = myvar
{
println(name)
}

//取出optional的了两种方式
//问候语 某某 类型名后面必须加？ 打印出某某你好
var namelet : String?
namelet = “小张”
if let names = namelet
{
println(“(names)你好！”)
}

println(“(namelet!)你好！”)

/*函数
- (返回值类型) 方法名 (参数){
函数实现部分
}

在swift中函数的关键之叫做func
func 函数名 (参数) -> 返回值类型{
实现部分
}
*/

func 问候语(name:String,day:String)->String{
return “Hello,(name),today is (day)”
}
//函数调用
println(问候语(“lisa”,”星期三”))

//元组作为元素的返回值

//传入一个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)
}

var 计算结果 = 计算([100,45,98,35,84,64,75])

println(计算结果)

//swift函数中的嵌套函数
func returnFiteen() ->Int{
var ten = 10
func addFive()
{
ten += 5
}
addFive()
return ten
}
println(returnFiteen())

//函数作为返回值 返回函数的参数列表 ->返回函数的返回值
func makeFunc() -> (Int->Int){
func addFive(a:Int)->Int{
return a+5
}
return addFive
}
var func1 = makeFunc()
println(func1(154))

//例子 传入一个+- 返回值返回一个函数，调用函数传入两个值，然后返回计算结果

func makeFun(a:Int,b:Int) ->Int{
func addFiv(let c:Int)->Int{
let c = a + b
return c
}
return addFiv(a+b)
}
var func2 = makeFun(10, 20)
println(func2)
//println(func2(10,12))
// ->(Int->Int)

func 计算(fuhao:String)->((Int,Int)->Int){
switch fuhao{
case “+”:
func sum(num1:Int,num2:Int)->Int{
return num1 + num2
}
return sum
case “-“:
func jian(num1:Int,num2:Int)->Int{
return num1 - num2
}
return jian
case “*”:
func cheng(num1:Int,num2:Int)->Int{
return num1 * num2
}
return cheng
case “/”:
func chu(num1:Int,num2:Int)->Int{
return num1 / num2
}
return chu
default :
func def(num1:Int,num2:Int)->Int{
return 0
}
return def
}
}
var fun3 = 计算(“/”)
println(fun3(78,45))

//函数作为参数
//第一层函数，参数为一个数组，和一个比较的函数，返回值是一个布尔类型
//比较函数要实现 判断第一层函数传入的数组中是否有大于10的数，如果大于10返回yes，如果小于10返回no

func hasAnymatches(number : [Int],condition:(Int)->Bool) ->Bool{
for number1 in number{
if condition(number1){
return true
}
}
return false
}

func moreThanTen (number1:Int)->Bool{
if number1 > 10{
return true
}else{
return false
}
}

//var ten = hasAnymatches([10,54,45,78,3,14,3,6,4], moreThanTen)
println(hasAnymatches([2,54,45,78,3,14,3,6,4], moreThanTen))