Swift - 懒加载(lazy initialization)

Swift中是存在和OC同样的懒加载机制的，在程序设计中,咱们常常会使用 懒加载 ,顾名思义，就是用到的时候再开辟空间

 

懒加载

• 格式：

lazy var 变量: 类型 = { 建立变量代码 }()

• 懒加载的写法本质上是定义并执行一个闭包

// 含义: 当dataList被使用到时, 就会执行等号后面的闭包 // 因此等号后面的闭包的()是必须写的, 若是不写就会报错 // 注意点: 若是写懒加载, 那么修饰符必须用var lazy var dataList:[String] = { print("我被加载了") return ["lnj", "lmj", "zs"] }()

lazy var satatuses: [String] = self.loadStatus() func loadStatus() -> [String] { print("我被加载了") return ["lnj", "lmj", "zs"] }

// 懒加载

    private lazy var inputeTextField: UITextField = {

        let inputeTextField = UITextField()

        inputeTextField.keyboardType = .NumberPad

        /*

         8种键盘风格：

        UIKeyboardTypeDefault,                // 默认键盘：支持全部字符

        UIKeyboardTypeASCIICapable,           // 支持ASCII的默认键盘

        UIKeyboardTypeNumbersAndPunctuation,  // 标准电话键盘，支持+*#等符号

        UIKeyboardTypeURL,                    // URL键盘，有.com按钮；只支持URL字符

        UIKeyboardTypeNumberPad,              //数字键盘

        UIKeyboardTypePhonePad,               // 电话键盘

        UIKeyboardTypeNamePhonePad,           // 电话键盘，也支持输入人名字

        UIKeyboardTypeEmailAddress,           // 用于输入电子邮件地址的键盘

        */

        inputeTextField.delegate = self

        inputeTextField.hidden = true

        return inputeTextField

    }()

 

咱们在OC中通常是这样实现懒加载初始化的：

   1: @property (nonatomic, strong) NSMutableArray *players;

   2:   

   3:  - (NSMutableArray *)players {

   4:      if (!_players) {

   5:          _players = [[NSMutableArray alloc] init];

   6:      }

   7:      return _players;

   8:  }

 

实际上咱们能够这样写：

   1:  lazy var players: NSMutableArray = {

   2:          var temporaryPlayers = NSMutableArray()

   3:          temporaryPlayers.addObject("Mike Buss")

   4:          return temporaryPlayers

   5:          }()

 

好比iOS开发中的最经常使用控件UITableView,实现数据源方法的时候,一般咱们都会这样写

Objective-C

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section { return self.dataArray.count; } - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{ //1.获得cell XWShopCell *cell = [XWShopCell cellWithTableView:tableView]; //2.传递模型 cell.wine = self.dataArray[indexPath.row]; //3.回传cell return cell; }

上面的的代码中

return self.dataArray.count;

其实就是利用

@property (nonatomic, strong) NSArray *dataArray;

@property 的特性，为属性生成了get和set方法，而这里是调用的get方法，可是上述代码中return self.dataArray.count 会调用

- (NSArray *)dataArray{ return _dataArray}

这样调用，若是成员属性dataArray 开始没有赋值的，那么在使用的时候，调用get方法，不重写的话，会报错，空指针,因此通常咱们会重写get方法

//重写get方法 - (NSArray *)dataArray { if (nil == _dataArray){ _dataArray = [NSArray array]; } return _dataArray }

这样写，就防止了成员属性为没有赋值的状况

综上所述,Objective-C的懒加载，其实就是调用成员属性的get方法，初始化值，而Swift的懒加载，是和Objective-C不一样的

---

Swift

//MARK tablview的 dataSource 代理方法 func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int{ return self.dataArray.count } func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell{ //1.获得cell let cell = XWShopCell.cellWithTableView(tableView) //2.传递模型 cell.wine = self.dataArray[indexPath.row] //3.回传cell return cell }

而这句

return self.dataArray.count

在Swift 存储属性必须初始化，确认类型，或者用可选类型，总之要确认类型，毕竟Swfit是类型安全语言,因此Swift提出了lazy属性，用法

//1.分析 NSArray 是一个闭包的返回值，而这是一个没有参数的闭包 lazy var dataArray:NSArray = { [] }() //2.也能够写成这样 lazy var dataArray:NSArray = { return NSArray() }() //3.从plist文件加载 lazy var dataArray:Array<XWWine> = { let winePath = NSBundle.mainBundle().pathForResource("wine.plist", ofType: nil)! let winesM = NSMutableArray(contentsOfFile: winePath); var tmpArray:Array<XWWine>! = [] for tmpWineDict in winesM! { var wine:XWWine = XWWine.wineWithDict(tmpWineDict as! NSDictionary) tmpArray.append(wine) } print("我就运行一次") return tmpArray }()

上述的代码，有点难理解，若是以前会Objective-C的block 或者对C语言的函数指针理解透彻的，能够当作是一个代码块，而后self.dataArray的时候，就执行了代码块，可是重复调用，Lazy 属性的代码块只会调用一次,lazy修饰的是一个存储属性，而存放的是闭包,我想内部，应该进行了优化

 

Swift 懒加载小议

lazy var zyTableView: UITableView = { let tempTableView = UITableView (frame: self.view.bounds, style: UITableViewStyle.Plain) tempTableView.delegate = self tempTableView.dataSource = self return tempTableView }() 这是Swift中懒加载一个叫作zyTableView的变量。 咱们今天就主要来讲说这段代码.

先来讲一下懒加载的好处:

• 须要的时候初始化内存，对内存开销较小，节省内部资源
• 代码初始化放在一块儿，代码块比较好划分，方便别人和本身阅读

再来讲一下有争议的地方，我刚才在几个群里问懒加载效率低不低，有不一样意见，有人说低，也有人说不低，我以为懒加载效率是低的，最简单的说法：

在你须要使用肥皂的时候，你没有肥皂，而后去捡一个肥皂，和你须要使用肥皂的时候就有肥皂了，你以为哪一个效率高？懒加载就是现去捡肥皂呀，因此，懒夹在效率低。

再来看看Swift中懒加载的本质，引用绝影的原话：

它本质在siwft中确实是一个闭包，执行顺序是这样的，若是这个lazy修饰的变量没值，就会执行闭包中的东西，不是每次都执行（本人补充：这也就是为何在Swift中的懒加载没有oc中判断。if（xx==nil）{初始化xx}的代码段）。

在来看下一个问题，既然懒加载在Swift中是一个闭包，那么就用闭包来复写一个懒夹在咯：

let name = { () -> String in return "..." } lazy var myName:String = self.name()

最后呢，若是懒夹在初始化失败怎么办？
答案:可选值。

lazy var value1:String = { return "aaa" }() lazy var value2:String? = { return nil }() lazy var value1:String 等价于 lazy var value1:String!