巩固—Swift 4.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.. 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 } //非逃逸闭包(可以直接引用)
      }
  }

枚举

枚举语法

  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. 必须给存储类型属性指定默认值，因为类型本身没有构造器。
- 1. 存储型类型属性时演示初始化的，它们只有在第一次被访问的时候才会被初始化。即不需要lazy关键字修饰。
- 1. 在类中可以使用class替代static来支持子类对父类的实现进行重写。
- 1. 类型属性是通过类型本身来访问，而不是通过实例。
```
   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. 变量型方法和类型方法可以同名
- 总结：变量和类型之间都不能互相调用

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

函数

闭包

枚举

类和结构体

属性

方法

你可能感兴趣的:(巩固—Swift 4.0 基础知识(二))