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)
print(userInfo2.name)
//在元祖中，我们可以跳过我们不关心的值，用下划线带过。这样我们就访问不到userInfo1.1这个数据
let(name,_,age) = userInfo1;
//元祖中可变元祖和不可变元祖

var user1 = ("xiaohua","man","35")
print(user1.1)
user1.0 = "xiaozhang";
print("\(user1)")

let(name,isMale,age) = ("xiaohua1","man","35")
print(name)

//可选值Optional，在类型后面加个？ 代表他是可选的。可选的意思是他可以为nil  也可以不为nil
var myVar : NSString? = nil
myVar = "小美"
print(myVar)

var myVar1 : String
print(myVar!)


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


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

if let name = myVar
{
    print(name)
}


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

var name : NSString? = nil
name = "阿呆"
var sayHi : NSString? = nil
sayHi = "hello"
sayHi = ("hello\(name!)")
print(sayHi)


//函数
//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 = 0
    for items in 数组{
        if max < items{
            max = items
        }
        if min > items{
            min = items
        }
        sum += items
    }
    return (max,min,sum)
}

//调用这个函数
let 运行结果 = 计算([12,23,32,52,61,5,3])
print("max = \(运行结果.max),min = \(运行结果.min),sum = \(运行结果.sum)")


//swift 函数可以嵌套函数
func returnFifteen()->Int{
    var ten = 10
    func addFive(){
        ten += 5
    }
    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))


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 product(num1:Int,num2:Int)->Int{
                return num1*num2
            }
        return product
    case"/":
        func division(num1:Int,num2:Int)->Int{
            return num1/num2
        }
        return division
    default:
        func oth(num1:Int,num2:Int)->Int{
            return 0
        }
        return oth
    }
}

var func2 = makeComputerFunc("-")
println(func2(12,6))

*/
//函数作为参数的情况
//第一层函数，参数为一个数组。和一个比较的函数。返回值是一个Bool类型
//比较函数，判断第一层函数传人的数组中是否有大于10的数，如果大于10 返回ture ，如果小于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 > 10{
        return true
    }else{
        return false
    }
}

println(hasAnyMatches([1,21,11,23,32],moreThanTen))

 

转载于:https://www.cnblogs.com/liYongJun0526/p/4874182.html