swift简单学习之单例

OC的单例写法前几篇文章已经介绍过，那在彩笔的眼里 swift的单例写法是这个样子的：

class CaiBi{

    class var share:CaiBi{
    
        struct Static{
        
            static var oneTaken:dispatch_once_t = 0
            static var instance:CaiBi? = nil
        }
        
        dispatch_once(&Static.oneTaken){
        
            Static.instance = CaiBi()
        }
        return Static.instance!
    }
}

在网上查找了资料之后发现，呵呵********了

彩笔简版：

class caiBi{

    class var share1:CaiBi{
    
        struct sta{
        
            static let insta = CaiBi()
        }
        return sta.insta
    }
}

精简版：

class TheOneAndOnlyKraken2 {
    static let sharedInstance = TheOneAndOnlyKraken2()
    private init() {}
}

class SwiftSingleton {
    class var shared: SwiftSingleton {
        dispatch_once(&Inner.token) {
            Inner.instance = SwiftSingleton()
        }
        return Inner.instance!
    }
    struct Inner {
        static var instance: SwiftSingleton?
        static var token: dispatch_once_t = 0
    }
    
}

A:class SingletonC {
    
    class var sharedInstance: SingletonC {
        struct Static {
            static var onceToken: dispatch_once_t = 0
            static var instance: SingletonC? = nil
        }
        dispatch_once(&Static.onceToken) {
            Static.instance = SingletonC()
        }
        return Static.instance!
    }
    
    private init() {
        print("CCC");
    }
    
}

B:class SingletonB {
    
    class var sharedInstance: SingletonB {
        struct Static {
            static let instance: SingletonB = SingletonB()
        }
        return Static.instance
    }
    
    private init() {
        print("BBB");
    }
    
}

C:
class SingletonA {
    
    static let sharedInstance: SingletonA = SingletonA()
    
    private init() {
        print("AAA");
    }
    
}

1、

import Foundation

class SingleOne {

    //单例
    static let shareSingleOne = SingleOne()

}

一句话搞定，静态常理。所有地方用到的都是同一个

2、

import Foundation

class SingleTwo {

    //单例
    class func shareSingleTwo()->SingleTwo{
        struct Singleton{
            static var onceToken : dispatch_once_t = 0
            static var single:SingleTwo?
        }
        dispatch_once(&Singleton.onceToken,{
            Singleton.single=shareSingleTwo()
        }
        )
        return Singleton.single!
    }

}

使用dispatch_once可以保证其中的代码只执行一次

3、

import Foundation

//全局的常量
let single = SingleThree()

class SingleThree {

    class var sharedInstance : SingleThree {
        return single
    }
}

4、

import Foundation

class SingleFour {

    static var sharedInstance : SingleFour {
        struct Static {
            static let instance : SingleFour = SingleFour()
        }
        return Static.instance
    }
}

在方法内定义静态常量