IOS Swift 训练

// Playground - noun: a place where people can play

import Cocoa

var str = "Hello, playground"

str+=",Yes I'm Good";

println("hello swift")

var myvar=

myvar=
let myConstant=
var a:Double=

let label="this width is"
let width=
let widthlabel=label+String(width)

"I have \(width) apples."
"I have \(String(width)+String(width)) apples"
var shoppingList=["C","B","D","E"]
shoppingList[]="A"
shoppingList
var dict=["A":"yes","B":"no"]
dict["A"]
dict["C"]="Cancel"
dict
var emptyArray=String[]()
emptyArray.append("A")
emptyArray.append("C")
emptyArray

var emptyDict=Dictionary<String,Float>()
emptyDict.values
emptyDict=["A":,"B":,"C":]

let individualSocres=[,,,,,]
var teamScore=
for score in individualSocres{
    if(score>){
        teamScore+=
    }
    else{
        teamScore+=
    }
}
teamScore
var optional:String?="Hello"
optional=nil
var t="H"
if optional==nil {
    t="hello \(optional)"
}else{
    t="XX"
}

let vegetable="1cecery"
switch vegetable{

//Case 用法
case let x where x.hasSuffix("cery"):
    let v="Is it a spicy \(x)"

    case "cecery":
        let v="add some";
    case "cecery","":
        let v="tttt"
    default:
        let v="tastes good"
}

let interestingNumbers = [
    "Prime": [, , , , , ],
    "Fibonacci": [, , , , , ],
    "Square": [, , , , ],
]
var largest =
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
largest

var n=
while n<{
    n=n*
}

var firstForLoop=
for i in ..{
    firstForLoop+=i
}

//多返回值参数
func greet(name:String,day:String)->(String,Double){
    return ("hello \(name),today is \(day)",99.0)
}

greet("jack","2014-06-09")

//数组参数
func sumOf(numbers:Int...)->Int{
    var sum=;
    for num in numbers{
        sum+=num
    }
    return sum
}

sumOf()
sumOf(,,)

//嵌套函数
func returnFifteen()->Int{
    var y=;
    func add(){
        y+=;
    }
    //调用了才执行
    add()
    return y;
}

returnFifteen();

//函数可以作为另一个函数的返回值
func makIncrementer() -> (Int->Int){
    func addOne(number:Int)->Int{
        return +number;
    }
    return addOne;
}

var increment=makIncrementer();
increment()

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number <
}
var numbers = [, , , ]
hasAnyMatches(numbers, lessThanTen)

//类定义
class Animals{
    var name="";
    //构造函数
    init(name:String){
        self.name=name;
    }
    //方法
    func WhatsName()->String{
        return "my name is \(name)!";
    }
}
//注意构造函数的调用方式
var cat=Animals(name: "dog");
//cat.name="cat";
cat.WhatsName();

//类的继承
class Pig:Animals{
    var age:Int{
        //在设置之前可以执行某段代码，之后执行用didSet
        willSet{
            println("aaaa");
        }
    };

    //Getter And Setter
    var Age:Int{
        get{
            return age;
        }
        set{
            age=newValue;
        }
    }

    init(age:Int){
        self.age=age;
        super.init(name:"Pig");
    }

    func HowOld()->String{
        return "pig is \(age) years old";
    }
    //重写
    override func WhatsName()->String{
        return "pig is a clever animal!";
    }

}

let LittlePig=Pig(age:);
LittlePig.HowOld();
LittlePig.WhatsName();
LittlePig.age;
LittlePig.age=;
LittlePig.Age=;

class Counter {
    var count: Int =
    //方法参数名，可以在为方法体内部使用单独定义一个别名，例如times
    func incrementBy(amount a: Int, numberOfTimes times: Int) {
        count += a * times
    }
}
var counter = Counter()
counter.incrementBy(amount:, numberOfTimes: )

//?之前如果为nil，则之后的会被忽略，否则执行
var os:String;//?="hello jack";
var ai:String?="BBBBB"

//枚举
enum Rank: Int {
    case Ace = ,Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten,Jack, Queen, King
    func simpleDescription() -> String {
        switch self {
        case .Ace:
            return "ace"
        case .Jack:
            return "jack"
        case .Queen:
            return "queen"
        case .King:
            return "king"
        default:
            return String(self.toRaw())
        }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()
ace.simpleDescription();
//struct结构体，值类型，类为引用类型
enum ServerResponse {
    case Result(String, String)
    case Error(String)
}

let success = ServerResponse.Result("36:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")

switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
    let serverResponse = "Failure...  \(error)"
}

//接口和扩展
protocol IUser{
    var simpleDesc:String{get}
    mutating func addJust()
}

class SimpleClass:IUser{
    var simpleDesc:String="Very well";
    func addJust(){
        simpleDesc+=" Now implement";
    }
}

var test=SimpleClass();
test.addJust()
test.simpleDesc;

//接口是可以用来扩展类型的功能的
extension String: IUser {
    var simpleDesc: String {
        return "The number \(self)";
    }
    mutating func addJust() {
        self += "S";
    }
}
"OK".simpleDesc
let tx:IUser = test;
tx.simpleDesc

//范型
func repeat<T>(item: T, times: Int) -> T[] {
    var result = T[]()
    for i in ..times {
        result += item
    }
    return result
}
repeat("knock", )

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
    return false
}

anyCommonElements([, , ], [,])