Swift语法入门



  • Swift Version: v4.0.3 (Xcode 9.2 Default)

    • 导入 package
    import Foundation
    
    • 变量和常量
    var str1 = "Hello, playground"
    let str2 = "test"
    
    • 数组
    var myArray = [
        "t1",
        "t2",
        "t3"
    ]
    
    • 集合
    let ttt: Set = [0, 1, 2, 3, 6, 9, 90, 2]
    
    • 字典
    var myDict = [
        "k1": "v1",
        "k2": "v2",
        "k3": "v3"
    ]
    
    • 方法
    func test(_ value: Int) -> Bool {
        if value > 10 {
            return true
        }
    
        // 编译错误,Swift强制if语句加{}
        //    if value > 10
        //        return true
    
        return false
    }
    
    • 多重返回值函数
    func test1(_ value: Int) -> (errorCode: Int, errorDes: String) {
        if value > 10 {
            return (200, "Success")
        }
    
        return (404, "Not Found")
    }
    
    let r = test(100)
    let r1 = test1(90)
    print("result1 = (\(r1.0), \(r1.1))")
    print("result1 = (\(r1.errorCode), \(r1.errorDes))")
    
    • 区间运算符
    // 闭区间运算符(a...b)定义一个包含从a到b(包括a和b)的所有值的区间,b必须大于a。
    for index in 1...5 {
        print("index = \(index)")
    }
    
    // 半开区间运算符
    for index in 1..<5 {
        print("index = \(index)")
    }
    
    • 闭包
    let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
    
    func backwards(s1: String, s2: String) -> Bool {
        return s1 > s2
    }
    
    func closureTest(_ param1: Int, param2: (_ s1: String, _ s2: String) -> Bool) {
        print("param1 = \(param1), param2 = \(param2("d", "b"))")
    }
    
    closureTest(1, param2: backwards)
    closureTest(2, param2: {
        (s1: String, s2: String) -> Bool in
        
        return s1 < s2
    })
    closureTest(3, param2: {
        (s1, s2) in // 类型可自动推倒出来
        
        return s1 < s2
    })
    closureTest(4, param2: {(s1, s2) in return s1 < s2})
    closureTest(5, param2: {$0 > $1})
    // 运算符函数
    closureTest(6, param2: >)
    
    • 尾随闭包
    func trailingClosuresTest(_ param: () -> ()) {
        print("trailingClosuresTest 1")
    
        param()
    
        print("trailingClosuresTest 2")
    }
    
    // 以下是不使用尾随闭包进行函数调用
    trailingClosuresTest({
        () -> () in
        
        print("trailingClosuresTest 3")
    })
    trailingClosuresTest({
        print("trailingClosuresTest 4")
    })
    
    // 以下是使用尾随闭包进行函数调用
    trailingClosuresTest() {
        print("trailingClosuresTest 5")
    }
    
    // 如果函数只需要闭包表达式一个参数,当使用尾随闭包时,甚至可以把()省略掉。
    trailingClosuresTest {
        print("trailingClosuresTest 6")
    }
    
    • 捕获值
    func makeIncrementor(forIncrement amount: Int) -> () -> Int {
        var runningTotal = 1
        func incrementor() -> Int {
            runningTotal += amount
            return runningTotal
        }
        return incrementor
    }
    
    let capture1 = makeIncrementor(forIncrement: 9)
    print(capture1())
    print(capture1())
    

    print 输出如下:

    10
    19

    • 枚举
    enum Barcode {
        case UPCA(Int, Int, Int)
        case QRCode(String)
    }
    
    func enumTest(value: Barcode) {
        switch(value) {
        case Barcode.UPCA(let numberSystem, let identifier, let check):
            print("UPCA numberSystem = \(numberSystem), identifier = \(identifier), check = \(check)")
        case Barcode.QRCode(let productCode):
            print("QRCode productCode = \(productCode)")
        }
    }
    
    enumTest(Barcode.QRCode("qs"))
    enumTest(Barcode.UPCA(1, 2, 3))
    
    enum Planet: Int {
        case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
    }
    
    enum StrEnum: String {
        case T1 = "a"
        case T2 = "b"
    }
    
    • 计算属性
    struct Point {
        var x = 0.0
        var y = 0.0
    }
    struct Size {
        var width = 0.0
        var height = 0.0
    }
    struct Rect {
        var origin = Point()
        var size = Size()
        var center: Point {
            get {
                let centerX = origin.x + (size.width / 2.0)
                let centerY = origin.y + (size.height / 2.0)
                
                return Point(x: centerX, y: centerY)
            }
            
            set {
                origin.x = newValue.x - (size.width / 2.0)
                origin.y = newValue.y - (size.height / 2.0)
            }
        }
    }
    
    var square = Rect(origin: Point(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
    print("square.center = \(square.center)")
    square.center = Point(x: 15.0, y: 15.0)
    print("square origin = \(square.origin)")
    

    print 输出如下:

    square.center = Point(x: 5.0, y: 5.0)
    square origin = Point(x: 10.0, y: 10.0)

    • 属性观察器
    class StepCounter {
        var totalSteps: Int = 0 {
            
            willSet(newTotalSteps) {
                print("1 totalSteps = \(totalSteps)")
            }
            didSet {
                
                if(totalSteps > oldValue) {
                    print("2 totalSteps = \(totalSteps)")
                }
            }
        }
    }
    
    let stepCounter = StepCounter()
    stepCounter.totalSteps = 100
    

    print 输出如下:

    1 totalSteps = 0
    2 totalSteps = 100

    • 结构体
    struct PointTest {
        var x = 0.0
        var y = 0.0
        mutating func moveBy(deltaX: Double, deltaY: Double) {
            x += deltaX
            y += deltaY
        }
    }
    

    使用 mutating 关键字是为了能在该方法中修改 struct 的变量。

    • 构造、析构、! 、?
    class Player {
        init() {
            print("Player init")
        }
        
        deinit {
            print("Player deinit")
        }
        
        func test() {
            
        }
    }
    
    var player: Player? = Player()    // 调用构造方法
    
    if(nil != player) {
        player!.test()
    }
    // 等价于上面这种情况
    player?.test()
    
    player = nil    // 调用析构方法
    
    • 继承 - 单继承,多实现
    class A {
        
    }
    
    class B: A {
        
    }
    
    protocol IA {
        
    }
    
    protocol IB {
        
    }
    
    protocol IC {
        
    }
    
    class C: A, IA, IB, IC {
        
    }
    
    • extension
    extension Double {
        var km: Double { return self * 1_000.0 }
        var m : Double { return self }
        var cm: Double { return self / 100.0 }
        var mm: Double { return self / 1_000.0 }
        var ft: Double { return self / 3.28084 }
    }
    
    let t = 45.7.km
    print(t)
    

    print 输出如下:

    45700.0


Log in to reply