Swift语法 -- [23 - 从OC到 Swift]

1. MARK、TODO、FIXME

• // MARK: 类似于OC中的 #pragma mark
• // MARK: - 类似于OC中的 #pragma mark -
• // TODO: 用于标记未完成的任务
• // FIXME: 用于标记待修复的问题

2. 条件编译

// 操作系统：macOS\iOS\tvOS\watchOS\Linux\Android\Windows\FreeBSD
#if os(macOS) || os(iOS)
// CPU架构：i386\x86_64\arm\arm64
#elseif arch(x86_64) || arch(arm64)
// swift版本
#elseif swift(<5) && swift(>=3)
// 模拟器
#elseif targetEnvironment(simulator)
// 可以导入某模块
#elseif canImport(Foundation)
#else
#endif


// debug模式
#if DEBUG

// release模式
#else

#endif

/* 可自定义: 需要在BuildSetting-->Swift Compiler - Custom Flags--> Active Compilation Conditions --> Debug 中添加例如"Test"就可以使用下面 */
#if TEST
print("test")
#endif
#if OTHER
print("other")
#endif

3. 打印

func log(_ msg: T,
            file: NSString = #file,
            line: Int = #line,
            fn: String = #function) {
    #if DEBUG
    let prefix = "\(file.lastPathComponent)_\(line)_\(fn):"
    print(prefix, msg)
    #endif
}

4. 系统版本检测

if #available(iOS 10, macOS 10.12, *) {
    // 对于iOS平台，只在iOS10及以上版本执行
    // 对于macOS平台，只在macOS 10.12及以上版本执行 // 最后的*表示在其他所有平台都执行
}

5. API可用性说明

@available(iOS 10, macOS 10.15, *)
class Person {}
struct Student {
    @available(*, unavailable, renamed: "study")
    func study_() {}
    func study() {}
    @available(iOS, deprecated: 11)
    @available(macOS, deprecated: 10.12)
    func run() {}
}

// 更多用法参考:https://docs.swift.org/swift-book/ReferenceManual/Attributes.html

6. iOS程序的入口

在AppDelegate上面默认有个@UIApplicationMain标记，这表示

• 编译器自动生成入口代码(main函数代码)，自动设置AppDelegate为APP的代理

也可以删掉@UIApplicationMain，自定义入口代码:新建一个main.swift文件

image

7. Swift调用OC

• 新建1个桥接头文件，文件名格式默认为:{targetName}-Bridging-Header.h
• 在{targetName}-Bridging-Header.h 文件中#import OC需要暴露给Swift的内容

Swift调用OC – @_silgen_name
如果C语言暴露给Swift的函数名跟Swift中的其他函数名冲突了
可以在Swift中使用 @_silgen_name 修改C函数名

 // C语言
int sum(int a, int b) {
    return a + b; 
}

 // Swift
@_silgen_name("sum") func swift_sum(_ v1: Int32, _ v2: Int32) -> Int32
print(swift_sum(10, 20)) // 30
print(sum(10, 20)) // 30

8 . OC调用Swift

Xcode已经默认生成一个用于OC调用Swift的头文件，文件名格式是: {targetName}-Swift.h

• Swift暴露给OC的类最终继承自NSObject
• 使用@objc修饰需要暴露给OC的成员
• 使用@objcMembers修饰类
  • 代表默认所有成员都会暴露给OC(包括扩展中定义的成员)
  • 最终是否成功暴露，还需要考虑成员自身的访问级别
• 可以通过@objc 重命名Swift暴露给OC的符号名(类名、属性名、函数名等)

9. 选择器(Selector)

Swift中依然可以使用选择器，使用#selector(name)定义一个选择器
必须是被@objcMembers或@objc修饰的方法才可以定义选择器

@objcMembers class Person: NSObject {
    func test1(v1: Int) { print("test1") }
    func test2(v1: Int, v2: Int) { print("test2(v1:v2:)") }
    func test2(_ v1: Double, _ v2: Double) { print("test2(_:_:)") }
    func run() {
        perform(#selector(test1))
        perform(#selector(test1(v1:)))
        perform(#selector(test2(v1:v2:)))
        perform(#selector(test2(_:_:)))
        perform(#selector(test2 as (Double, Double) -> Void))
    }
}

10. String

Swift的字符串类型String，跟OC的NSString，在API设计上还是有较大差异

// String创建方式
var emptyString = ""
var emptyString1 = String()

// 拼接
var str = ""

// 方式1.拼接字符
str.append("H")
// 方式2.拼接字符串
str.append("ello")
// 方式3 + 拼接
str  += "world!"
// 方式4: 插值表达式
str = "\(str) ,Welcome to Swift"

// 字符串长度
print(str.count)

var str = "123456"
// 前缀
print(str.hasPrefix("123"))
// 后缀
print(str.hasSuffix("456"))

字符串插入与删除

var str = "1_2"
// 1_2_
str.insert("_", at: str.endIndex)
// 1_2_3_4
str.insert(contentsOf: "3_4", at: str.endIndex)
// 1666_2_3_4
str.insert(contentsOf: "666", at: str.index(after: str.startIndex))
// 1666_2_3_8884
str.insert(contentsOf: "888", at: str.index(before: str.endIndex))
// 1666hello_2_3_8884
str.insert(contentsOf: "hello", at: str.index(str.startIndex, offsetBy: 4))

// 666hello_2_3_8884
str.remove(at: str.firstIndex(of: "1")!)
// hello_2_3_8884
str.removeAll { $0 == "6" }
var range = str.index(str.endIndex, offsetBy: -4)..

Substring

String可以通过下标、 prefix、 suffix等截取子串，子串类型不是String，而是Substring

var str = "1_2_3_4_5"
// 1_2
var substr1 = str.prefix(3)
// 4_5
var substr2 = str.suffix(3)
// 1_2
var range = str.startIndex.. String
var str2 = String(substr3)

String 与 Character

for c in "jack" { 
    // c是Character类型 
    print(c)
}
var str = "jack"
// c是Character类型
var c = str[str.startIndex]

String相关的协议

BidirectionalCollection 协议包含的部分内容

• startIndex 、 endIndex 属性、index 方法
• String、Array 都遵守了这个协议

RangeReplaceableCollection 协议包含的部分内容

• append、insert、remove 方法
• String、Array 都遵守了这个协议

Dictionary、Set 也有实现上述协议中声明的一些方法，只是并没有遵守上述协议

多行String

let str = """ 1
"2" 3
'4' """

String 与 NSString

String 与 NSString 之间可以随时随地桥接转换

• 如果你觉得String的API过于复杂难用，可以考虑将String转为NSString

var str1: String = "jack"
var str2: NSString = "rose"
var str3 = str1 as NSString
var str4 = str2 as String
// ja
var str5 = str3.substring(with: NSRange(location: 0, length: 2)) print(str5)

11. Swift、OC桥接转换表

12. 只能被class继承的协议

被@objc 修饰的协议，还可以暴露给OC去遵守实现

protocol Runnable1: AnyObject {}
protocol Runnable2: class {}
@objc protocol Runnable3 {}

13. 可选协议

可以通过@objc 定义可选协议，这种协议只能被class 遵守

 @objc protocol Runnable {
    func run1()
    @objc optional func run2()
func run3() }
class Dog: Runnable {
    func run3() { print("Dog run3") }
    func run1() { print("Dog run1") }
}
var d = Dog()
d.run1() // Dog run1
d.run3() // Dog run3

14. dynamic

被 @objc dynamic 修饰的内容会具有动态性，比如调用方法会走runtime那一套流程

 class Dog: NSObject {
    @objc dynamic func test1() {}
    func test2() {}
}
var d = Dog()
d.test1()
d.test2()

15. KVC\KVO

Swift 支持 KVC \ KVO 的条件

• 属性所在的类、监听器最终继承自 NSObject
• 用 @objc dynamic 修饰对应的属性

 class Observer: NSObject {
override func observeValue(forKeyPath keyPath: String?,
                               of object: Any?,
                               change: [NSKeyValueChangeKey : Any]?,
                               context: UnsafeMutableRawPointer?) {
print("observeValue", change?[.newKey] as Any) }
}

class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observer: Observer = Observer()
    override init() {
        super.init()
        self.addObserver(observer,
                         forKeyPath: "age",
                         options: .new,
                         context: nil)
}
deinit {
        self.removeObserver(observer,
                            forKeyPath: "age")
} }
var p = Person()
// observeValue Optional(20)
p.age = 20
// observeValue Optional(25)
p.setValue(25, forKey: "age")

16. block方式的KVO

 class Person: NSObject {
    @objc dynamic var age: Int = 0
    var observation: NSKeyValueObservation?
    override init() {
        super.init()
        observation = observe(\Person.age, options: .new) {
            (person, change) in
            print(change.newValue as Any)
        }
} }
var p = Person()
// Optional(20)
p.age = 20
// Optional(25)
p.setValue(25, forKey: "age")

17. 关联对象(Associated Object)

• 在Swift中，class依然可以使用关联对象
• 默认情况，extension不可以增加存储属性
• 借助关联对象，可以实现类似extension为class增加存储属性的效果

class Person {}
extension Person {
private static var AGE_KEY: Void? var age: Int {
get {
(objc_getAssociatedObject(self, &Self.AGE_KEY) as? Int) ?? 0
} set {
objc_setAssociatedObject(self, &Self.AGE_KEY,
} }
}

18. 资源名管理

这种做法实际上是参考了Android的资源名管理方式

let img = UIImage(named: "logo") 
let btn = UIButton(type: .custom)
btn.setTitle("添加", for: .normal) 
performSegue(withIdentifier: "login_main", sender: self)

let img = UIImage(R.image.logo) 
let btn = UIButton(type: .custom)
btn.setTitle(R.string.add, for: .normal)
performSegue(withIdentifier: R.segue.login_main, sender: self) 

enum R {
    enum string: String {
        case add = "添加"
    }
    enum image: String {
        case logo
    }
    enum segue: String {
        case login_main
    }
}

extension UIImage {
    convenience init?(_ name: R.image) {
        self.init(named: name.rawValue) }
}
extension UIViewController {
    func performSegue(withIdentifier identifier: R.segue, sender: Any?) {
        performSegue(withIdentifier: identifier.rawValue, sender: sender) }
}
extension UIButton {
    func setTitle(_ title: R.string, for state: UIControl.State) {
        setTitle(title.rawValue, for: state) }
}

19. 资源名管理的其他思路

更多优秀的思路参考
https://github.com/mac-cain13/R.swift
https://github.com/SwiftGen/SwiftGen

20. 多线程开发 – 异步

class Asyncs: NSObject {

    public typealias Task = () -> Void

    public static func async( task: @escaping Task){
        _async(task)
    }

    public static func async(_ task: @escaping Task , _ mainTask: @escaping Task){
        _async(task ,mainTask)
    }

    private static func _async(_ task: @escaping Task,
                               _ mainTask: Task? = nil) {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().async(execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
    }

    @discardableResult
    public static func delay(_ seconds: Double,
                             _ block: @escaping Task) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: block)
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + seconds,
                                      execute: item)
        return item
    }

    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task) -> DispatchWorkItem {
        return _asyncDelay(seconds, task)
    }
    @discardableResult
    public static func asyncDelay(_ seconds: Double,
                                  _ task: @escaping Task,
                                  _ mainTask: @escaping Task) -> DispatchWorkItem { return _asyncDelay(seconds, task, mainTask)
    }
    private static func _asyncDelay(_ seconds: Double,
                                    _ task: @escaping Task,
                                    _ mainTask: Task? = nil) -> DispatchWorkItem {
        let item = DispatchWorkItem(block: task)
        DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + seconds, execute: item)
        if let main = mainTask {
            item.notify(queue: DispatchQueue.main, execute: main)
        }
        return item
    }
}

21. 多线程开发 – once

dispatch_once在Swift中已被废弃，取而代之

• 可以用类型属性或者全局变量\常量
• 默认自带 lazy + dispatch_once 效果

class Singleton {    
    static let sharedInstance = Singleton()
    private init(){
        print("init")
    }
}

22. 多线程开发 – 加锁

//gcd信号量
class Cache {
    private static var data = [String: Any]()
    private static var lock = DispatchSemaphore(value: 1) 
    static func set(_ key: String, _ value: Any) {
        lock.wait()
        defer { lock.signal() }
        data[key] = value
    }
}

// Foundation
private static var lock = NSLock()
static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}

private static var lock = NSRecursiveLock() 
static func set(_ key: String, _ value: Any) {
    lock.lock()
    defer { lock.unlock() }
}

23. Array的常见操作

var arr = [1, 2, 3, 4]

// [2, 4, 6, 8]
var arr2 = arr.map { $0 * 2 }

// [2, 4]
var arr3 = arr.filter { $0 % 2 == 0 }

// 10
// $0 上一次遍历返回的结果(初始值是0)
// $1 每次遍历到的数组元素
var arr4 = arr.reduce(0) { $0 + $1 }//设置初始值为0

// 10
var arr5 = arr.reduce(0, +)


func double(_ i: Int) -> Int { i * 2 } 
var arr = [1, 2, 3, 4]
// [2, 4, 6, 8]
print(arr.map(double))


/* 
var arr = Array.init(repeating: 4, count: 5)
print(arr) //[4, 4, 4, 4, 4]
*/
var arr = [1, 2, 3]
// [[1], [2, 2], [3, 3, 3]]
var arr2 = arr.map { Array.init(repeating: $0, count: $0) }
// [1, 2, 2, 3, 3, 3]
var arr3 = arr.flatMap { Array.init(repeating: $0, count: $0) }
/*flatMap会将里面的元素平铺出来,要求返回数组*/


var arr = ["123", "test", "jack", "-30"]
// [Optional(123), nil, nil, Optional(-30)]
var arr2 = arr.map { Int($0) }
// [123, -30]
func double(_ i: Int) -> Int { i * 2 } var arr3 = arr.compactMap { Int($0) }


// 使用reduce实现map、filter的功能
var arr = [1, 2, 3, 4]
// [2, 4, 6, 8]
print(arr.map { $0 * 2 })
print(arr.reduce([]) { $0 + [$1 * 2] })
// [2, 4]
print(arr.filter { $0 % 2 == 0 })
print(arr.reduce([]) { $1 % 2 == 0 ? $0 + [$1] : $0 })

24. lazy的优化

let arr = [1, 2, 3]
let result = arr.lazy.map {
    (i: Int) -> Int in
    print("mapping \(i)")
    return i * 2
}
print("begin-----")
print("mapped", result[0])//用到这个的时候才会映射
print("mapped", result[1])
print("mapped", result[2])
print("end----")
/*打印结果:
begin-----
mapping 1
mapped 2
mapping 2
mapped 4
mapping 3
mapped 6
end----
*/

25. 可选类型Optional的map和flatMap

var num1: Int? = 10
// Optional(20)
var num2 = num1.map { $0 * 2 }//如果num1有值,会将num1先解包传入进行操作, map会将值再包装一层返回出去
var num3: Int? = nil
// nil
var num4 = num3.map { $0 * 2 }//有值才会执行里面代码, 否则直接返回nil


var num1: Int? = 10
// Optional(Optional(20))
var num2 = num1.map { Optional.some($0 * 2) }
// Optional(20)
var num3 = num1.flatMap { Optional.some($0 * 2) }//如果发现你里面本身就是可选类型,flatMap就不会再包装一层


var num1: Int? = 10
var num2 = (num1 != nil) ? (num1! + 10) : nil
var num3 = num1.map { $0 + 10 }
// num2、num3是等价的


var fmt = DateFormatter()
fmt.dateFormat = "yyyy-MM-dd"
var str: String? = "2011-09-10"
// old
var date1 = str != nil ? fmt.date(from: str!) : nil
// new
// var date1 = str.flatMap { fmt.date(from:$0) }//flatMap是传入一个函数,如果str有值的话, 它会将str的值传给这个函数, 现在由于这个函数是个闭包表达式, 所以传给函数的东西变成了$0,再执行函数,返回date
var date2 = str.flatMap(fmt.date)//现在直接将fmt.date这个函数传进去,那就代表会将str进行解包,解包之后直接传给fmt.date


var score: Int? = 98
// old
var str1 = score != nil ? "socre is \(score!)" : "No score"
// new
var str2 = score.map { "score is \($0)" } ?? "No score"


/* 根据person的名称找到person实例 */
struct Person {
        var name: String
        var age: Int
}
var items = [
        Person(name: "jack", age: 20),
        Person(name: "rose", age: 21),
        Person(name: "kate", age: 22)
]
/*查找数组索引:
  var items = [11, 22, 33]
  let index = items.firstIndex { $0 == 22 }
  print(index)
*/
// old
func getPerson1(_ name: String) -> Person? {
        let index = items.firstIndex { $0.name == name }
        return index != nil ? items[index!] : nil
}
// new
func getPerson2(_ name: String) -> Person? {
        return items.firstIndex { $0.name == name }.map { items[$0] }
}


/*字典转Person模型*/
struct Person {
    var name: String
    var age: Int
    init?(_ json: [String : Any]) {
        guard let name = json["name"] as? String,
                    let age = json["age"] as? Int else {
                return nil
        }
        self.name = name
        self.age = age
    }
}
var json: Dictionary? = ["name" : "Jack", "age" : 10]
// old
var p1 = json != nil ? Person(json!) : nil
// new
var p2 = json.flatMap(Person.init)