swift 5.1语法 1小时入门

while 条件{
   表达式
}

repeat{
  
} while 条件

while 和 repeat while 的循环次数是一样的。

swift 没有 i++。 赋值表达式没有返回值。

if 条件{
  // 表达式1
} else if 条件1 {
  
} else {
  
}

class Person{
    var mac: Mac?
    init?(mac: Mac?){
        // mac == nil 时直接返回nil
        guard let mac = mac else { return nil }
        // mac != nil 才走下面的逻辑
        self.mac = mac
    }
}

swift中的switch 更强大，进行模式匹配。

字符串匹配

let a = "a"

switch "b" {
    case "a":
        print("a")
    case "b":
        print("b")
    default:
        print("默认值")
}

区间匹配

let cout = 32
switch cout {
case 1...3:
    print("in 1...3")
case 30...40:
    print("in 30...40")
default:
    print("默认匹配")
}

元组

let somePoint = (1,20)
switch somePoint {
case (0,0):
    print("(0,0)")
case (1,_):
    print("first = 1,second 随意")
case (_,20):
    print("first 随意，second = 20")
default:
    print("没有匹配上")
}

值绑定

let anotherPoint = (2,0)
switch anotherPoint {
case (let x,0):
    print("x = \(x), y = 0")
case (2, let y):
    print("x = 2, y = \(y)")
case (let x ,let y):
    print("x = \(x),y = \(y)")
}

where 附加条件

let yetAnotherPoint = (1,-1)
switch yetAnotherPoint {
case let (x,y) where x == y:
    print("x = \(x),y = \(y)")
case let (x, y) where x == -y:
    print("x = \(x),y = \(y)")
default:
    print("x = \(yetAnotherPoint.0),y = \(yetAnotherPoint.1)")
}

符合型

let char = "a"
switch char {
case "a", "e", "i", "o", "u":
    print(char)
default:
    print("其他char")
}

穿透

var index = 10
switch index {
case 10:
    index += 1
    fallthrough
default:
    index += 1
}
// 12 穿透执行
print(index)

·continue break

func 函数名（参数名：类型，参数名：类型）-> 返回类型{
  // 执行体
}



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


let array = [1,3,4,5,6,7,8]
print("min = \(minMax(array: array).min) max = \(minMax(array:array).max)")

如果函数体是一个单行return 语句，那么这个return可以省略掉。

func greeting(person: String) -> String {
  "hello," + person + "!"
}

参数标签使代码有更强的可读性。

func someFuncation(argumentLabel parameterName: Int) -> Int {
  // parameterName 参数名称， argumentLabel 标签参数
}

// from 是参数标签，hometown是参数名称
func greet(person:String,from hometown: String){
    print(person+" from "+hometown)
}

greet(person: "wangbo", from: "haidian")

指定默认参数值，也是实现函数重载的方式。

func someFuncation(param: Int, param1: Int = 2){
  
}

// 调用
someFuncation(param: 3)
someFuncation(param: 3, param1: 3)

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)

函数的参数默认是常量，不能修改的。如果想要修改参数的值，就要把参数定义为输入输出参数（参数类型前 inout) 。并且传入的参数是个变量。

var ar = [Int]()

// 参数类型前加 inout 表示是输入输出参数，可以修改
func add(array:  inout [Int]) -> [Int] {
    for i in 1...5{
        array.append(i)
    }
    return array
}

// 调用的时候实参前面加 &，表示这个参数可以被修改
for item in add(array: &ar) {
    print(item)
}

func funcation(param: Int, param1: String) -> [Int]{
  
}

// 函数的类型
(Int,String) -> [Int]

swift 中函数式一等公民，函数类型像其他类型一样可以定义变量, 也可以作为函数返回类型。

typealias FuncationType = (Int,Int) -> Int

func some(funcation: FuncationType) -> Int{
    let a = 10, b = 100
    return funcation(a,b)
}

let sum = some { (a, b) -> Int in
    return a + b
}

函数内定义函数。

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
}

swift的闭包和OC中block，Java中Lambda一样都是用于模块之间通讯的。

{(parameters) -> returnType in
    执行体
}

例子

var names = ["a","dsf","weea","3psd"]

names.sort(by: { (s1: String, s2: String) -> Bool in
    return s1 > s2
})

for item in names {
    print(item)
}

swift 的表达式拥有更简洁的风格。

根据上下文推断类型

因为闭包是作为函数的参数传入的，可以根据参数的类型来推断闭包的类型，所以闭包的 参数类型 和 返回类型 都可以省略。

names.sort(by: { s1, s2 in return s1 < s2 })

单表达式隐式返回

names.sort(by: { s1,s2 in s1 > s2 })

参数名缩写

names.sort(by:{ $0 > $1})

运算符方法

names.sort(by: > )

如果将闭包表达式作为最后一个参数传递给函数，将这个闭包替换成尾随闭包的形式。

尾随闭包不用写参数标签。

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函数体部分
}

// 以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure(closure: {
    // 闭包主体部分
})

// 以下是使用尾随闭包进行函数调用
someFunctionThatTakesAClosure() {
    // 闭包主体部分
}

闭包的用途：

func f1(amount: Int) -> () -> Int{
    var total = 10
    func f2() -> Int{
        total += amount
        return total
    }
    return f2
}

let res = f1(amount: 5)
print(res())  // 15
print(res())  // 20

let res1 = f2(amount: 5)
print(res()) // 15

f1 是 f2的父函数，f2赋值给一个全局变量，f2一直在内存中，f2依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制回收。

闭包是引用类型，一个对象属性赋值给一个闭包，如果闭包直接访问了该对象或该对象的成员，就会引起循环引用。

闭包作为函数的参数，分为逃逸闭包和非逃逸闭包。默认是非逃逸闭包。逃逸闭包在闭包类型前面加上 @escaping 。

// 逃逸闭包
func sun(callBack: @escaping (String) -> Void){
    DispatchQueue
        .global()
        .asyncAfter(deadline: DispatchTime.init(uptimeNanoseconds: 1000)) {
        callBack("我逃出sun的生命周期")
    }
    print("sun 执行完毕")
}

sun { print($0) }

// 非逃逸闭包
func moon(callBack: (String) -> Void){
    print("moon 执行")
    callBack("我没有逃出moon的生命周期")
}

moon { print($0) }

var count = 10
let f = { count += 10 }

print(count)
f()
print(count)

class Person{
    let id: Int
    var name: String = "wangbo"
    // var bb: String
    // 如果没有默认初始化，就必须在init中初始化
    
    // 延迟加载存储属性，第一次调用时才初始值,延迟属性必须是var
    lazy var array = Array(repeating: 0, count: 3)
    
    init(id: Int) {
        self.id = id
    }
}
// 存储属性也是可以直接修改和取值的
let person = Person(id: 10)
person.name = "hh"
person.array = Array(repeating: 10, count: 3)
print(person.name)

计算属性提供一个 getter 和一个可选的 setter方法。来间接获取或设置属性值。

计算属性其实就是 java 里的 getter 和 setter 方法

class Person{
    var age: Int{
        get{
            return self.age
        }
        set{
            self.age = newValue
        }
    }
}

let person = Person()
person.age = 10
print(person.age)

只读计算属性

class Person{
    // 只读计算属性，省略掉 get{ return 10 }
    var age : Int{
        return 10
    }
}

let person = Person()
print(person.age)

属性观察器一般为存储属性提供的，计算属性可以，但是没必要，在setter方法中就可以监听变化。

class Person{
    var name = "hh" {
        willSet{
            print("name = \(self.name) 将变为 \(newValue)")
        }
        didSet{
            print("旧的值是 \(oldValue) 当前值\(self.name)")
        }
    }
} 

let person = Person()
person.name = "www"

class Person{
    static let a: String = "hello"
}

Person.a

结构体，枚举，类都可以有方法。

特殊点：swift的类方法，可以用static修饰，也可以用class修饰。

区别：

class Person{
    static let a: String = "hello"
    
    // 实例方法
    func work(at where: String) -> Void {
        print("at \(`where`)" world)
    }
    
    // 不可以被复写的类方法
    static func sayHello(){
        print("hello")
    }
    
    // 可以被子类复写的类方法
    class func sayWorld(){
        print("world")
    }
}

class Teacher: Person{
    override class func sayWorld() {
        print("teacher say world")
    }
}

构造器没有返回值。

swift 的类，如果存储属性没有指定默认值，就必须要有构造器。

class ShoppingListItem {
    var name: String?
    var quantity = 1
    var purchased = false
}
var item = ShoppingListItem()

class Person{
    let a: Int
    var b: String
    // 指定构造器
    init(a: Int, b:String) {
        self.a = a
        self.b = b
    }
    
    // 便利构造器
    convenience init(a: Int) {
        self.init(a: a, b:"haha")
    }
}

let pe = Person(a: 10)
let p2 = Person(a: 12,b:"world")

可失败构造器一般用于结构体，表示model层数据可能失败。

构造器通过返回一个 nil 表示这是个可失败构造器。

struct Person{
    let name: String
    init?(name: String){
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

let person = Person(name: "")
// Optional
print(type(of: person))

class SomeClass {
    required init() {
        // 表明子类必须实现该构造器
    }
}

deinit(){
    // 释放资源
}

swift的类如果不指定父类，是没有父类的。不像其他语言默认继承 Object类。

子类可以继承父类的属性，方法，并重写父类的属性和方法。

class Person{
    let name: String
    init(name: String) {
        self.name = name
    }
}

class Teacher: Person{
    var age: Int
    init(name: String,age: Int) {
        self.age = age
        super.init(name: name)
    }
}

let teacher = Teacher(name: "hh", age: 29)
if teacher is Person {
    print("teacher 是Person的子类")
}

let teacher = Teacher(name: "hh", age: 29)
guard let tea = (teacher as? Person) else{
    print("转换失败")
}
print("转换成功")

as? 表示可能转换失败，返回nil。as! 表示一定能转换成功。

扩展可以在不访问一个类，结构体，枚举，源代码的基础上，给类，结构体，枚举添加一些属性，方法，实现协议等。替代之前的工具类。

extension SomeType {
  // 在这里给 SomeType 添加新的功能
}

在项目中，扩展经常用来格式化代码和实现工具类。

extension Double {
    var km: Double { return self * 1_000.0 }
    var m: Double { return self }
    var cm: Double { return self / 100.0 }
    var mm: Double { return self / 1_000.0 }
    var ft: Double { return self / 3.28084 }
}

struct Size {
    var width = 0.0, height = 0.0
}
struct Point {
    var x = 0.0, y = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
}

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

extension Int {
   func repetitions(task: () -> Void) {
       for _ in 0..

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..

extension Int {
    enum Kind {
        case negative, zero, positive
    }
    var kind: Kind {
        switch self {
        case 0:
            return .zero
        case let x where x > 0:
            return .positive
        default:
            return .negative
        }
    }
}

class Person{
    var age: Int = 0
    
    class Kind{
        var name: String?
        init?(name: String?) {
            guard let name = name else { return nil }
            self.name = name
        }
    }
}

let kind = Person.Kind(name: nil)
print(kind?.name ?? "")

open > public > interal > fileprivate > private

struct PersonInfo{
    let name: String
    var age: Int
    
    func say(word: String) -> Void {
        print(word)
    }
    
    mutating func add() -> Int {
        age = age + 1
        return age
    }
}

let person = PersonInfo(name: "haha", age: 10)

enum {
  case north
  case south
  case east
  case west
}

enum Beverage: CaseIterable {
  case coffee,tea,juice
}

for item in Beverage.allCases{
    print(item)
}

enum Type: String{
    case ALL = "all"
    case NORMAL = "normal"
}

// Int 是原始值类型，隐式原始值是递增的
enum Planet: Int {
    case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

// String 是原始值类型，隐式原始值为成员名
enum CompassPoint: String {
    case north, south, east, west
}

// rawValue属性可以访问枚举成员的原始值
print(Planet.venus.rawValue)  // 输出2
print(CompassPoint.north.rawValue)  // 输出north


// 使用原始值初始化枚举值
let planet = Planet(rawValue: 3)  // Planet.earth

// 枚举值的关联值
enum BarCode{
    case upc(Int, Int,Int,Int)
    case qrCode(String)
}

let productCode = BarCode.upc(1, 23, 39, 219)
let productCode1 = BarCode.upc(3, 8, 9, 78)

switch productCode {
case let .upc(x,y,z,q):
    print("x= \(x), y = \(y) ,z = \(z) ,q = \(q)")
default:
    print("默认值")
}

protocol SomeProtocol{
    var name: String {get set}
    static var here: String { get }
}

class Person: SomeProtocol{
    var name: String
    
    static var here: String = "person"
    
    init(name: String) {
        self.name = name
    }
}

let person = Person(name: "hh")
print(person.name)
person.name = "ww"
print(Person.here)

protocol SomeProtocol{
    // 值类型修改属性的方法必须是 mutating修饰
    mutating func changeName() -> String
}

class Person: SomeProtocol{
    func changeName() -> String {
        return "hehe"
    }
}

struct Man: SomeProtocol{
    var name: String
    mutating func changeName() -> String {
        name = "hhh"
        return name
    }
}

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
    print("Happy birthday, \(celebrator.name), you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(to: birthdayPerson)

protocol SomeProtocol{
    // 普通方法
    func add(age: Int) -> Int
    // 属性
    var age: Int{get set}
    // 构造器
    init(age: Int)
}

// 协议扩展
extension SomeProtocol{
    // 实现计算属性
    var name: String {
        return "hhh"
    }
    
    // 实现方法
    func work(here: String) -> String {
        return "我在 \(here) 工作"
    }
}

// 协议扩展实现的限定，只能由Person对象调用
extension SomeProtocol where self: Person{
    func sleep(time: String){
        print("睡觉)
    }
}

class Person: SomeProtocol{
    func add(age: Int) -> Int {
        self.age = self.age + age
        return self.age
    }
    
    var age: Int
    
    required init(age: Int) {
        self.age = age
    }
}

let person = Person(age: 10)
person.add(age: 10)
person.work(here: "北京")

struct Stack{
    var items:[T] = [T]()
    
    var count: Int{
        return items.count
    }
    
    mutating func push(item: T) {
        items.append(item)
    }
    
    mutating func push(items: [T]){
        for item in items {
            self.items.append(item)
        }
    }
    
    mutating func pop() -> T? {
        return items.popLast() ?? nil
    }
}

var stack = Stack()
stack.push(item: 1)
stack.push(items:[2,3,4,5])
stack.count

typealias StringDictionary = Dictionary
typealias DictionaryOfStrings = Dictionary
typealias IntFunction = (T) -> Int
typealias Vec3 = (T, T, T)

protocol SomeProtocol {
    associatedtype T
}

enum VendingMachineError: Error {
    case invalidSelection                     //选择无效
    case insufficientFunds(coinsNeeded: Int) //金额不足
    case outOfStock                             //缺货
}

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch {
    statements
}

func someThrowingFunction() throws -> Int {
    // ...
}

let y: Int?
do {
    y = try someThrowingFunction()
} catch {
    y = nil
}

// x 是个可选类型，效果和上面一样，try？是个简洁的语法
let x = try? someThrowingFunction()

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")

func canThrowErrors() throws -> String

func canThrowErrors() throws

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { print("\(name) is being deinitialized") }
}

class Apartment {
    let unit: String
    init(unit: String) { self.unit = unit }
    weak var tenant: Person?
    deinit { print("Apartment \(unit) is being deinitialized") }
}

class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
    deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
    let number: UInt64
    unowned let customer: Customer
    init(number: UInt64, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card #\(number) is being deinitialized") }
}

lazy var someClosure = {
    // 捕获列表
    [unowned self, weak delegate = self.delegate] 
    (success, errorCode, errorMsg)
    in
    // 这里是闭包的函数体
}