“??”操作符可以判断输入并在当左侧的值是非 nil 的 Optional 值时返回其 value，当左侧是 nil 时返回右侧的值.
例：
var level: Int?
var startLevel = var currentLevel = level ?? startLevel
//currentLevel等于默认值1
Swift 中 Selector 只能使用字符串在生成,这样难以重构，并且无法在编译期间进行检查,可以利用柯里化进行封装改造。
代码如下：
protocol TargetAction {
func performAction()
}
struct TargetActionWrapper<T:AnyObject>: TargetAction {
weak var target: T?
let action: (T) -> () -> ()
func performAction() {
if let t = target {
action(t)()
}
}
}
enum ControlEvent {
case TouchUpInside
case ValueChanged
}
class Control {
var actions = [ControlEvent: TargetAction]()
func setTarget<T:AnyObject>(target: T, action: (T) -> () -> (), controlEvent: ControlEvent) {
actions[controlEvent] = TargetActionWrapper(target: target, action: action)
}
func removeTargetForControlEvent(controlEvent: ControlEvent) {
actions[controlEvent] = nil
}
func performActionForControlEvent(controlEvent: ControlEvent) {
actions[controlEvent]?.performAction()
}
}
写一个可变参数的函数只需要在声明参数时在类型后面加上 “…”, 在同一个方法中只能有一个参数是可变的，可变参数都必须是同一种类型.
例：
“func sum(input: Int...) -> Int {
return input.reduce(, combine: +)
}
print(sum(,,,,))
// 输出：15”
如果有一个类型 Class 同时实现了 A 和 B接口（Protocol），为了避免冲突，在调用前应该进行类型转换。
例：
protocol A {
func bar() -> Int
}
protocol B {
func bar() -> String
}
class Class: A, B {
func bar() -> Int {
return
}
func bar() -> String {
return "Hi"
}
}
let instance = Class()
let num = (instance as A).bar() //
let str = (instance as B).bar() // "Hi"
Swift中常用的原生容器类型有Array、Dictionary、Set，它们都是泛型的，也就是说在一个集合中只能放同一个类型的元素。(OC可以用NSArray放不同类型的元素)
Swift可以考虑使用enum封装（利用enum可以带有值的特性）
代码如下：
enum IntOrString {
case IntValue(Int)
case StringValue(String)
}
let mix = [IntOrString.IntValue(),
IntOrString.StringValue("two"),
IntOrString.IntValue()]
mix.map { (obj) -> () in
switch obj {
case let .IntValue(i):
print(i)
case let .StringValue(str):
print(str)
}
}
Lazy修饰符和map、filter这类接受闭包的方法写在一起，让整个行为变成延时进行，在不需要完全运行，可能提前退出的情况下，可以优化性能。
代码如下：
let data = ...
let result = data.lazy.map {
(i: Int) -> Int in
print("正在处理 \(i)")
return i *
} print("准备访问结果")
for i in result {
print("操作后结果为 \(i)")
} print("操作完毕") /////// 输出结果
// 准备访问结果
// 正在处理 1
// 操作后结果为 2
// 正在处理 2
// 操作后结果为 4
// 正在处理 3
// 操作后结果为 6
// 操作完毕
Swift内建类型Array和Dictionary都是值类型，也就是在传递和赋值时会进行复制，而Cocoa中的NSMutableArray和NSMutableDictionary是引用类型。因此，在需要处理大量数据并频繁操作（增减）其中元素时，选择NSMutableArray和NSMutableDictionary更好，而对于容器内条目小而容器本身数目多的情况，选择Array和Dictionary更好。
GCD实现延时调用（delay）和取消执行（cancel）
实现代码：
typealias Task = (cancel: Bool) -> Void
func delay(time: NSTimeInterval, task:()->()) -> Task? {
func dispatch_later(block:()->()) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(time*Double(NSEC_PER_SEC))), dispatch_get_main_queue(), block)
}
var closure: dispatch_block_t? = task
var result: Task?
let delayedClosure: Task = {
cancel in
if let internalClosure = closure {
if (cancel == false) {
dispatch_async(dispatch_get_main_queue(), internalClosure)
}
}
closure = nil
result = nil
}
result = delayedClosure
dispatch_later { () -> () in
if let delayedClosure = result {
delayedClosure(cancel: false)
}
}
return result
}
func cancel(task:Task?) {
task?(cancel: true)
}
调用：
let task = delay(5.0, task: { print("Do sometiong 5 seconds later") }) //延迟5秒调用task
cancel(task) //取消执行task
Swift中如果想对属性进行KVO观察，需要添加dynamic关键字，如果无法修改源码，需要重载相关类。比起改写，更推荐使用swift第三方框架Observable-Swift
“class MyClass: NSObject {
var date = NSDate()
}
class MyChildClass: MyClass {
dynamic override var date: NSDate {
get { return super.date }
set { super.date = newValue }
}
}”
Swift实现Associated Object为已有类型添加属性
“class MyClass: NSObject {
var date = NSDate()
}
class MyChildClass: MyClass {
dynamic override var date: NSDate {
get { return super.date }
set { super.date = newValue }
}
}”
测试：
func printTitle(input: MyClass) {
if let title = input.title {
print("Title:\(title)")
}
else {
print("NO Title")
}
}
let c = MyClass()
printTitle(c)
c.title = "I'm title"
printTitle(c)
摘录来自: 王巍 (onevcat). “Swifter - 100 个 Swift 必备 Tips (第二版)”。 iBooks.