Swift-创建单例的三种方式
Swift-创建单例的三种方式
class NetWork {
var value:Double = 0
使用GCD创建单例
- returns: 返回NetWork单例
class func shareInstance() -& NetWork {
struct once{
static var onceToken:dispatch_once_t = 0
static var g_Instance:NetWork! = nil
dispatch_once(&once.onceToken) {
once.g_Instance = NetWork()
return once.g_Instance
使用结构体创建单例
- returns: 返回NetWork单例
class func shareInstance2() -& NetWork {
struct single{
static var g_Instance2 = NetWork()
return single.g_Instance2
/// 使用全局变量创建单例
static let shareInstance3 = NetWork()
&span style=&white-space:pre&& &/span&let net1 = NetWork.shareInstance()
net1.value = 100
let net2 = NetWork.shareInstance()
print(net2.value)
let net11 = NetWork.shareInstance2()
net11.value = 200
let net22 = NetWork.shareInstance2()
print(net22.value)
let net111 = NetWork.shareInstance3
net111.value = 300
let net222 = NetWork.shareInstance3
print(net222.value)
我的热门文章
即使是一小步也想与你分享3044人阅读
Swift（21）
常见的有这么几种方法
第一种简单到爆的
final class Single: NSObject {
static let shared = Single()
private override init() {}
final关键字的作用是这个类或方法不希望被继承和重写
public extension DispatchQueue {
private static var onceToken = [String]()
public class func once(_ token: String, _ block:@escaping () -& Void) {
objc_sync_enter(self)
objc_sync_exit(self)
if onceToken.contains(token) {
onceToken.append(token)
final class Single2: NSObject {
static func shared() -& Single2 {
struct Singleton {
static var single = Single2()
DispatchQueue.once(&YouShaoduo&) {
Singleton.single = shared()
return Singleton.single
第二种完全是OC风格的单例，但是由于Swift3中废弃了原来的dispatch_once_t，所以需要先给DispatchQueue添加一个extension，实现原先的dispatch_once_t效果
private let single = Single3()
final class Single3: NSObject {
static var shared: Single3 {
return single
由于Swift3中加强了权限控制，导致如果重写private override init()方法会报错，所以这种写法在Swift3中的安全性未知。
final class Single4: NSObject {
static var shared: Single4 {
struct Static {
static let instance: Single4 = Single4()
return Static.instance
private override init() {}
在方法内定义静态变量
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：124671次
积分：2308
积分：2308
排名：第14143名
原创：96篇
转载：10篇
评论：68条
(19)(6)(16)(8)(27)(9)(2)(11)(6)(3)Swift3.0 闭包整理
招聘信息：
语法表达式一般形式：{
&&&&&&&&&&&&(parameters)&->&returnType&in
&&&&&&&&&&&&&statements
&&&&&&&&&&&}这里的参数(parameters)，可以是in-out(输入输出参数)，但不能设定默认值。如果是可变参数，必须放在最后一位，不然编译器报错。元组也可以作为参数或者返回值。"in"关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。即由in引入函数例子//一般形式
let&calAdd:(Int,Int)->(Int)&=&{
&&&&(a:Int,b:Int)&->&Int&in
&&&&return&a&+&b
print(calAdd(100,150))
//Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
let&calAdd2:(Int,Int)->(Int)&=&{
&&&&a,b&in&&//也可以写成(a,b)&in
&&&&return&a&+&b
print(calAdd2(150,100))
//上面省略了返回箭头和参数及返回值类型，以及参数周围的括号。当然你也可以加括号，为了好看点，看的清楚点。(a,b)
//单行表达式闭包可以隐式返回，如下，省略return
let&calAdd3:(Int,Int)->(Int)&=&{(a,b)&in&a&+&b}
print(calAdd3(50,200))
//如果闭包没有参数，可以直接省略“in”
let&calAdd4:()->Int&=&{return&100&+&150}
print("....\(calAdd4())")
//这个写法，我随便写的。打印出“我是250”
//这个是既没有参数也没返回值，所以把return和in都省略了
let&calAdd5:()->Void&=&{print("我是250")}
calAdd5()归纳闭包类型是由参数类型和返回值类型决定，和函数是一样的。比如上面前三种写法的闭包的闭包类型就是(Int,Int)->(Int),后面的类型分别是()->Int和()->Void。分析下上面的代码：let calAdd：(add类型)。这里的add类型就是闭包类型 (Int,Int)->(Int)。意思就是声明一个calAdd常量，其类型是个闭包类型。"="右边是一个代码块，即闭包的具体实现，相当于给左边的add常量赋值。兄弟们，是不是感觉很熟悉了，有点像OC中的block代码块。起别名也可以关键字“typealias”先声明一个闭包数据类型。类似于OC中的typedef起别名typealias&AddBlock&=&(Int,&Int)&->&(Int)
let&Add:AddBlock&=&{
&&&&(c,d)&in
&&&&return&c&+&d
let&Result&=&Add(100,150)
print("Result&=&\(Result)")尾随闭包若将闭包作为函数最后一个参数，可以省略参数标签,然后将闭包表达式写在函数调用括号后面func&testFunction(testBlock:&()->Void){
&&&&//这里需要传进来的闭包类型是无参数和无返回值的
&&&&testBlock()
//正常写法
testFunction(testBlock:&{
&&&&print("正常写法")
//尾随闭包写法
testFunction(){
&&&&print("尾随闭包写法")
//也可以把括号去掉，也是尾随闭包写法。推荐写法
testFunction&{&
&&&&print("去掉括号的尾随闭包写法")
}值捕获闭包可以在其被定义的上下文中捕获常量或变量。Swift中，可以捕获值的闭包的最简单形式是嵌套函数，也就是定义在其他函数的函数体内的函数。func&captureValue(sums&amount:Int)&->&()->Int{
&&&&var&total&=&0
&&&&func&incrementer()->Int{
&&&&&&&&total&+=&amount
&&&&&&&&return&total
&&&&return&incrementer
print(captureValue(sums:&10)())
print(captureValue(sums:&10)())
print(captureValue(sums:&10)())
//打印"10&10&10"这里没有值捕获的原因是，没有去用一个常量或变量去引用函数，所以每次使用的函数都是新的。有点类似于OC中的匿名对象。let&referenceFunc&=&captureValue(sums:&10)
print(referenceFunc())
print(referenceFunc())
print(referenceFunc())
//打印"10&20&30"这里值捕获了，是因为函数被引用了，所以没有立即释放掉。所以函数体内的值可以被捕获闭包形式func&captureValue2(sums&amount:Int)&->&()->Int{
&&&&var&total&=&0
&&&&let&AddBlock:()->Int&=&{
&&&&&&&&total&+=&amount
&&&&&&&&return&total
&&&&return&AddBlock
let&testBlock&=&captureValue2(sums:&100)
print(testBlock())
print(testBlock())
print(testBlock())由上面的例子都可以证得，函数和闭包都是引用类型。逃逸闭包当一个闭包作为参数传到一个函数中，需要这个闭包在函数返回之后才被执行，我们就称该闭包从函数种逃逸。一般如果闭包在函数体内涉及到异步操作，但函数却是很快就会执行完毕并返回的，闭包必须要逃逸掉，以便异步操作的回调。逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。//例1
func&doSomething(some:&@escaping&()&->&Void){
&&&&//延时操作，注意这里的单位是秒
&&&&DispatchQueue.main.asyncAfter(deadline:&DispatchTime.now()&+&1)&{
&&&&&&&&//1秒后操作
&&&&&&&&some()
&&&&print("函数体")
doSomething&{
&&&&print("逃逸闭包")
var&comletionHandle:&()->String&=&{"约吗?"}
func&doSomething2(some:&@escaping&()->String){
&&&&comletionHandle&=&some
doSomething2&{
&&&&return&"叔叔，我们不约"
print(comletionHandle())
//将一个闭包标记为@escaping意味着你必须在闭包中显式的引用self。
//其实@escaping和self都是在提醒你，这是一个逃逸闭包，
//别误操作导致了循环引用！而非逃逸包可以隐式引用self。
//例子如下
var&completionHandlers:&[()&->&Void]&=&[]
func&someFunctionWithEscapingClosure(completionHandler:&@escaping&()&->&Void)&{
&&&&completionHandlers.append(completionHandler)
func&someFunctionWithNonescapingClosure(closure:&()&->&Void)&{
&&&&closure()
class&SomeClass&{
&&&&var&x&=&10
&&&&func&doSomething()&{
&&&&&&&&someFunctionWithEscapingClosure&{&self.x&=&100&}
&&&&&&&&someFunctionWithNonescapingClosure&{&x&=&200&}
}自动闭包顾名思义，自动闭包是一种自动创建的闭包，封装一堆表达式在自动闭包中，然后将自动闭包作为参数传给函数。而自动闭包是不接受任何参数的，但可以返回自动闭包中表达式产生的值。自动闭包让你能够延迟求值，直到调用这个闭包，闭包代码块才会被执行。说白了，就是语法简洁了，有点懒加载的意思。var&array&=&["I","have","a","apple"]
print(array.count)
//打印出"4"
let&removeBlock&=&{array.remove(at:&3)}//测试了下，这里代码超过一行，返回值失效。
print(array.count)
//打印出"4"
print("执行代码块移除\(removeBlock())")
//打印出"执行代码块移除apple"&这里自动闭包返回了apple值
print(array.count)
//打印出"3"
微信扫一扫
订阅每日移动开发及APP推广热点资讯公众号：CocoaChina
您还没有登录！请或
点击量9525点击量9425点击量8643点击量5998点击量5944点击量5663点击量5267点击量4951点击量4798
&2016 Chukong Technologies,Inc.
京公网安备89Swift3.0图文混排进阶（一）数据准备 - 简书
Swift3.0图文混排进阶（一）数据准备
基于Swift写一个小轮子，使用微博的表情素材，简单友好的生成属性文本写下此篇，记录其中的知识点
一、从磁盘加载表情数据（数据准备）
画了个记载数据的思维图，可以对照着下面的代码理一下思路：
加载bundle数据.png
1.获取自定义bundle，加载plist
创建YWEmoticonManager类，一般除了类需要做模型字典转换操作的，不然都不要继承NSObject，使用单例，因为，一般项目中，很多地方都要展示表情，这样我们就可以不用每次都需要去磁盘加载数据了，构造函数 如果在init之前增加private 修饰符，可以要求调用者必须通过 shared 访问对象， OC 要重写 allocWithZone方法，然后读取emoticons.plist，如果Bundle按照默认的结构目录设定，就可以直接读取Resourse目录文件,这样我们就拿到了plist文件：
guard let path = Bundle.main.path(forResource: "HMEmoticon", ofType: "bundle"),
let bundle = Bundle(path: path),
let plistPath = bundle.path(forResource: "emoticons", ofType: "plist"),
let array = NSArray(contentsOfFile: plistPath) as? [[String:String]] else {
2.建立数据模型
模型转化使用YYModel，所以现行导入YYModel继续接下来的操作：
建立表情模型
///表情类型 false-图片表情/true-emoji
var type = false
/// 表情字符串，发送给服务器（节约流量）
var chs: String?
/// 表情的图片名称，用于本地图文混排
var png: String?
/// emoji 16进制编码
var code: String?
override var description: String{
return yy_modelDescription()
建立表情包模型
/// 表情包的分组名
var groupName: String?
/// 表情包目录，从目录下加载info.plist 可以创建表情模型数组
var directory: String?
/// 懒加载表情模型空数组，使用懒加载可以避免后续的解包
lazy var emoticonArr = [YWEmoticon]()
override var description: String{
return yy_modelDescription()
3.加载表情包数据数组
/// 表情包懒加载数组
lazy var packageArr = [YWEmoticonPackage]()
guard let path = Bundle.main.path(forResource: "HMEmoticon", ofType: "bundle"),
let bundle = Bundle(path: path),
let plistPath = bundle.path(forResource: "emoticons", ofType: "plist"),
let array = NSArray(contentsOfFile: plistPath) as? [[String:String]],
let modelArr = NSArray.yy_modelArray(with: YWEmoticonPackage.self, json: array) as? [YWEmoticonPackage] else {
//设置表情包数组 使用 += 不会再次给packetArr 分配空间， 直接追加数据
packageArr += modelArr
4.加载表情表情模型数组
在YWEmoticonPackage模型的directory属性的didSet方法中，取出directory目录中的info.plist加载表情模型数组
/// 表情包目录，从目录下加载info.plist 可以创建表情模型数组
var directory: String?{
//当设置目录时候，从目录下加载 info.plist
guard let directory = directory,
let path = Bundle.main.path(forResource: "HMEmoticon", ofType: "bundle"),
let bundle = Bundle(path: path),
let infoPath = bundle.path(forResource: "info", ofType: "plist", inDirectory: directory),
let array = NSArray(contentsOfFile: infoPath) as? [[String: String]],
let modelArr = NSArray.yy_modelArray(with: YWEmoticon.self, json: array) as? [YWEmoticon]else {
//设置表情模型数组
emoticonArr += modelArr
5.表情模型增加目录属性，图像的计算想属性，方便获取图像
/// 表情模型所在的目录
var directory: String?
/// 图片表情对用的图像
var image:UIImage?{
//判断表情类型
return nil
guard let directory = directory,
let png = png,
let path = Bundle.main.path(forResource: "HMEmoticon", ofType: "bundle"),
let bundle = Bundle(path:path)
return nil
return UIImage(named: "\(directory)/\(png)", in: bundle, compatibleWith: nil)
6.添加表情包数组过滤表情方法
插播关于OC数组中 使用谓词过滤的数组的用法装逼解释：谓词是OC中提供了的针对数组处理，它的作用和数据库中的查询操作操作很像，我们可以通过简单的谓词语句对数组进行查找和过滤。
extension YWEmoticonManager {
/// 根据string [爱你] 在所有的表情符号中查找对应是表情模型
/// - 如果找到返回表情模型
/// - 否则 返回nil
func findEmoticon(string:String?) -& YWEmoticon? {
//遍历表情包 OC中过滤数组使用[谓词] swift
for p in packageArr {
//在表情数组中过滤 string
let result = p.emoticonArr.filter({ (em) -& Bool in
return em.chs == string
// 判断 结果数组的数量
if result.count == 1 {
return result[0]
return nil
7.扩展一下闭包的三种简写方式
//方法1.在表情数组中过滤 string
let result = p.emoticonArr.filter({ (em) -& Bool in
return em.chs == string
//方法2.尾随闭包 - 当闭包是最后一个参数，圆括号可以提前结束
let result = p.emoticonArr.filter(){ (em) -& Bool in
return em.chs == string
//方法3.如果闭包中只有一句，并且是返回，闭包格式可以省略【闭包格式 指的是 in之前的语句】，参数省略之后，使用$0,$1依次替代
let result = p.emoticonArr.filter(){
return $0.chs == string
//方法4.如果闭包中只有一句，并且是返回，闭包格式可以省略【闭包格式 指的是 in之前的语句】，参数省略之后，使用$0,$1依次替代,return也可以省略
let result = p.emoticonArr.filter(){ $0.chs == string}
8.根据当前的表情模型，生成图像的属性文本
在表情模型中，实现此方法
//根据当前的图像，生成图像的属性文本
func imageText(font:UIFont) -& NSAttributedString {
//判断图像是否存在
guard let image = image else {
return NSAttributedString(string: "")
//创建文本附件 -图像
let attachment = NSTextAttachment()
attachment.image = image
//lineHeight 大致和字体大小相等
let height = font.lineHeight
attachment.bounds = CGRect(x: 0, y: -4, width: height, height: height)
//返回图像属性文本
return NSAttributedString(attachment: attachment)
8.至此，初步的封装就做好了，我们可以测试一下
//测试直接生成表情属性文本
let emo = YWEmoticonManager.shared.findEmoticon(string: "[马到成功]")
testlabel.attributedText = emo?.imageText(font: testlabel.font);
上午12.30.02.png
最后奉上demo地址：可以关注下，会持续更新。。。
扬在脸上的自信、长在心底的善良、融进血里的骨气、刻进生命的坚强在swift中挣扎的程序员
最近在学习swift，不得不说，确实让人蛋疼的是Xcode各种闪退，看来得考略换台电脑了。。。。。
先让我吟诗几句：
朝花夕拾杯中酒，举杯消愁愁更愁
春色满园关不住，安能辨我是雄雌
话不多说，进入正题。。。。。
关于swift的单例写法有好几种，这里介绍一下其中我使用的一种单例
class HttpManager: AFHTTPRequestOperationManager {
//创建一个网络请求类的单例
class func sharedHttpManager() -& AFHTTPRequestOperationManager {
struct SingleTon {
static var onceToken : dispatch_once_t = 0
static var manager : AFHTTPRequestOperationManager?
dispatch_once(&SingleTon.onceToken) { () -& Void in
SingleTon.manager = AFHTTPRequestOperationManager(baseURL: NSURL.init(string: BaseUrl.baseUrlString))
SingleTon.manager?.responseSerializer = AFJSONResponseSerializer.init(readingOptions: NSJSONReadingOptions.MutableContainers)
SingleTon.manager?.responseSerializer.acceptableContentTypes = NSSet(array: [&application/x-javascript&,&application/json&,&text/html&,&text/javascript&,&text/plain&]) as Set&NSObject&
return SingleTon.manager!
在于dispatch_once保证代码块只执行一次，单例就这样可以使用了哈哈
我的热门文章
即使是一小步也想与你分享