Swift语法初见

Swift语法初见

http://c.biancheng.net/cpp/html/2424.html

类型的声明：

let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

注：如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割。

数值转换：

let label = "The width is"
let width = 94
let widthLabel = label + String(width)

注：值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。

let apples = 3
let oranges = 5
let appleSummary = "I have (apples) apples."
let fruitSummary = "I have (apples + oranges) pieces of fruit."

注：有一种更简单的把值转换成字符串的方法：把值写到括号中，并且在括号之前写一个反斜杠。

数组、字典的初始化和赋值

var emptyArray = NSMutableArray.init()
var emptyArray1 = NSMutableArray()

emptyArray[0] = "00000";
emptyArray[1] = "11111";
emptyArray.add("22222")
var emptyDictionary = NSMutableDictionary()

emptyDictionary["1"] = 67788
emptyDictionary["2"] = "67788"
emptyDictionary.setValue("sss", forKeyPath: "key")

控制流

let vegetable = "cucumber"
switch vegetable {
case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
    let vegetableComment = "Is it a spicy (x)?"
default:
    let vegetableComment = "Everything tastes good in soup."
}

注：支持任意类型比较;支持多个条件匹配;不需要break，因为只运行一个case; 除非case覆盖所有可能，否则default不可缺失

let interestingNumbers:NSDictionary = ["Prime": [2, 3, 5],"Fibonacci": [1, 1, 8],"Fibonacc": [1, 1, 8]]

for (a,b) in interestingNumbers{
    print(a)
    print(b)
}

输出：Fibonacci [1, 1, 8] Prime [2, 3, 5]
for c in interestingNumbers{
print(c)
}
输出：(key: "Fibonacci", value: [1, 1, 8]) (key: "Prime", value: [2, 3, 5])

注：for in 遍历字典时，两个变量表示 key,value,一个变量表示 key-value键值对

for i in 0...1 {
    interestingNumbers.object(forKey: interestingNumbers.allKeys[i])
}

for i in 0..<2 {
    interestingNumbers.object(forKey: interestingNumbers.allKeys[i])
}

函数和闭包

func greet(nameOut name:String,_ day:String) -> String{
    return "Hello (name), today is (day)."
}

greet(nameOut:"sss","sss")

注：1，区分内部和外部参数名 2，返回值的方式

func greet1(names:Int...) -> (a:Int,b:String,c:String){
    let a = names[0]
    let b = "ss"
    let c = "aaa"
    
    return (a,b,c)
}

greet1(names: 1,2,3)

func makeIncrementer() -> ( (Int) -> Int ) {
    func addOne(number:Int) ->Int {
        return 1+number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

注：1，函数可作为返回值

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 < 10
}
var number = [20, 19, 7, 12]
hasAnyMatches(list:number,condition:lessThanTen)

注：1，函数可作为参数

let numbers = [10,20,30]

numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    
    let aiia = "ssss"
    
    return result
})

let mappedNumbers = numbers.map { number in number/2
}

print (mappedNumbers)


class Shape {
    var name = "aa"
    let numberOfSides = 0
    init(name:String) {
        self.name = name
    }
    func simpleDescription(name:String) -> String {
        return "A shape with (numberOfSides) sides."
    }
    
    func funcInFunc(name:String)->((Int) -> (Int)){
        func addSelf(number:Int)->Int{
            return 1+number
        }
        return addSelf;
    }
}

Shape(name:"bb")
let p = Shape(name:"aa").funcInFunc(name:"sss")
p(20)

注：1，函数可作为返回值

numbers.map({
    (number:Int)->Int in
    
    var aa = number
    let num = number % 2
    if(num == 1){
        aa = 0
    }
    print(aa)
    return aa;
})

class ShapeChild: Shape
{
    override func simpleDescription(name: String) -> String{
        return "A shape with (numberOfSides) sides."
    }
    
    var sideLength: Double = 0.0
    var perimeter:Double{
        get{
            return 3.0 * sideLength
        }
        set{
            sideLength = newValue/3.0
        }
    }
    var per:Int = 0{
        willSet{
           print("newValue : (newValue)")
        }
        didSet{
            print("oldValue : (oldValue)")
        }
    }
}

var triangle = ShapeChild(name:"bb")
triangle.perimeter
triangle.perimeter = 9.9
triangle.sideLength = 4.0
triangle.perimeter
triangle.per = 1
triangle.per = 2

注：1,重写父类方法 用 override关键字 2,属性可以有get set方法，oldValue、newValue是默认参数

枚举与结构体

enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case 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.rawValue)
        }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.rawValue

注：使用enum来创建一个枚举 rawValue为自动去取方法

var optionalSquare: Rank? = Rank.Ace
optionalSquare = nil
optionalSquare = Rank.Five

注：如果?之前的值是nil，?后面的东西都会被忽略，并且整个表达式返回nil

enum ServerResponse {
    case Result(String, String)
    case Error(String)
}
let success = ServerResponse.Result("6: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 printSelf{
    var selfStr:String{get}
    mutating func printSelf()
}

class desk:printSelf{
    var selfStr: String = "a desk"
    
    func printSelf() {
        print(selfStr)
    }
}

struct phone:printSelf{
    var selfStr: String = "a phone"
    func printSelf() {
        print(selfStr)
    }
}

desk()
phone()

注：类、枚举和结构体都可以实现接口。其中类是引用类型，枚举和结构体是值类型
在值类型的实例方法中，也可以直接修改self属性值。 mutating关键字用来标记一个会修改结构体或枚举属性值的方法

泛型

func repeatFunc<T>(item: T, times: Int) -> [T] {
    var result = [T]()
    for _ in 0...times {
        result.append(item)
    }
    return result
}
repeatFunc(item:"knock",times:4)