ios客户端学习笔记（五）：学习Swift的关键字和容易弄混的符号

新找到一篇文，也比较全 swift 5.1语法 1小时入门

1. 关键字

下面是Swift语言中的常见关键字及其说明和代码应用实例：

1. class：定义一个类，用于封装一组相关的属性和方法。

示例代码：

class Person {
    var name: String = ""
    var age: Int = 0
}

2. struct：定义一个结构体，用于封装一组相关的值类型数据。

示例代码：

struct Point {
    var x: Int
    var y: Int
}

3. enum：定义一个枚举类型，用于封装一组相关的有限值。

示例代码：

enum Direction {
    case north
    case south
    case east
    case west
}

4. extension：扩展一个已有的类型，添加新的属性、方法或下标等。

示例代码：

extension String {
    func reverse() -> String {
        var result = ""
        for char in self {
            result = String(char) + result
        }
        return result
    }
}

let str = "hello"
let reversedStr = str.reverse() // "olleh"

5. protocol：定义一个协议，用于规定一组方法、属性或其他需求，可以被类、结构体或枚举类型实现。

示例代码：

protocol Printable {
    var description: String { get }
}

struct Person: Printable {
    var name: String
    var age: Int
    
    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Tom", age: 20)
print(person) // "Tom, 20 years old"

6. guard：用于提前退出函数、方法或循环，以避免出现嵌套的 if 语句。

示例代码：

func test(age: Int?) {
    guard let age = age, age >= 18 else {
        print("未满18岁")
        return
    }
    print("已满18岁")
}

test(age: 20) // "已满18岁"
test(age: nil) // "未满18岁"
test(age: 16) // "未满18岁"

7. weak：用于声明一个弱引用，避免循环引用问题。

示例代码：

class Person {
    var name: String = ""
    weak var spouse: Person?
}

var tom: Person? = Person()
var lily: Person? = Person()

tom?.name = "Tom"
lily?.name = "Lily"

tom?.spouse = lily
lily?.spouse = tom

tom = nil
print(lily?.spouse?.name) // nil

8. static：用于定义一个静态属性或方法，可以通过类型名直接调用。

示例代码：

struct Math {
    static let pi = 3.14
    
    static func square(_ x: Int) -> Int {
        return x * x
    }
}

print(Math.pi) // 3.14
print(Math.square(2)) // 4

9. private：用于限制访问级别，只有在当前文件内可以访问。
   public、internal、fileprivate、private
   

示例代码：

class Person {
    private var name: String = ""
    var age: Int = 0
    
    func printName() {
        print(name)
    }
}

let person = Person()
person.age = 20
person.printName() // 编译错误，name为私有属性

10. override：用于重写父类的方法、属性或下标等。

示例代码：

class Animal {
    var name: String = ""
    
    func makeSound() {
        print("...")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("wangwang")
    }
}

let dog = Dog()
dog.makeSound() // "wangwang"

11. final：Swift中，final关键字可以在class、func和var前修饰。表示 不可重写，可以将类或者类中的部分实现保护起来,从而避免子类破坏。

class Fruit {
    //修饰词 final 表示 不可重写 可以将类或者类中的部分实现保护起来,从而避免子类破坏
    final  func price(){
        print("price")
    }
}

class Apple : Fruit {//类继承
    //重写父类方法
    override func price() {
        print("重写父类的price 方法")
    }
    // 上面的会报错
}

12. mutating：写在func前面,以便于让func可以修改struct和protocol的extension中的成员的值。 如果func前面不加mutating，struct和protocol的extension中的成员的值便被保护起来，不能修改
    下面是使用mutating关键字的具体代码实例：

protocol Vehicle {
    var speed: Double { get set }
    mutating func accelerate(by delta: Double)
}

struct Car: Vehicle {
    var speed: Double = 0
    
    mutating func accelerate(by delta: Double) {
        speed += delta
    }
}

var car = Car()
print(car.speed) // 0

car.accelerate(by: 50)
print(car.speed) // 50

在上面的代码中，我们定义了一个Vehicle协议，其中包含一个可读写的speed属性和一个mutating方法accelerate(by:)，用于加速车辆。然后我们定义了一个Car结构体，实现了Vehicle协议，并且在accelerate(by:)方法前面加上了mutating关键字，以便于修改Car结构体中的属性speed。最后，我们创建了一个Car实例，并调用accelerate(by:)方法加速，成功修改了speed属性的值。

如果我们在accelerate(by:)方法前面不加mutating关键字，那么编译器会报错，提示我们不能在结构体中修改属性的值。

另外可看Swift中常用关键字

2. 容易弄混的符号（？ ！）

1） ？

Swift 可选(Optionals)类型
Swift 的可选（Optional）类型，用于处理值缺失的情况。可选表示"那儿有一个值，并且它等于 x “或者"那儿没有值”。

Swfit语言定义后缀？作为命名类型Optional的简写，换句话说，以下两种声明是相等的：

var optionalInteger: Int?
var optionalInteger: Optional<Int>

在这两种情况下，变量 optionalInteger 都是可选整数类型。注意，在类型和 ?之间没有空格。

Optional 是一个含有两种情况的枚举，None 和 Some(T)，用来表示可能有或可能没有值。任何类型都可以明确声明为（或者隐式转换）可选类型。当声明一个可选类型的时候，要确保用括号给 ? 操作符一个合适的范围。例如，声明可选整数数组，应该写成 (Int[])? 写成 Int[]? 会报错。

当你声明一个可选变量或者可选属性的时候没有提供初始值，它的值会默认为 nil。

可选项遵照 LogicValue 协议，因此可以出现在布尔环境中。在这种情况下，如果可选类型T?包含类型为T的任何值（也就是说它的值是 Optional.Some(T) ），这个可选类型等于 true，反之为 false。

实践

class Person{
    var mac: Mac?
    init?(mac: Mac?){
        guard let mac = mac else { return nil }
        self.mac = mac
    }
    
    // swift中的下标语法，使得获取某些值更加便捷。
    subscript(index: String) -> Int {
        switch index {
            case "count": return self.mac?.name.count ?? 0
            default:
                return 0
        }
    }
}
 
class Mac{
    let name: String = "mac book pro"
}
 
let person = Person(mac: nil)
 
print(person?.mac?.name.count ?? 0)
print(person?["count"] ?? 0)

下面是代码中每个含？号的语句的含义注释：

1. init?(mac: Mac?): 这是一个可失败的初始化方法，参数为可选类型的Mac对象。如果传入的Mac对象为nil，则初始化会失败，返回nil；否则，会将传入的Mac对象赋值给类属性mac，初始化成功。

2. self.mac?.name.count: 这是一个可选链式调用，表示如果mac不为nil，则获取mac的name属性的字符数量；否则，返回nil。

3. print(person?.mac?.name.count ?? 0): 这是一个可选链式调用，表示如果person不为nil，则获取person的mac属性的name属性的字符数量；否则，返回0。

4. print(person?["count"] ?? 0): 这是一个下标语法，表示如果person不为nil，则获取person的下标为"count"的值；否则，返回0。在Person类中，下标的实现是获取mac的name属性的字符数量。

2） ！

如果一个可选类型的实例包含一个值，你可以用后缀操作符 ！来访问这个值，如下所示：

optionalInteger = 42
optionalInteger! // 42

使用操作符！去获取值为nil的可选变量会有运行时错误。

你可以用可选链接和可选绑定选择性执行可选表达式上的操作。如果值为nil，任何操作都不会执行，也不会有运行报错。

来源：菜鸟教程