发布于 2018-02-26 07:57:50 | 21 次阅读 | 评论: 0 | 来源: 网友投递

这里有新鲜出炉的Swift教程,程序狗速度看过来!

Swift编程语言

SWIFT,苹果于2014年WWDC(苹果开发者大会)发布的新开发语言,可与Objective-C*共同运行于Mac OS和iOS平台,用于搭建基于苹果平台的应用程序。


本篇文章主要介绍了Swift中如何避免循环引用的方法,小编胜博发手机官网挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

内存管理中经常会遇到的一个问题便是循环引用。首先,我们来了解一下iOS是如何进行内存管理的。

和OC一样,swift也是使用自动引用计数ARC(Auto Reference Counteting)来自动管理内存的,所以我们不需要过多考虑内存管理.当某个类实例不需要用到的时候,ARC会自动释放其占用的内存.

ARC

ARC(Automatic Reference Counting) 是苹果的自动内存管理机制。正如其名:自动引用计数,根据引用计数来决定内存块是否应该被释放。

当一个对象被创建的时候,它的引用计数为1。在它的生命周期内,其引用计数可以增加或减少。当它的引用计数减为0的时候,其所占用内存便会被释放。其生命周期如图所示:


强引用和弱引用(Strong/Weak References)

定义一个变量的时候可以声明其strong和weak属性,默认是strong类型。


struct Example {
 var strongView = UIView()
 weak var weakView = UIView()
}

强引用和弱引用有什么不同呢?

强引用会使变量的引用计数加1。如果一个对象的引用计数为2,当它再次被强引用的时候,它的引用计数会变为3。

弱引用不会增加引用计数。如果一个对象的引用计数为2,当它再次被弱引用的时候,它的引用计数仍为2。

强引用的对象能保证其被调用的时候仍在内存中,而弱引用不行。

循环引用和内存泄漏

当A引用B中的成员变量,而B又对A中的成员变量有引用的时候就会发生循环引用。
比如:


class Book {
 private var pages = [Page]()
 func add(_ page : Page) {
  pages.append(page)
 }
}
class Page {
 private var book : Book
 required init(book : Book) {
  self.book = book
 }
}
let book = Book()
let page = Page(book: book)
book.add(page)

此时,book对page有强引用,同时page对book也有强引用。这个时候便有循环引用,会导致内存泄漏。

对于这种两个变量的相互强引用导致的内存泄漏该如何解决呢?

Structs 和 Classes

正确的使用struct 和 class能避免循环引用的发生。

struct 和 class 都有成员变量,函数和协议。那么,它们之间有什么区别呢?

struct 是 值类型。
class 是 引用类型。

当引用或者传递 值类型 变量的时候,它会在内存中重新分配地址,copy内容到新的地址中。


struct Element {
 var name : String
 var number : Int
}
var firstElement = Element(name: "A", number: 1)
var secondElement = firstElement
secondElement.name = "B"
secondElement.number = 2
print(firstElement)
print(secondElement)

输出的结果为:


Element(name: “A”, number: 1)
Element(name: “B”, number: 2)

当引用或者传递 引用类型 变量的时候,新的变量指针指向的仍是原先的内存地址。此时原先的变量值改变的话,也会导致新变量值的变化。

比如:


class Element {
 var name : String
 var number : Int
 required init(name : String, number : Int) {
  self.name = name
  self.number = number
 }
}
extension Element : CustomStringConvertible {
 var description : String {
  return "Element(name: \(name), number: \(number))"
 }
}
var firstElement = Element(name: "A", number: 1)
var secondElement = firstElement
secondElement.name = "B"
secondElement.number = 2
print(firstElement)
print(secondElement)

此时的输出结果为:


Element(name: B, number: 2)
Element(name: B, number: 2)

我们为什么在此讨论值类型和引用类型呢?

回到之前book和pages的例子。我们用struct代替class:


struct Book {
 private var pages = [Page]()
 mutating func add(_ page : Page) {
  pages.append(page)
 }
}
struct Page {
 private var book : Book
 init(book : Book) {
  self.book = book
 }
}
var book = Book()
let page = Page(book: book)
book.add(page)

此时,便不会发生循环引用的情况。

如果仍想使用class的话,可以使用weak来避免循环引用:


class Book {
 private var pages = [Page]()
 func add(_ page : Page) {
  pages.append(page)
 }
}
class Page {
 private weak var book : Book?
 required init(book : Book) {
  self.book = book
 }
}
let book = Book()
let page = Page(book: book)
book.add(page)

Protocols

Protocols在swift中使用的很广泛。class,struct 和 enum 都可以使用Protocol。但是如果使用不当的话,同样会引起循环引用。

比如:


protocol ListViewControllerDelegate {
 func configure(with list : [Any])
}
class ListViewController : UIViewController {
 var delegate : ListViewControllerDelegate?
 override func viewDidLoad() {
  super.viewDidLoad()
 }
}

ListViewController 中的delegate变量是strong类型的,可以引用任何实现它protocol的变量。假如实现其protocol的变量对该 view controller 同样有强引用的话会怎么样? 声明delegate为weak可能会避免这种情况,但是这样的话会引起编译错误,因为structs和enums不能引用weak变量。

该如何解决呢?当声明protocol的时候,我们可以指定只有class类型的变量可以代理它,这样的话就可以使用weak来修饰了。


protocol ListViewControllerDelegate : class {
 func configure(with list : [Any])
}
class ListViewController : UIViewController {
 weak var delegate : ListViewControllerDelegate?
 override func viewDidLoad() {
  super.viewDidLoad()
 }
}

Closures

Closures 导致循环引用的原因是:Closures对使用它们的对象有一个强引用。

比如:


class Example {
 private var counter = 0
 private var closure : (() -> ()) = { }
 init() {
  closure = {
   self.counter += 1
   print(self.counter)
  }
 }
 func foo() {
  closure()
 }
}

此时,对象对closure有一个强引用,同时在closure的代码块中又对该对象本身有一个强引用。这样就引起了循环引用的发生。

这种情况,可以有两种方法来解决这个问题。

1.使用[unowned self]:


class Example {
 private var counter = 1
 private var closure : (() -> ()) = { }
 init() {
  closure = { [unowned self] in
   self.counter += 1
   print(self.counter)
  }
 }
 func foo() {
  closure()
 }
}

使用[unowned self] 的时候需要注意的一点是:调用closure的时候如果对象已经被释放的话,会出现crash。

2.使用[weak self]:


class Example {
 private var counter = 1
 private var closure : (() -> ()) = { }
 init() {
  closure = { [weak self] in
   self?.counter += 1
   print(self?.counter ?? "")
  }
 }
 func foo() {
  closure()
 }
}

[weak self] 和[unowned self] 的区别是 [weak self]处理的时候是一个可选类型。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持PHPERZ。



相关阅读 :
Swift中如何避免循环引用的方法
Swift中使用正则表达式的一些方法
Swift在控件中添加点击手势的方法
深入解析Swift中switch语句对case的数据类型匹配的支持
Swift 中 10 个震惊小伙伴的单行代码
详解Swift中enum枚举类型的用法
Swift算法实现字符串转数字的方法示例
Swift算法实现逐字翻转字符串的方法示例
Swift 4.0中如何引用3.0的第三方库
Swift中数组和Objective-C中数组的新增方法对比
详解Swift编程中的方法与属性的概念
在 Swift 中测试 UIAlertController的方法
最新网友评论  共有(0)条评论 发布评论 返回顶部
月排行榜

Copyright © 2007-2017 PHPERZ.COM All Rights Reserved   冀ICP备14009818号  版权声明  服务