快速浏览Swift-笔记

快速浏览Swift-笔记

快速浏览Swift：https://docs.swift.org/swift-book/GuidedTour/GuidedTour.html

变量也常量

// 多行字符串，使用 “”" “”"

let quotation = """
I said "I have \(3) apples."
And then I said "I have \(3 + 4) pieces of fruit."
"""
print(quotation)

// 创建一个空数组，可变的

var array = [String]()

// 创建一个空字典，key是String类型，value是Float类型

var dictionary = [String: Float]()

// 创建一个字典，key是String类型，value是任何类型

var dictionary1 = [String: Any]()

// 字符串

var string = "hello"

// 可选类型 ?

var optionnalString: String? = "hello"

控制流

// if let

if let str = optionnalString {
   
    print(str)
}

// 可选类型

//let nickName: String = nil // 报错：'nil' cannot initialize specified type 'String'
let nickName: String? = nil  // 有点三目运算符的感觉，有没有有，没有的话就是nil
let fullName: String = "John"
// ?? 运算符设置默认值
let name: String = "My name is \(nickName ?? fullName)"

// Switch 支持任何类型的比较，不仅局限于整数的比较

函数与闭包

// 函数

// func 函数名(形参) -> 返回值
/**
func <#name#>(<#parameters#>) -> <#return type#> {
<#function body#>
}
*/
func person(fullName name: String, age: Int) -> String {
   
    return "\(name) age:\(age)"
}

// 关于形参：
// 1. 在括号()里面，多个参数的话用逗号隔开，这和大多数语言都是一样的
// 2. 冒号前面的是 形参，冒号后面空一格，之后是参数类型
// 3. 形参数前面可以加一个 “参数标签”。也可以不写，在Swift旧的版本里不写的话得需要使用“”来表示不使用任何参数标签。在Swift5中，淡化了参数标签的存在，不写，不加“”编译也不会报错

// 元组
// 使用()来定义一个元组
// 可以使用元组作为函数返回值

func calculatesStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
   
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
   
        if score > max {
   
            max = score
        } else if score < min {
   
            min = score
        }
        sum += score
    }
    return (min, max, sum)
}

// 函数嵌套
// 一个函数中嵌套另外一个函数的实现

// 函数作为另一个函数的返回值
// 将函数放在()中返回，看来是将函数作为元组的一个元素返回
// ((函数参数) -> 函数的返回值)

func makeIncrementer() -> ((Int) -> Int) {
   
    func addOne(num: Int) -> Int {
   
        return num+1
    }
    return addOne(num:)
}

// 函数作为参数

// 闭包

对象和类

// class 类名

class Shape {
   
    // 变量，可变的
    var numberOfSides = 0
    // 常量
    let sumNumbers = 100

    // 初始化
    init(sides: Int) {
   
        numberOfSides = sides
    }
    
    func simpleDescription() -> String {
   
        return "A shape with \(numberOfSides) sides."
    }
}

// 创建一个shape实例

var shape = Shape()
shape.numberOfSides = 10

// 继承

class rectangle: Shape {
   

    var sideLength: Double
    var sidWidth: Double


    // ? init函数中不添加sideLength 和 sidWidth的话会报错？Why？
    init(sideLength: Double, sidWidth: Double, sides: Int) {
   
        self.sideLength = sideLength
        self.sidWidth = sidWidth
        super.init(sides: sides)
    }

    // 定义一个变量，顺便写上set和get方法
    var perimeter: Double {
   
        get {
   
            return 3.0 * sideLength
        } set {
   
            sideLength = newValue / 3.0   // 这里这个newValue就比较有意思了，set之后会先保存一个tep值，就是newValue吧。
        }
    }

    // willSet 和 didSet
    //
}

枚举（enum） 和 结构体（struct）

// 枚举

enum AliasAPI: Int {
   
    case register = 1
    case login
    case getPersonalInfo
    case updatePersionalInfo

    func API() -> String {
   
        switch self {
   
        case .register:
            return "register/v1"
        case .login:
            return "login/v1"
        case .getPersonalInfo:
            return "getPersonalInfo/v2"
        case .updatePersionalInfo:
            return "updatePersionalInfo/v2"
        }
    }
}

let api = AliasAPI.login
let apiRawValue = api.rawValue
print(apiRawValue)
let apiString = api.API()
print(apiString)


//enum APICommad: String {
   
//    case register
//    case login
//    case getPersonalInfo
//    case updatePersionalInfo
//}
//
//func getApi(command: APICommad) -> String {
   
//    return command.rawValue
//}
//let apiValue = getApi(command: .login)
//print(apiValue)


enum APICommad: String {
   
    case register
    case login
    case getPersonalInfo
    case updatePersionalInfo
}
let apiValue = APICommad.login
print(apiValue)

协议和扩展

// protocol
// 类，枚举和结构都可以用协议。

// 声明一个协议

protocol ActivitiseProtocol {
   
    var name: String {
    get }  // 这里不加{ get }爆红了
    var age: Int {
    get }
    
    mutating func eat()  // 为什么需要用mutating来修饰
    
}

class Person: ActivitiseProtocol {
   
    var name: String = ""
    var age: Int = 0
    var dog: Dog?
    
    func eat() {
   
        print("吃饭")
    }
}

class Dog: ActivitiseProtocol {
   
    var name: String = ""
    var age: Int = 0
    func eat() {
   
        print("吃狗粮")
    }
}

var dog = Dog()
dog.eat()
dog.name = "Huahua"

var p = Person()
p.eat()
p.name = "Xiaoming"
p.dog = dog


print(p.dog?.name ?? "")

错误处理

// 使用该Error协议自定义错误类型

enum XXError: Error {
    // 注意，这里Error是一个协议
    case parater
    case api
    case url
    case network
}

// throw抛出错误，这个和其他语言差不多

// do- catch。也和其他语言一样的

do {
   
    
} catch {
   
    
}

// try?

// defer

/// 泛型
// <> 里写一个名称，代表通用的类型 这个和C#中的泛型一样一样的，其他语言应该也有吧

func makeArray<Item>(item: Item, numberOfTimes: Int) -> [Item] {
   
    var result = [Item]()
    for _ in 0..<numberOfTimes {
   
        result.append(item)
    }
    return result
}


var myArray:[String] = makeArray(item: "value", numberOfTimes: 3)
print(myArray)
 
var myArray1:[Dog] = makeArray(item: dog, numberOfTimes: 3)
print(myArray1)

转载：https://blog.csdn.net/Morris_/article/details/116266972