• Swift基础

    本文是个比较简单的学习笔记，更详细的内容见 Swift官方文档

    1、相等性比较

    Swift标准库用 < 和 == 运算符定义了 >、>=、<=，所以实现 Comparable 的 < 运算符就会自动得到这些运算符的实现，实际上 Comparable 继承自 Equatable，所以 == 运算也是必须实现的，以下是示例代码

    1. struct Point: Comparable, CustomStringConvertible {
    2.     let x: Int
    3.     let y: Int
    4.     
    5.     var description: String {
    6.         return "Point(\(x), \(y))"
    7.     }
    8.     
    9.     
    10.     static func ==(lhs: Point, rhs: Point) -> Bool {
    11.         return lhs.x == rhs.x && lhs.y == rhs.y
    12.     }
    13.     
    14.     static func <(lhs: Point, rhs: Point) -> Bool {
    15.         return lhs.x < rhs.x && lhs.y < rhs.y
    16.     }
    17.     
    18.     static func + (left: Point, right: Point) -> Point {
    19.         return Point(x: left.x + right.x, y: left.y + right.y)
    20.     }
    21. }
    22.  
    23. let a = Point(x: 3, y: 4)
    24. let b = Point(x: 3, y: 4)
    25. let abEqual = (a == b)
    26. a != b
    27.  
    28. let c = Point(x: 2, y: 6)
    29. let d = Point(x: 3, y: 7)
    30. c == d
    31. c < d
    32. c <= d
    33. c > d
    34. c >= d
    35.  
    36. c + d
    37.  
    38.  
    39. class Person: Equatable {
    40.     let name: String
    41.     let age: Int
    42.     weak var brother: Person?
    43.     
    44.     init(name: String, age: Int) {
    45.         self.name = name
    46.         self.age = age
    47.     }
    48.     
    49.     static func ==(lhs: Person, rhs: Person) -> Bool {
    50.         return lhs.name == rhs.name
    51.     }
    52. }
    53.  
    54. let p1 = Person(name: "JJF", age: 33)
    55. let p2 = Person(name: "JZF", age: 36)
    56. var people = [p1, p2]
    57. if let p1Index = people.firstIndex(where: { $0 == p2 }) {
    58.     print(p1Index)
    59. }
    60.  
    61. //自定义运算符
    62. infix operator +++
    63.  
    64. func +++(lhs: Person, rhs: Person) {
    65.     lhs.brother = rhs
    66.     rhs.brother = lhs
    67. }
    68. p1 +++ p2
    69. p1.brother?.name
    70. p2.brother?.name

    2、日期和时间

    1. import Foundation
    2.  
    3. let date = Date.now
    4.  
    5. let dateFormatter = DateFormatter()
    6. //dateFormatter.locale = Locale(identifier: "zh_CN")
    7. dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss.SSS"
    8.  
    9. // typealias TimeInterval = Double
    10. // A number of seconds.
    11. // TimeInterval 是 Double 类型，单位是秒，可精确到微秒
    12. //时间戳，1970到现在的毫秒数
    13. let timestamp = Int(date.timeIntervalSince1970 * 1000)
    14. print("timestamp = \(timestamp)")
    15.  
    16. //取当前时间的年/月/日/时/分/秒/毫秒
    17. var calendar = Calendar.current
    18. let year = calendar.component(.year, from: date)
    19. let month = calendar.component(.month, from: date)
    20. let day = calendar.component(.day, from: date)
    21. let hour = calendar.component(.hour, from: date)
    22. let minute = calendar.component(.minute, from: date)
    23. let second = calendar.component(.second, from: date)
    24. let milliSecond = calendar.component(.nanosecond, from: date) / 1000_000
    25. print("\(year)-\(String(format: "%02D", month))-\(String(format: "%02D", day)) \(String(format: "%02D", hour)):\(String(format: "%02D", minute)):\(String(format: "%02D", second)).\(String(format: "%03D", milliSecond))")
    26.  
    27. //使用 DateFormatter 格式化时间
    28. print("\(dateFormatter.string(from: date))")
    29.  
    30.  
    31. let str = "Hello World!"
    32. let start = str.index(str.startIndex, offsetBy: 6)
    33. let end = str.index(str.startIndex, offsetBy: 11)
    34. let substr = String(str[start..<end])
    35. print(substr)

    3、处理异常 

    1. enum Token {
    2.     case number(Int)
    3.     case plus
    4. }
    5.  
    6. class Lexer {
    7.     enum Error: Swift.Error {
    8.         case invalidCharacter(Character)
    9.     }
    10.     let input: String
    11.     var position: String.Index
    12.     
    13.     init(input: String) {
    14.         self.input = input
    15.         self.position = self.input.startIndex
    16.     }
    17.     
    18.     func peek() -> Character? {
    19.         guard position < input.endIndex else {
    20.             return nil
    21.         }
    22.         return input[position]
    23.     }
    24.     
    25.     func advance() {
    26.         //断言只在调试模式下生效，发布模式下可使用 precondition(_:_:) 替代
    27.         assert(position < input.endIndex, "Cannot advance past endIndex!")
    28.         position = input.index(after: position)
    29.     }
    30.     
    31.     func lex() throws -> [Token] {
    32.         var tokens = [Token]()
    33.         while let nextCharacter = peek() {
    34.             switch nextCharacter {
    35.             case "0"..."9":
    36.                 tokens.append(.number(getNumber()))
    37.             case "+":
    38.                 tokens.append(.plus)
    39.                 advance()
    40.             case " ":
    41.                 advance()
    42.             default:
    43.                 throw Lexer.Error.invalidCharacter(nextCharacter)
    44.             }
    45.         }
    46.         return tokens
    47.     }
    48.     
    49.     func getNumber() -> Int {
    50.         var value = 0
    51.         
    52.         while let nextCharacter = peek() {
    53.             switch nextCharacter {
    54.             case "0"..."9":
    55.                 let digitValue = Int(String(nextCharacter))!
    56.                 value = 10 * value + digitValue
    57.                 advance()
    58.             default:
    59.                 return value
    60.             }
    61.         }
    62.         return value
    63.     }
    64. }
    65.  
    66.  
    67. class Parser {
    68.     enum Error: Swift.Error {
    69.         case unexpectedEndOfInput
    70.         case invalidToken(Token)
    71.     }
    72.     let tokens: [Token]
    73.     var position = 0
    74.     
    75.     init(tokens: [Token]) {
    76.         self.tokens = tokens
    77.     }
    78.     
    79.     func nextToken() -> Token? {
    80.         guard position < tokens.count else {
    81.             return nil
    82.         }
    83.         let token = tokens[position]
    84.         position += 1
    85.         return token
    86.     }
    87.     
    88.     func getNumber() throws -> Int {
    89.         guard let token = nextToken() else {
    90.             throw Parser.Error.unexpectedEndOfInput
    91.         }
    92.         switch token {
    93.         case .number(let value):
    94.             return value
    95.         case .plus:
    96.             throw Parser.Error.invalidToken(token)
    97.         }
    98.     }
    99.     
    100.     func parse() throws -> Int {
    101.         var value = try getNumber()
    102.         
    103.         while let token = nextToken() {
    104.             switch token {
    105.             case .plus:
    106.                 let nextNumber = try getNumber()
    107.                 value += nextNumber
    108.             case .number:
    109.                 throw Parser.Error.invalidToken(token)
    110.             }
    111.         }
    112.         return value
    113.     }
    114. }
    115.  
    116. func evaluate(_ input: String) {
    117.     print("Evaluating: \(input)")
    118.     let lexer = Lexer(input: input)
    119. //    let tokens = try! lexer.lex()//强制执行可能抛出错误的方法，发生错误时触发陷阱
    120. //    guard let tokens = try? lexer.lex() else {
    121. //        print("Lexing failed, but I don't know why")
    122. //        return
    123. //    }
    124.     do {
    125.         let tokens =  try lexer.lex()
    126.         print("Lexer ouput: \(tokens)")
    127.         let parser = Parser(tokens: tokens)
    128.         let value = try parser.parse()
    129.         print(value)
    130.     } catch Lexer.Error.invalidCharacter(let character) {
    131.         print("Input contained an invalid character: \(character)")
    132.     } catch Parser.Error.unexpectedEndOfInput {
    133.         print("Unexpected end of input during parsing")
    134.     } catch Parser.Error.invalidToken(let token) {
    135.         print("Invalid token during parsing: \(token)")
    136.     } catch {
    137.         print("An error occurred: \(error)")
    138.     }
    139. }
    140. evaluate("10 + 3 + 5 +")

    4、扩展

    （1）扩展类/结构体

    1. typealias Velocity = Double
    2.  
    3. extension Velocity {
    4.     var kph: Velocity { return self * 1.60934 }
    5.     var mph: Velocity { return self }
    6. }
    7.  
    8. protocol Vehicle {
    9.     var topSpeed: Velocity { get }
    10.     var numberOfDoors: Int { get }
    11.     var hasFlatbed: Bool { get }
    12. }
    13.  
    14. struct Car {
    15.     let make: String
    16.     let model: String
    17.     let year: Int
    18.     let color: String
    19.     let nickname: String
    20.     var gasLevel: Double {
    21.         willSet {
    22.             precondition(newValue <= 1.0 && newValue >= 0.0, "New value must between 0 and 1.")
    23.         }
    24.     }
    25. }
    26.  
    27. //利用拓展使 Car 实现协议
    28. extension Car: Vehicle {
    29.     var topSpeed: Velocity { return 180 }
    30.     var numberOfDoors: Int { return 4 }
    31.     var hasFlatbed: Bool { return false }
    32. }
    33.  
    34. //利用拓展给 Car 增加初始化方法，这样会保留默认的成员初始化方法
    35. extension Car {
    36.     init(make: String, model: String, year: Int) {
    37.         self.init(make: make, model: model, year: year, color: "Black", nickname: "N/A", gasLevel: 1.0)
    38.     }
    39. }
    40.  
    41. var c = Car(make: "Ford", model: "Fusion", year: 2013)
    42.  
    43. extension Car {
    44.     enum Kind {
    45.         case coupe, sedan
    46.     }
    47.     var kind: Kind {
    48.         if numberOfDoors == 2 {
    49.             return .coupe
    50.         } else {
    51.             return .sedan
    52.         }
    53.     }
    54. }
    55. c.kind
    56.  
    57. extension Car {
    58.     mutating func  emptyGas(by amount: Double) {
    59.         precondition(amount <= 1 && amount > 0, "Amount to remove must be between 0 and 1.")
    60.         gasLevel -= amount
    61.     }
    62.     
    63.     mutating func fillGas() {
    64.         gasLevel = 1.0
    65.     }
    66. }
    67. c.emptyGas(by: 0.3)
    68. c.gasLevel
    69. c.fillGas()
    70. c.gasLevel

    （2）扩展协议

    1. protocol Exercise: CustomStringConvertible {
    2.     var name: String { get }
    3.     var caloriesBurned: Double { get } //消耗的卡路里
    4.     var minutes: Double { get }//锻炼的时长
    5. }
    6.  
    7. extension Exercise {
    8.     var description: String {
    9.         return "Exercise(\(name), burned \(caloriesBurned) calories in \(minutes) minutes)"
    10.     }
    11. }
    12.  
    13. extension Exercise {
    14.     var title: String {
    15.         return "\(name) - \(minutes) minutes"
    16.     }
    17. }
    18.  
    19. struct EllipticalWorkout: Exercise {
    20.     let name: String = "Elliptical Workout"
    21.     let title: String = "Workout using the Go Fast Elliptical Trainer 3000"
    22.     let caloriesBurned: Double
    23.     let minutes: Double
    24. }
    25.  
    26. struct TreadmillWorkout: Exercise {
    27.     let name: String = "Treadmill Workout"
    28.     let caloriesBurned: Double
    29.     let minutes: Double
    30.     let laps: Double //跑步的圈数
    31. }
    32. extension TreadmillWorkout {
    33.     var description: String {
    34.         return "TreadmillWorkout(\(caloriesBurned) calories and \(laps) laps in \(minutes) minutes)"
    35.     }
    36. }
    37.  
    38. let ellipticalWorkout = EllipticalWorkout(caloriesBurned: 335, minutes: 30)
    39. let runningWorkout = TreadmillWorkout(caloriesBurned: 350, minutes: 25, laps: 10.5)
    40. //使用范型定义函数：计算每分钟消耗的卡路里
    41. func caloriesBurnedPerMinute<E: Exercise>(for exercise: E) -> Double {
    42.     return exercise.caloriesBurned / exercise.minutes
    43. }
    44. print(caloriesBurnedPerMinute(for: ellipticalWorkout))
    45. print(caloriesBurnedPerMinute(for: runningWorkout))
    46.  
    47. //拓展协议
    48. extension Exercise {
    49.     //所有实现该协议的类型都可以使用通过拓展为该协议添加的属性和方法
    50.     var caloriesBurnedPerMinute: Double {
    51.         return caloriesBurned / minutes
    52.     }
    53. }
    54.  
    55. print(ellipticalWorkout.caloriesBurnedPerMinute)
    56. print(runningWorkout.caloriesBurnedPerMinute)
    57. print(ellipticalWorkout)
    58. print(runningWorkout)
    59.  
    60. //带 where 子句的协议拓展
    61. extension Sequence where Iterator.Element == Exercise {
    62.     func totalCaloriesBurned() -> Double {
    63.         var total: Double = 0
    64.         for exercise in self {
    65.             total += exercise.caloriesBurned
    66.         }
    67.         return total
    68.     }
    69. }
    70.  
    71. let mondayWorkout: [Exercise] = [ellipticalWorkout, runningWorkout]
    72. print(mondayWorkout.totalCaloriesBurned())
    73.  
    74.  
    75. for exercise in mondayWorkout {
    76.     print(exercise.title)
    77. }
    78. print(ellipticalWorkout.title)

    5、范型

    1. struct StackIterator<T>: IteratorProtocol {
    2. //    typealias Element = T
    3.     
    4.     var stack: Stack<T>
    5.     
    6.     mutating func next() -> T? {
    7.         return stack.pop()
    8.     }
    9. }
    10.  
    11. // Sequence 是实现 for-in 循环在内部使用的协议
    12. struct Stack<E>: Sequence {
    13.     var items = [E]()
    14.     
    15.     // 使用 where 子句约束 Sequence 的元素类型
    16.     mutating func pushAll<S: Sequence>(_ sequence: S) where S.Iterator.Element == E {
    17.         for item in sequence {
    18.             self.push(item)
    19.         }
    20.     }
    21.     
    22.     mutating func push(_ newItem: E) {
    23.         items.append(newItem)
    24.     }
    25.     
    26.     mutating func pop() -> E? {
    27.         guard !items.isEmpty else {
    28.             return nil
    29.         }
    30.         return items.removeLast()
    31.     }
    32.     
    33.     func map<U>(_ f: (E) -> U) -> Stack<U> {
    34.         var mappedItems = [U]()
    35.         for item in items {
    36.             mappedItems.append(f(item))
    37.         }
    38.         return Stack<U>(items: mappedItems)
    39.     }
    40.     
    41.     func makeIterator() -> StackIterator<E> {
    42.         return StackIterator(stack: self)
    43.     }
    44. }
    45.  
    46. var intStack = Stack<Int>()
    47. intStack.push(1)
    48. intStack.push(2)
    49. var doubledStack = intStack.map { 2 * $0 }
    50.  
    51. print(intStack.pop())
    52. print(intStack.pop())
    53. print(intStack.pop())
    54. print(doubledStack.pop())
    55. print(doubledStack.pop())
    56.  
    57. func myMap<T, U>(_ items: [T], _ f: (T) -> U) -> [U] {
    58.     var result = [U]()
    59.     for item in items {
    60.         result.append(f(item))
    61.     }
    62.     return result
    63. }
    64. let strings = ["one", "two", "three"]
    65. //let stringLengths = myMap(strings, {(str: String) -> Int in
    66. //    return str.count
    67. //})
    68. let stringLengths = myMap(strings) { $0.count }
    69. print(stringLengths)
    70.  
    71. //类型约束
    72. func checkIfEqual<T: Equatable>(_ first: T, _ second: T) -> Bool {
    73.     return first == second
    74. }
    75. print(checkIfEqual(1, 1))
    76. print(checkIfEqual("a string", "a string"))
    77. print(checkIfEqual("a string", "a different string"))
    78.  
    79. //每个占位类型都可以有一个类型约束
    80. func checkIfDescriptionsMatch<T: CustomStringConvertible, U: CustomStringConvertible>(_ first: T, _ second: U) -> Bool {
    81.     return first.description == second.description
    82. }
    83.  
    84. print(checkIfDescriptionsMatch(Int(1), UInt(1)))
    85. print(checkIfDescriptionsMatch(1, 1.0))
    86. print(checkIfDescriptionsMatch(Float(1.0), Double(1.0)))
    87.  
    88.  
    89. var myStack = Stack<Int>()
    90. myStack.push(10)
    91. myStack.push(20)
    92. myStack.push(30)
    93. var myStackIterator = StackIterator(stack: myStack)
    94. while let value = myStackIterator.next() {
    95.     print("got \(value)")
    96. }
    97.  
    98. for value in myStack {
    99.     print("for-in loop: got \(value)")
    100. }
    101. myStack.pushAll([1, 2, 3])
    102. for value in myStack {
    103.     print("after pushing: got \(value)")
    104. }
    105. var myOtherStack = Stack<Int>()
    106. myOtherStack.pushAll([1, 2, 3])
    107. myStack.pushAll(myOtherStack)
    108. for value in myStack {
    109.     print("after pushing item onto stack, got \(value)")
    110. }

    6、协议

    1. protocol TabularDataSource {
    2.     var numberOfRows: Int { get }
    3.     var numberOfColumns: Int { get }
    4.     func label(forColumn column: Int) -> String
    5.     func itemFor(row: Int, column: Int) -> String
    6. }
    7.  
    8. protocol PrintableTabularDataSource: TabularDataSource, CustomStringConvertible {
    9.     //
    10. }
    11.  
    12. //组合协议，让 printTable 的参数符合 CustomStringConvertible 协议
    13. func printTable(_ dataSource: TabularDataSource & CustomStringConvertible) {
    14.     print(dataSource)
    15.     var firstRow = "|"
    16.     var columnWidths = [Int]()
    17.     for i in 0..<dataSource.numberOfColumns {
    18.         let columnLabel = dataSource.label(forColumn: i)
    19.         let columnHeader = " \(columnLabel) |"
    20.         firstRow += columnHeader
    21.         columnWidths.append(columnLabel.count)
    22.     }
    23.     print(firstRow)
    24.     
    25.     for i in 0..<dataSource.numberOfRows {
    26.         var out = "|"
    27.         for j in 0..<dataSource.numberOfColumns {
    28.             let item = dataSource.itemFor(row: i, column: j)
    29.             let paddingNeeded = columnWidths[j] - item.count
    30.             let padding = repeatElement(" ", count: paddingNeeded).joined(separator: "")
    31.             out += " \(padding)\(item) |"
    32.         }
    33.         print(out)
    34.     }
    35. }
    36.  
    37.  
    38. struct Person {
    39.     let name: String
    40.     let age: Int
    41.     let yearsOfExperience: Int
    42. }
    43.  
    44. struct Department: TabularDataSource, CustomStringConvertible {
    45.     let name: String
    46.     var people = [Person]()
    47.     
    48.     var description: String {
    49.         return "Department (\(name))"
    50.     }
    51.     
    52.     init(name: String) {
    53.         self.name = name
    54.     }
    55.     
    56.     mutating func add(_ person: Person) {
    57.         people.append(person)
    58.     }
    59.     
    60.     var numberOfRows: Int {
    61.         return people.count
    62.     }
    63.     
    64.     var numberOfColumns: Int {
    65.         return 3
    66.     }
    67.     
    68.     func label(forColumn column: Int) -> String {
    69.         switch column {
    70.         case 0: return "Employee Name"
    71.         case 1: return "Age"
    72.         case 2: return "Years of Experience"
    73.         default: fatalError("Invalid column!")
    74.         }
    75.     }
    76.     
    77.     func itemFor(row: Int, column: Int) -> String {
    78.         let person = people[row]
    79.         switch column {
    80.         case 0: return person.name
    81.         case 1: return String(person.age)
    82.         case 2: return String(person.yearsOfExperience)
    83.         default: fatalError("Invalid column!")
    84.         }
    85.     }
    86. }
    87.  
    88. var department = Department(name: "Engineering")
    89. department.add(Person(name: "Joe", age: 30, yearsOfExperience: 6))
    90. department.add(Person(name: "Karen", age: 40, yearsOfExperience: 18))
    91. department.add(Person(name: "Fred", age: 50, yearsOfExperience: 20))
    92.  
    93. printTable(department)

    7、字符串

    1. import Cocoa
    2.  
    3. extension String {
    4.     /// 截取字符串
    5.     /// - Parameter start: 起始索引（包含）
    6.     /// - Parameter end: 结束索引（不包含）
    7.     func substring(start: Int, end: Int) -> String {
    8.         let firstIndex = index(startIndex, offsetBy: start)
    9.         let lastIndex = index(startIndex, offsetBy: end)
    10.         return String(self[firstIndex..<lastIndex])
    11.     }
    12.     
    13.     /// 16进制字符串（可以有空格）转换成二进制数据
    14.     func toData() -> Data {
    15.         let hex = self.replacingOccurrences(of: " ", with: "")
    16.         var arr = Array<UInt8>()
    17.         for i in 0..<hex.count where i % 2 == 0 {
    18.             let byteStr = hex.substring(start: i, end: i + 2)
    19.     //        print("byteStr = \(byteStr)")
    20.             arr.append(UInt8(byteStr, radix: 16) ?? 0)
    21.         }
    22.         return Data(arr)
    23.     }
    24. }
    25.  
    26. extension Data {
    27.     
    28.     /// 按照 ASCII 转换成字符串
    29.     func toAscii() -> String {
    30.         return subdata2ascii(start: 0, end: self.count)
    31.     }
    32.     
    33.     /// 转换成16进制字符串
    34.     /// - Parameter withSpace: 可选参数，默认true，输出的字符串是否每两个字节之间放一个空格
    35.     func toHex(withSpace: Bool = true) -> String {
    36.         return subdata2hex(start: 0, end: self.count, withSpace: withSpace)
    37.     }
    38.     
    39.     /// 将指定范围的数据转换成ASCII字符串
    40.     /// - Parameter start: 起始索引（包含）
    41.     /// - Parameter end: 结束索引（不包含）
    42.     func subdata2ascii(start: Int, end: Int) -> String {
    43.         if let str = String(data: self[start..<end], encoding: .ascii) {
    44.             return str
    45.         }
    46.         return ""
    47.     }
    48.     
    49.     /// 将指定范围的数据转换成16进制字符串
    50.     /// - Parameter start: 起始索引（包含）
    51.     /// - Parameter end: 结束索引（不包含）
    52.     /// - Parameter withSpace: 可选参数，默认true，输出的字符串是否每两个字节之间放一个空格
    53.     func subdata2hex(start: Int, end: Int, withSpace: Bool = true) -> String {
    54.         let arr = Array<UInt8>(self[start..<end])
    55.         let hex = arr.map({ byte -> String in
    56.             return String(format: "%02X", byte)
    57.         }).joined(separator: withSpace ? " " : "")
    58.         return hex
    59.     }
    60. }
    61.  
    62.   
    63. func test() {
    64.     let hexString = "5A 58 48 0C 83 0E 47 07 22 2B 42 41 30 34 56 30 35"
    65.     let data = hexString.toData()
    66.     print("head = \(data.subdata2ascii(start: 0, end: 3))")
    67.     print("mac = \(data.subdata2hex(start: 3, end: 9))")
    68.     print("DeviceType = \(data.subdata2ascii(start: 9, end: 14))")
    69.     print("version = \(data.subdata2ascii(start: 14, end: data.count))")
    70.     print(data.toHex(withSpace: true))
    71. }
    72.  
    73. test()
    74.  
    75. let apples = 3
    76. let oranges = 5
    77. //只要与结束引号(""")的缩进匹配，就会删除每一行开始处的缩进
    78. let quotation = """
    79.         Even though there's whitespace to the left,
    80.         the actual lines aren't indented.
    81.             Except for this line.
    82.         Double quotes (") can appear without being escaped.
    84.         I still have \(apples + oranges) pieces of fruit.
    85.         """
    86. print(quotation)

    8、类和结构体

    1. /** struct 类似 Kotlin 的 data class，等价写法是：
    2.  data class Person(var firstName: String = "Matt", var lastName: String = "Mathias")
    3.  */
    4. struct Person {
    5.     var firstName = "Matt"
    6.     var lastName = "Mathias"
    7. }
    8.  
    9. var p = Person(firstName: "Jia", lastName: "Jiefei")
    10. print(p)
    11.  
    12.  
    13. //如果属性没有提供默认值，结构体会根据属性生成默认的成员初始化方法，并且直接打印结构体可以看到所有存储属性的值
    14. struct Device {
    15.     var name: String
    16.     var address: String
    17.     // text 是计算属性，打印时不会输出
    18.     var text: String {
    19.         return "name=\(name), address=\(address)"
    20.     }
    21. }
    22. print(Device(name: "Device", address: "11:22:33:44:55:66"))
    23.  
    24. //而类就没有默认成员初始化方法了，需要自己编写初始化方法，并且直接打印类实例，不会输出各存储属性的值
    25. class BleDevice {
    26.     var name: String
    27.     var address: String
    28.     
    29.     required init(name: String, address: String) {
    30.         self.name = name
    31.         self.address = address
    32.     }
    33. }
    34. print(BleDevice(name: "BleDevice", address: "AA:BB:CC:DD:EE:FF"))

    9、值类型和引用类型

    1. //类是引用类型
    2. class GreekGod {
    3.     var name: String
    4.     
    5.     init(name: String) {
    6.         self.name = name
    7.     }
    8. }
    9.  
    10. let hecate = GreekGod(name: "Hecate")
    11. let athena = GreekGod(name: "Athena")
    12. let zeus = GreekGod(name: "Zeus")
    13. let anotherHecate = hecate
    14. anotherHecate.name = "AnotherHecate"
    15. hecate.name //类是引用类型，改变 anotherHecate.name，hecate.name也会变
    16.  
    17. //结构体是值类型
    18. struct Pantheon {
    19.     var chiefGod: GreekGod
    20. }
    21.  
    22. let pantheon = Pantheon(chiefGod: hecate)
    23.  
    24. pantheon.chiefGod.name // AnotherHecate
    25. let greekPantheon = pantheon
    26. hecate.name = "Trivia"
    27. greekPantheon.chiefGod.name // Trivia
    28.  
    29. let gods = [athena, hecate, zeus]
    30. let godsCopy = gods
    31. gods.last?.name = "Jupiter"
    32. godsCopy.last?.name // Jupiter
    33.  
    34.  
    35. //探究写时复制（copy on write, COW）
    36. fileprivate class IntArrayBuffer {
    37.     var storage: [Int]
    38.     
    39.     init() {
    40.         storage = []
    41.     }
    42.     
    43.     init(buffer: IntArrayBuffer) {
    44.         storage = buffer.storage
    45.     }
    46. }
    47.  
    48. struct IntArray {
    49.     private var buffer: IntArrayBuffer
    50.     
    51.     init() {
    52.         buffer = IntArrayBuffer()
    53.     }
    54.     
    55.     func describe() {
    56.         let str = buffer.storage.map { i in
    57.             String(i)
    58.         }.joined(separator: ", ")
    59.         print("[\(str)]")
    60. //        print(buffer.storage)
    61.     }
    62.     
    63.     private mutating func copyIfNeeded() {
    64.         //判断引用类型是否只有一个引用
    65.         if !isKnownUniquelyReferenced(&buffer) {
    66.             print("Making a copy of \(buffer.storage)")
    67.             buffer = IntArrayBuffer(buffer: buffer)
    68.         }
    69.     }
    70.     
    71.     
    72.     mutating func insert(_ value: Int, at index: Int) {
    73.         copyIfNeeded()
    74.         buffer.storage.insert(value, at: index)
    75.     }
    76.     
    77.     mutating func append(_ value: Int) {
    78.         copyIfNeeded()
    79.         buffer.storage.append(value)
    80.     }
    81.     
    82.     mutating func remove(at index: Int) {
    83.         copyIfNeeded()
    84.         buffer.storage.remove(at: index)
    85.     }
    86. }
    87.  
    88. var integers = IntArray()
    89. integers.append(1)
    90. integers.append(2)
    91. integers.append(4)
    92. integers.describe()
    93. var ints = integers
    94. ints.insert(3, at: 2)
    95. integers.describe()
    96. ints.describe()

    10、继承

    虽然是讲继承，但代码中的注释也会涉及其他知识点！例子涉及3个.swift文件

    Town.swift

    1. struct Town {
    2.     let region: String
    3.     var population: Int {
    4.         didSet {
    5.             print("The population has changed to \(population) from \(oldValue)")
    6.         }
    7.     }
    8.     var numberOfStoplights: Int
    9.     
    10.     //自定义初始化方法，问号表示可失败的初始化方法
    11.     init?(region: String, population: Int, stoplights: Int) {
    12.         guard population > 0 else {
    13.             return nil
    14.         }
    15.         self.region = region
    16.         self.population = population
    17.         numberOfStoplights = stoplights
    18.     }
    19.     
    20.     //委托初始化
    21.     init?(population: Int, stoplights: Int) {
    22.         self.init(region: "N/A", population: population, stoplights: stoplights)
    23.     }
    24.     
    25.     enum Size {
    26.         case small
    27.         case medium
    28.         case large
    29.     }
    30.     
    31.     //计算属性
    32.     var townSize: Size {
    33.         get {
    34.             print("town size")//每次调用都会打印
    35.             switch self.population {
    36.             case 0...10_000:
    37.                 return Size.small
    38.             case 10_001...100_000:
    39.                 return Size.medium
    40.             default:
    41.                 return Size.large
    42.             }
    43.         }
    44.     }
    45.     
    46.     //惰性存储属性，注意这里的等号以及结尾的圆括号
    47.     lazy var name: String = {
    48.         print("town name")//这里只会打印一次，即第一次访问该属性时
    49.         return "XiShe"
    50.     }()
    51.     
    52.     
    53.     func printDescription() {
    54.         print("Population: \(population), number of stoplights: \(numberOfStoplights), region: \(region)")
    55.     }
    56.     
    57.     /* 如果结构体（确切的说，应该是值类型，结构体和枚举都是值类型）的一个实例方法需要修改结构体的属性，就必须使用 mutating 标记该方法 */
    58.     mutating func changePopulation(by amount: Int) {
    59.         population += amount
    60.     }
    61.     
    62.     /* 对于值类型，类型方法使用static标记 */
    63.     static func xxx() {
    64.         
    65.     }
    66. }

    Monster.swift

    1. class Monster {
    2.     // static 属性无法被子类覆盖
    3.     static let isTerrifying = true
    4.     // class 属性可被子类覆盖
    5.     class var spookyNoise: String {
    6.         return "Grrr"
    7.     }
    8.     var town: Town?
    9.     var name: String
    10.     
    11.     var victimPool: Int {
    12.         get {
    13.             return town?.population ?? 0
    14.         }
    15.         set {
    16.             town?.population = newValue
    17.         }
    18.     }
    19.     
    20.     //子类必须得实现的初始化方法
    21.     required init(town: Town?, monsterName: String) {
    22.         self.town = town
    23.         name = monsterName
    24.     }
    25.     
    26.     
    27.     func terrorizeTown() {
    28.         if town != nil {
    29.             print("\(name) is terrorizing a town!")
    30.         } else {
    31.             print("\(name) hasn't found a town to terrorize yet...")
    32.         }
    33.     }
    34.     
    35.     /* 对于类，类型方法使用class或者static标记，区别在于static标记的方法无法被子类重写，也可以使用final class代替static */
    36.     static func makeSpookyNoise() {
    37.         print("Brains...")
    38.     }
    39. }

    Zombie.swift

    1. class Zombie: Monster {
    2.     override class var spookyNoise: String {
    3.         return "Brains..."
    4.     }
    5.     var walkWithLimp: Bool
    6.     //只将 set 属性设置为私有，get 属性为默认的 internal
    7.     private(set) var isFallingApart: Bool
    8.     
    9.     //指定初始化方法
    10.     init(limp: Bool, fallingApart: Bool, town: Town?, monsterName: String) {
    11.         walkWithLimp = limp
    12.         isFallingApart = fallingApart
    13.         //如果有父类，子类的指定初始化方法必须调用父类的指定初始化方法
    14.         super.init(town: town, monsterName: monsterName)
    15.     }
    16.     
    17.     //便捷初始化方法，必须调用指定初始化方法或者其他便捷初始化方法，但最终都要调用指定初始化方法，以确保所有属性都进行了初始化
    18.     convenience init(limp: Bool, fallingApart: Bool) {
    19.         self.init(limp: limp, fallingApart: fallingApart, town: nil, monsterName: "Fred")
    20.         if walkWithLimp {
    21.             print("This zombie has a bad knee.")
    22.         }
    23.     }
    24.     
    25.     
    26.     required init(town: Town?, monsterName: String) {
    27.         walkWithLimp = false
    28.         isFallingApart = false
    29.         super.init(town: town, monsterName: monsterName)
    30.     }
    31.     
    32.     //实例被清除出内存时会触发反初始化
    33.     deinit {
    34.         print("Zombie named \(name) is no longer with use.")
    35.     }
    36.     
    37.     //final 禁止子类重写该方法
    38.     final override func terrorizeTown() {
    39.         if !isFallingApart {
    40.             town?.changePopulation(by: -10)
    41.         }
    42.         super.terrorizeTown()
    43.     }
    44. }

     测试代码

    1. var town = Town(region: "West", population: 10, stoplights: 6)
    2. town?.printDescription()
    3. for _ in 0..<3 {
    4.     if let townSize = town?.townSize, let townName = town?.name {
    5.         print(townSize)
    6.         print(townName)
    7.     }
    8.     town?.changePopulation(by: 1_000_000)
    9. }
    10. //let genericMonster = Monster()
    11. //genericMonster.town = town
    12. //genericMonster.terrorizeTown()
    13. var fredTheZombie: Zombie? = Zombie(limp: false, fallingApart: false, town: town, monsterName: "Fred")
    14. //fredTheZombie.terrorizeTown()
    15. //fredTheZombie.town?.printDescription()
    16. //Monster.makeSpookyNoise()
    17. print("Victim pool: \(fredTheZombie?.victimPool)")
    18. fredTheZombie?.victimPool = 500
    19. fredTheZombie = nil
    20. print(Monster.spookyNoise)
    21. print(Zombie.spookyNoise)

    11、数组和字典

    1. //初始化数组的3种方式，本人习惯上倾向使用第一种
    2. //使用 var 就是可变数组，let就是不可变数组
    3. var bucketList: Array<String> = []
    4. var bucketList2:[String] = ["haha"]
    5. var arr = [Int]()
    6. arr.append(1)
    7. arr.append(3)
    8. arr.append(2)
    9. //print("bucketList.count=\(bucketList.count) arr[0]=\(arr[0])")
    10. //数组排序
    11. let sortedArray = arr.sorted(by: {a, b in
    12.     a < b
    13. })
    14. print(sortedArray)
    15. //注：只有Array 才有 joined 方法，如果元素类型不是 String，得先通过 map 方法转一次
    16. let joinedString = arr.map { i in
    17.     String(i)
    18. }.joined(separator: ", ")
    19. print("[\(joinedString)]")
    20.  
    21. //字典也有多种初始化方式，这里只列出其中一种
    22. //使用 var 就是可变字典，let就是不可变字典
    23. var dict: Dictionary<String, Int> = [:]
    24. dict["one"] = 1
    25. dict["two"] = 2
    26. dict["three"] = 3
    27. //遍历字典
    28. for (key, value) in dict {
    29.     print("\(key) = \(value)")
    30. }
    31. dict.removeValue(forKey: "one")
    32. dict["two"] = nil //将值设置为nil来删除键值对
    33. print(dict)

  • 相关阅读:
    【C/C++】C语言获取键盘输入
    【21天python打卡】第14天 网络爬虫（5）
    C++特性——inline内联函数
    Vue双向绑定的原理
    前端Vue篇之Vuex中action和mutation的区别、Vuex 和 localStorage 的区别
    Java如何使用DOM4j解析XML呢?
    如何快速通过阿里云ACP 认证？
    高通量筛选——离子化合物
    基于昇腾AI 使用AscendCL实现垃圾分类和视频物体分类应用
    数据结构-归并排序与基数排序
  • 原文地址：https://blog.csdn.net/jjf19891208/article/details/133828462