Swift 开发必备 Tip

柯里化(Currying)

在Swift中可以将方法柯里化,也就是把接受多个参数的方法变换成接受第一个参数的方法
并且返回接受余下的参数,返回结果的新方法
柯里化是一种量产相似方法的好办法,可以通过可里化一个方法模板来避免写出很多重复代码,也方便了今后维护

func addTwoNumbers(a:Int)(num:Int) -> Int {
    return a + num
}

let addToFour = addTwoNumbers(4) // addToFour 是一个Int -> Int
let result = addToFour(num: 6)   // result = 10

func greaterThan(comparor:Int)(input :Int) -> Bool {
    return input > comparor
}

let greaterThan10 = greaterThan(10)  // Int->Bool
greaterThan10(input: 13)             // 结果是true
greaterThan10(input: 9)              // 结果是false

将protocol的方法声明为mutating

Swift的mutating关键字修改方法是为了能在该方法中修改struct或enum的变量,所以如果你没在接口方法里写mutating的话,别人如果用struct或者enum来实现这个接口的话，就不能在方法里改变自己的变量了

// 如如下面的代码:
protocol Vehicle {
    var numberOfWheels:Int { get }
    var color:UIColor { get set }
    
    mutating func changeColor()
}

struct myCar :Vehicle {
    let numberOfWheels = 4
    var color = UIColor.blueColor()
    
    mutating func changeColor() {
        color = UIColor.redColor()
    }
}

Sequence

Swift的for...in 可以用在所有实现了SequenceType的类型上,而为了实现SequenceType你首先需要实现一个GeneratorType.比如一个实现了反向的generator和sequence可以这么写

// 先定义一个实现了GeneratorType protocol的类型
// GeneratorType 需要指定一个typealias Element
// 以及提供一个返回Element?的方法的next()
class ReverseGenerator : GeneratorType {
    typealias Element = Int
    
    var counter :Element
    
    init(array:[T]) {
        self.counter = array.count - 1
    }
    
    init(start: Int) {
        self.counter = start
    }
    
    func next() -> Element? {
        return self.counter < 0 ?nil:counter--
    }
}

// 然后我们来定义SequenceType
// 和SequenceType很类似,不过换成指定一个typealias Generator
// 以及提供一个返回Generator?方法的generate()
struct ReverseSequence :SequenceType {
    var array: [T]
    
    init (array:[T]) {
        self.array = array
    }
    
    typealias Generator = ReverseGenerator
    
    func generate() -> Generator {
        return ReverseGenerator(array: array)
    }
}

let arr = [0,1,2,3,4]

for i in ReverseSequence(array: arr) {
    print("Index\(i) is \(arr[i])")
}

// 输出为:
// Index4 is 4
// Index3 is 3
// Index2 is 2
// Index1 is 1
// Index0 is 0

多元组(Tuple)

// 比如交换输入
func swapMe(inout a:T,inout b:T) {
    let temp = a
    a = b
    b = temp
}

var a = 05
var b = 21
swapMe(&a, b: &b)

// 使用多元组
func swapMe2(inout a:T,inout b :T) {
    (a,b) = (b,a)
}

swapMe2(&a, b: &b)

@autoclosure和??操作符

// @autoclosure
// 比如我们有一个方法接受一个闭包,当闭包执行的结果为true的时候进行打印
func logIfTrue(predicate:() ->Bool) {
    if predicate() {
        print("true")
    }
}

logIfTrue({ return 2 > 1})  // return:true
logIfTrue({ 2 > 1})         // return:true
logIfTrue{ 2 > 1 }          // 尾随闭包,return:true

func logIfTrue2(@autoclosure predicate:() ->Bool) {
    if predicate() {
        print("true")
    }
}

// 调用:
logIfTrue2(2 > 1)   // return:true
// Swift会把2 >1这个表达式自动转换为()->Bool.这样我们就得到了一个写法简单,表意清楚的式子.


// ??操作符
// 在Swift中,一个非常有用的操作符,可以用来快带地对�nil进行条件判断,那就是??.
// 这个操作符可以判断输入内容,当左侧的值是非nil的Optional值时返回其Value
// 当左侧是nil时返回右侧的值

var level :Int?
var startLevel = 1
var currentLevel = level ?? startLevel  // return:1

单例

// 写法1:
class MyManager {
    class var shareManage :MyManager {
        struct Static {
            static var onceToken :dispatch_once_t = 0
            static var staticInstance :MyManager? = nil
        }
        
        dispatch_once(&Static.onceToken) {
            Static.staticInstance = MyManager()
        }
        return Static.staticInstance!
    }
}

// 写法2:
// 更简单的保证上线程安全的方法,那就是let.
class MyManager {
    class var shareManage :MyManager {
        struct Static {
            static let shareInstance : MyManager = MyManager()
        }
        return Static.shareInstance
    }
}

// 写法3:
// 由于现在Class不支持存储式的property
// 我们想要使用一个只存在一份的属性时,就只能将其定义在全局的scope中.
// 我们可以在变量定义前面加上privagte关键字,使这个变量在当前文件中可以被访问.

private let sharedInstance = MyManager()

class MyManager {
    class var sharedManager :MyManager {
        return sharedInstance
    }
}

// 写法4: - 推荐写法
class MyManager {
    private static let sharedInstance = MyManager()
    class var sharedManager :MyManager {
        return sharedInstance
    }
}

Playground可视化

import Foundation
import UIKit
import XCPlayground

var arr_temp = [14,11,20,1,3,9,4,15,6,19,2,8,7,17,12,5,10,13,18,16]

func plot(title :String,array:[T]) {
    for value in array {
        XCPCaptureValue(title, value: value)
    }
}

plot("起始",array: arr_temp)

func swap(inout x:T,inout y:T) {
    (x,y) = (y,x)
}

func bubbleSort(inout input :[T]) {
    for var i = input.count;i > 1;i-- {
        var didSwap = false
        for var j = 0;j < i-1;j++ {
            if input[j] > input[j + 1] {
                didSwap = true
                swap(&input[j], &input[j+1])
            }
        }

        if !didSwap {
            break
        }
        plot("第\(input.count - (i-1)) 次迭代", array: input)
    
    }
    plot("结果", array: input)
}

bubbleSort(&arr_temp)

其他

• 注意 Swift 中 static 的变量是延时加载的，意味着 Instance 直到需要的时候才会被创建。同时再注意一下，因为它是一个常量，所以一旦创建之后不会再创建第二次。

使用CocoaPods导入百度地图SDK所遇到的坑

建立Podfile（配置文件）,接着上一步，终端输入 vim Podfile
esc
:wq
百度了下,发现pod install命令被墙了,换成pod install --verbose --no-repo-update搞定!