swift与OC

MARK、TODO、FIXME

// MARK: 类似于OC中的 #pragma mark

// MARK: - 类似于OC中的 #pragma mark

// TODO: 用于标记未完成的任务

// FIXME: 用于标记待修复的问题

条件编译

// 操作系统：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

swift条件编译设置

// debug模式 
#if DEBUG 
// release模式 
#else 
#endif

#if TEST 
print("test") 
#endif

#if OTHER 
print("other") 
#endif

打印

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
}

系统版本检测

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

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() {}
}

iOS程序的入口

在AppDelegate上面默认有个@UIApplicationMain标记，这表示 :编译器自动生成入口代码（main函数代码），自动设置AppDelegate为APP的代理

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

main

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

OC调用Swift

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

Swift暴露给OC的类最终继承自NSObject

使用@objc修饰需要暴露给OC的成员

使用@objcMembers修饰类 :1、代表默认所有成员都会暴露给OC（包括扩展中定义的成员） 2、最终是否成功暴露，还需要考虑成员自身的访问级别

Xcode会根据Swift代码生成对应的OC声明，写入 {targetName}-Swift.h 文件

可以通过 @objc 重命名Swift暴露给OC的符号名（类名、属性名、函数名等）

Swift

@objc(MYCar) 
@objcMembers class Car: NSObject {
  var price: Double 
  @objc(name) 
  var band: String 
  init(price: Double, band: String) {
    self.price = price
    self.band = band 
  } 
  @objc(drive) 
  func run() { print(price, band, "run") } 
  static func run() { print("Car run") }
} 
extension Car {
  @objc(exec:v2:)
  func test() { 
    print(price, band, "test") 
  } 
}

OC

MYCar *c = [[MYCar alloc] initWithPrice:10.5 band:@"BMW"];
c.name = @"Bently";
c.price = 100.00;
[c drive]; // 100.00 Bently run
[c exec:10 v2:20]; // 100.00 Bently test 
[MYCar run]; // Car run
  

选择器（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))
  }
}

String

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

// 空字符串 
var emptyStr1 = "" 
var emptyStr2 = String()

var str: String = "1" 
// 拼接，
jack_rose str.append("_2") 
// 重载运算符 + 
str = str + "_3" 
// 重载运算符 
+= str += "_4" 
// \()插值 
str = "\(str)_5" 
// 长度，9，1_2_3_4_5 
print(str.count)

var str = "123456" 
print(str.hasPrefix("123")) // true 
print(str.hasSuffix("456")) // true

String的插入和删除

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)

Substring和它的base，共享字符串数据

Substring发生修改 或者 转为String时，会分配新的内存存储字符串数据

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

"""三引号表示多行

如果要显示3引号，至少转义1个引号

缩进以结尾的3引号为对齐线

String 与 NSString

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

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

比较字符串内容是否等价 : String使用 == 运算符 ; NSString使用isEqual方法，也可以使用 == 运算符（本质还是调用了isEqual方法）。

Swift、OC桥接转换表

String	⇌	NSString
String	←	NSMutableString
Array	⇌	NSArray
Array	←	NSMutableArray
Dictionary	⇌	NSDictionary
Dictionary	←	NSMutableDictionary
Set	⇌	NSSet
Set	←	NSMutableSet

只能被class继承的协议

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

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

可选协议

可以通过 @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

dynamic

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

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

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")

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")

关联对象（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, newValue, .OBJC_ASSOCIATION_ASSIGN)
    }
  }
}

var p = Person() 
print(p.age) // 0 
p.age = 10 
print(p.age) // 10

资源名管理

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) 
  } 
}

资源名管理的其他思路

let img = UIImage(named: "logo")
let font = UIFont(name: "Arial", size: 14)


let img = R.image.logo
let font = R.font.arial(14)


enum R {
  enum image { 
    static var logo = UIImage(named: "logo") 
  } 
  enum font {
    static func arial(_ size: CGFloat) -> UIFont? {
      UIFont(name: "Arial", size: size)
    } 
  }
}

多线程开发 – 异步

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
}

多线程开发 – once

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

可以用类型属性或者全局变量\常量

默认自带 lazy + dispatch_once 效果

fileprivate let initTask2: Void = { print("initTask2---------") }()

class ViewController: UIViewController { 
  static let initTask1: Void = { print("initTask1---------") }()
  override func viewDidLoad() { 
    super.viewDidLoad()
    let _ = Self.initTask1
    let _ = initTask2
  }
}

多线程开发 – 加锁

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() } 
}