巩固—Swift 5.0 基础知识(二)

函数

定义：函数是执行特定任务的自包含代码块。（Swift中每个函数都有一个类型，由函数的参数类型和返回类型组成）。
使用：

• 函数可以返回元组（也可以是可选元组：整个元组是可选的，而不仅仅是元组中的每个单独的值）

    func minMax(array: [Int]) -> (min: Int, max: Int)? {
        if array.isEmpty { return nil }
        var currentMin = array[0]
        var currentMax = array[0]
        for value in array[1..<array.count] {
            if value < currentMin {
                currentMin = value
            } else if value > currentMax {
                currentMax = value
            }
        }
        return (currentMin, currentMax)
    }
  

• 使用外部参数和内部参数，外部参数可以用“_”省略

    func greet(Person person: String, _ hometown: String) -> String {
        return "Hello \(person)!  Glad you could visit from \(hometown)."
    }
    print(greet(Person: "Bill", "Cupertino"))
    // Prints "Hello Bill!  Glad you could visit from Cupertino."
  

• 使用默认参数值，调用该函数时可以省略该参数

     func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
        // If you omit the second argument when calling this function, then
        // the value of parameterWithDefault is 12 inside the function body.
    }
    someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault is 6
    someFunction(parameterWithoutDefault: 4) // parameterWithDefault is 12
  

• 使用变量参数，则此参数可以接受0-N的参数值，函数内部，此参数当做函数处理，关键字"..."（注：函数最多有一个可变参数）

    func arithmeticMean(_ numbers: Double...) -> Double {
        var total: Double = 0
        for number in numbers {
            total += number
        }
        return total / Double(numbers.count)
    }
    arithmeticMean(1, 2, 3, 4, 5)
    // returns 3.0, which is the arithmetic mean of these five numbers
    arithmeticMean(3, 8.25, 18.75)
    // returns 10.0, which is the arithmetic mean of these three numbers

• in-Out参数，函数参数类型默认是let类型，不可更改，若需要更改参数，则在参数类型前加上关键字inout。（注意：in-Out参数不能具有默认值，并且可变参数不能标记为inout）

    func swapTwoInts(_ a: inout Int, _ b: inout Int) {
        (a,b) = (b,a) //交换两个值
    }
    //调用方式如下：
    var someInt = 3
    var anotherInt = 107
    swapTwoInts(&someInt, &anotherInt)
    print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
    // Prints "someInt is now 107, and anotherInt is now 3"
  

• 函数类型：函数参数类型和返回值类型的组合

    该函数的类型是(Int, Int) -> Int，并返回Int。
    func addTwoInts(_ a: Int, _ b: Int) -> Int {
        return a + b
    }
    
    该函数的类型是() -> Void或“没有参数的函数，并返回” Void。
    func printHelloWorld() {
        print("hello, world")
    }
  

• 函数类型可用作：函数参数类型，返回值类型等

• 函数嵌套：可以在函数内部定义其他函数

    //不推荐：一般一个函数就完成一个功能模块
    func chooseStepFunction(backward: Bool) -> (Int) -> Int {
        func stepForward(input: Int) -> Int { return input + 1 }
        func stepBackward(input: Int) -> Int { return input - 1 }
        return backward ? stepBackward : stepForward
    }
  

闭包

• 表达式一般形式

    {（参数） -> 返回类型 in
        声明
    }
  

• 几种闭包的使用方式举例：

    //完整格式：
    reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
        return s1 > s2
    })
    //省略参数类型：因为swift具有上下文自动推断数据格式
    reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )
    //闭包中只有一条语句时，称为隐式返回，即省略return
    reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )
    //最简格式：使用参数值$0，$1，$2依次代替参数值
    reversedNames = names.sorted(by: { $0 > $1 } )
    //追尾闭包：既闭包类型作为函数参数的最后一个参数
    func someFunctionThatTakesAClosure(closure: () -> Void) {
        // function body goes here
    }
    调用时可以写成如下格式：
    someFunctionThatTakesAClosure(closure: {
        // closure's body goes here
    })
  

  • 逃逸闭包：逃逸闭包恰恰与非逃逸闭包相反，其生命周期长于相关函数，当函数退出的时候，逃逸闭包的引用仍然被其他对象持有，不会在相关函数结束后释放。

  • 非逃逸闭包（默认）：1. 把闭包作为参数传递给函数。2. 函数中运行该闭包。3. 退出函数。

      class SomeClass {
          var x = 10
          func doSomething() {
              someFunctionWithEscapingClosure { self.x = 100 } //逃逸闭包（不能直接写x）
              someFunctionWithNonescapingClosure { x = 200 } //非逃逸闭包(可以直接引用)
          }
      }
    

  • 自动闭包（@autoclosure）：是一种自动创建的用来把作为实际参数传递给函数的表达式打包的闭包。

    • 要求：它不接受任何实际参数
    • 表现：它被调用时，它会返回内部打包的表达式的值
    • 好处：在于通过写普通表达式代替显式闭包而使你省略包围函数形式参数的括号

    func testB()  {
       let neStr =  self.testbBlock1(block: "2sssssss")
     
       self.testBlock2(block: (print("ffjfjfjjf")))
     
       print(neStr)
    }
    
    func testbBlock1(block: @autoclosure ()->String) -> String {
       return block()
    }
    
    func testBlock2(block:@autoclosure ()->()) {
       block()
    }
    
    

枚举

• 枚举语法

    enum 枚举名 {
        case 枚举值1
        case 枚举值2
        ....
    }
    //注意: 1. 枚举名应遵循首字母大写的驼峰式复数命名
            2. 每个枚举值没有默认的0，1，2...等值
    //可以携带参数
    enum Barcode {
        case upc(Int, Int)
        case qrCode(String)
    }
    var productBarcode = Barcode.qrCode("ABCED")
    switch productBarcode {
        //如果所有关联值被提取为常量或变量，则可以将var或let注释放在枚举值前面，如下：
        case let .upc(number1,number2) :
        print("\(number1)")
        case.qr(let code):
        print("\(code)")
    }
    //Prints:ABCED
  

• 原始值：可以是字符串、字符、任意的整数或浮点数类型，但是原始值是唯一的。

    enum Plant: Int {
        case mercury = 1,venus,earth
    }
    print("\(Plant.earth.rawValue)") == 3
  

• 初始化值：如果你使用原始值定义枚举，则枚举将自动接收一个初始化器。

    //possiblePlanet 为 venus
    let possiblePlanet = Planet(rawValue: 2)
  

• 递归枚举：简单理解为自己调用自己，而递归枚举并不是函数，它并不执行某项运算，他只是表达一个数据或者一种表达式。（关键字：indirect：表示可以递归），整个enum都可以递归就在enum前加上关键字：indirect

    enum ArithmeticExpression {
        case number(Int)
        //indirect：为递归枚举的关键字
        indirect case addition(ArithmeticExpression, ArithmeticExpression)
        indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
    }
    
    let five = ArithmeticExpression.number(5)
    let four = ArithmeticExpression.number(4)
    let sum = ArithmeticExpression.addition(five, four) //并没有真正执行运算
    let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))
    
    实现递归枚举的最好方式就是用递归函数：
    func evaluate(_ expression: ArithmeticExpression) -> Int {
        switch expression {
        case let .number(value):
            return value
        case let .addition(left, right):
            return evaluate(left) + evaluate(right)
        case let .multiplication(left, right):
            return evaluate(left) * evaluate(right)
        }
    }
     
    print(evaluate(product))
    // Prints "18"
  

类和结构体

• 相同点：
  • 定义属性以存储值
  • 定义提供功能的方法
  • 定义下标语法提供对其值得访问
  • 定义初始化器以设置其默认实现
  • 扩展其功能
  • 遵守协议以提供某种特定的标准功能
• 不同点：
  • 类可以被继承
  • 类型转换使您能够在运行时检查和解释类实例的类型。
  • 取消初始化使类的实例可以释放其分配的任何资源。
  • 引用计数允许多个对类实例的引用。
• 判断是否是同类：（===）（!==）比较两个类对象是否相等
• 当结构体对象为let类型时，不管属性是var或let都不能修改属性的值，类则不同。能否修改由属性的类型决定

属性

• 存储属性：是存储在特定类或结构体实例里的一个常量或变量，只能用于类和结构体

    var firstValue: Int
    let secondValue: Int
  

• 计算属性：不直接存储值，而是提供一个getter和一个可选的setter方法，来间接和设置其他属性或变量的值，可以用于类、结构体和枚举

    struct AlternativeRect {
        var origin = Point()
        var size = Size()
        var center: Point { //计算属性
            get { //只读属性时可以不写get，直接返回
                let centerX = origin.x + (size.width / 2)
                let centerY = origin.y + (size.height / 2)
                return Point(x: centerX, y: centerY)
            }
            set { //没有set则为只读计算属性
                origin.x = newValue.x - (size.width / 2)
                origin.y = newValue.y - (size.height / 2)
            }
        }
    }
  

• lazy属性：指的是第一次被调用的时候才会计算其初始值的属性。

  • 注意:lazy属性必须声明为变量var，因为属性的初始值可能在实例构造完成之后才会得到，而常量属性在构造过程之前必须要有初始值。

  • 注意：如果一个被标记为lazy的属性在没有初始值时就同时被多个线程访问，则无法保证该属性只会被初始化一次。

  • 格式

      lazy var 属性名:属性类型 = {调用一个没有参数，返回值是当前属性类型的闭包。
                                闭包中需要创建一个当前属性的变量返回}()
    

• 类型属性：无论创建多少个该类型的实例，这些属性都是唯一共享的一份。（static关键字）

  • 注意：1. 必须给存储类型属性指定默认值，因为类型本身没有构造器。
  • 2. 存储型类型属性时演示初始化的，它们只有在第一次被访问的时候才会被初始化。即不需要lazy关键字修饰。
  • 3. 在类中可以使用class替代static来支持子类对父类的实现进行重写。

  • 4. 类型属性是通过类型本身来访问，而不是通过实例。

          class SomeClass {
              static var storedTypeProperty = "Some value."
              static var computedTypeProperty: Int {
                  return 27
              }
              class var overrideableComputedTypeProperty: Int {
                  return 107
              }
          }
       

• 属性观察器：

  • willSet -- 在值被存储之前被调用，可以再此名称后加(变量名),默认参数是newValue,此值就代表将要赋的值。
  • didSet -- 在存储值之前被调用，可以再此名称后加(变量名),默认参数是oldValue,此值就代表原始值。

方法

• 方法：实现一定功能的函数。类、结构体和枚举中都能定义方法。

• 注意：结构体和枚举是值类型。默认情况下，不能从实例方法中修改值类型的属性，若想要修改其属性值，必须在方法func前添加mutating关键字。

    struct Point {
        var x = 0.0, y = 0.0
        mutating func moveBy(x deltaX: Double, y deltaY: Double) {
            x += deltaX
            y += deltaY
        }
    }
    等同于下面：
    struct Point {
        var x = 0.0, y = 0.0
        mutating func moveBy(x deltaX: Double, y deltaY: Double) {
            self = Point(x: x + deltaX, y: y + deltaY)
        }
    }
    //突变的方法
    enum TriStateSwitch {
        case off, low, high
        mutating func next() {
            switch self {
            case .off:
                self = .low
            case .low:
                self = .high
            case .high:
                self = .off
            }
        }
    }
  

• 类型方法和属性方法

  • 类型属性需要通过类型名来获取，通过变量或对象去获取的话是找不到该属性的
  • 类型属性必须有初值，同时不能直接再构造函数中初始化，需要通过结构体名或类名去调用赋值
  • 类型方法——
    1. 在类中可以使用class关键字代替static
    2. 类型方法中不可以使用变量型属性
    3. 类型方法中不可以调用变量型方法
    4. 变量型方法和类型方法可以同名
  • 总结：变量和类型之间都不能互相调用