懒加载
- 格式
lazy var 变量: 类型 = { 创建变量代码 }() - 以
lazy var开头，闭包末尾跟一个'()' - 懒加载的写法本质上是定义并执行一个闭包
- 好处：没有解包的麻烦，并且 延迟创建
- 与OC懒加载的区别：这里的懒加载只会执行一次，如果中途被设置成nil，也不会再次执行
懒加载完整的写法：
eg:懒加载一个数组
lazy var dataList: [String] = { () -> [String] in
return ["zero","one", "two"]
}()
in 和 前面的代码块可以省略，写成这样
lazy var dataList: [String] = {
return ["zero","one", "two"]
}()
后面的闭包和括号也能省略,这种写法是最为简洁的懒加载形式，一般这样写就可以了
lazy var dataList: [String] = ["zero","one", "two"]
比如懒加载一个label
lazy var label: UILabel = UIlabel()
如果对label需要添加其他属性，就可以写成带（）的
lazy var label :UILabel = {
let label = UILabel()
label.font = UIFont.systemFont(ofSize: 15)
label.textColor = UIColor.red
return label
}()
extension
swift中一个类只有一个.m文件，所有代码都会写在.m中，代码多了，难免就会混乱，extension 就是用来隔离代码用的。
extension最常用的几个地方：
代理方法
extension HomeViewController : UITableViewdelegate,UItableViewDataSource {
}
对类的扩展
import UIKit
//对UIBarButtonItem UIbarButton 的一个扩展
extension UIBarButtonItem {
// 便利构造函数
convenience init(imageName: String, highImageName: String, size: CGSize = CGSize.zero) {
let btn = UIButton();
btn.setImage(UIImage(named: imageName), for: UIControlState())
if(highImageName != "") {
btn.setImage(UIImage(named: highImageName), for: .highlighted)
}
if size == CGSize.zero {
btn.sizeToFit()
}else {
btn.frame = CGRect(origin: CGPoint.zero, size: size)
}
self.init(customView: btn)
}
}
本类中的私有方法
extension 外如果想调用extension 内的私有方法，需要加上fileprivate
// MARK: - 设置UI界面
extension HomeController {
fileprivate func setupUI() {
setupNavgationbar()
}
private func setupNavgationbar() {
self.navigationItem.leftBarButtonItem = UIBarButtonItem(imageName:"logo")
}
Swift宏定义
Swift中没有宏的存在，但是有其他实现的方法。而且Swift共享整个命名空间，不在需要.pch文件。新建一个Swfit file文件，最好导入UIKit框架，没有参数的宏直接使用常量定义即可，有参数的宏使用函数代替
无参数的宏
//oc中的宏定义
#define kIOS7 [UIDevice currentDevice].systemVersion.doubleValue>=7.0 ? 1 :0
#define kIOS8 [UIDevice currentDevice].systemVersion.doubleValue>=8.0 ? 1 :0
#define kScreenHeight [UIScreen mainScreen].bounds.size.height
#define kScreenWidth [UIScreen mainScreen].bounds.size.width
//转换成Swift的写法
let kIOS7 = Double(UIDevice().systemVersion)>=7.0 ? 1 :0
let kIOS8 = Double(UIDevice().systemVersion)>=8.0 ? 1 :0
let kScreenHeight = UIScreen.mainScreen().bounds.size.height
let kScreenWidth = UIScreen.mainScreen().bounds.size.width
有参数的宏
//oc写法
#define RGBCOLOR(r,g,b) [UIColor colorWithRed:(r)/255.0 green:(g)/255.0 blue:(b)/255.0 alpha:1]
//Swift中的写法
func RGBCOLOR(r:CGFloat,_ g:CGFloat,_ b:CGFloat) -> UIColor
{
return UIColor(red: (r)/255.0, green: (g)/255.0, blue: (b)/255.0, alpha: 1.0)
}
Swift中weakSelf 的 写法
第一种 类似OC的写法
这里只能用 var 修饰
weak var weakSelf = self
loadData { (result) in
print(weakSelf?.view)
}
第二种 Swift推荐的方式
loadData { [weak self] (result) in
print(self?.view)
}
第三种 不推荐使用
[unowned self] 表示{} 中的 所有self 都是 assgined， 不会强引用，但是对象释放，指针地址不会变化
//相当于 OC __unsafe_unretain
// 如果对象被释放，继续调用，就会出现野指针,有极大的安全隐患
loadData { [unowned self] (result) in
print(self.view)
}
单例
Swift中单例写法较为简单，并且线程安全
static let shared: XCRequest = {
// 实例化对象
let instance = XCRequest()
// 返回对象
return instance
}()
还有另外一种写法
static let instance: XCRequest = XCRequest()
class func shareManager() ->XCRequest {
return instance
}
getter&setter
模仿OC的写法，事实上Swift不会这么写
var _name: String?
var name: String? {
get {
return _name
}
set {
_name = newValue
}
}
var age:Int{
// 如果只重写了get,没有set. 那么属性是一个"计算型"属性
// 计算型属性不占用存储空间, 相当于OC中的readOnly
get{
return 30
}
}
// 如果只有get可以简写为
var gender:String{
return "lnj"
}
计算型属性
只有getter，没有setter的属性被称为计算型属性
var title: String {
get {
return "Mr " + (name ?? "")
}
}
- 只实现 getter 方法的属性被称为计算型属性，等同于 OC 中的 ReadOnly 属性
- 计算型属性本身不占用内存空间
- 不可以给计算型属性设置数值
计算型属性可以使用以下代码简写:
var title: String {
return "Mr " + (name ?? "")
}
didSet
OC中最常见的就是重写setter方法，然后同时做一些额外的事情，那么Swift中就用didSet来实现
var room_list : [[String : NSObject]]? {
didSet {
guard let room_list = room_list else { return }
for dict in room_list {
anchors.append(AnchorModel(dict: dict))
}
}
}
构造函数，析构函数
先了解两个概念
方法重载：
• 函数名相同，参数名／参数类型／参数个数不同
• 重载函数并不仅仅局限于构造函数
• 函数重载是面相对象程序设计语言的重要标志
• OC 不支持函数重载，OC 的替代方式是 withXXX…
方法重写：
• 也叫覆盖，指在子类中定义一个与父类中方法同名同参数列表的方法。
• 重写父类方法需要加override
• 重写是子类的方法覆盖父类的方法，要求方法名和参数都相同
• 因为子类会继承父类的方法，而重写就是将从父类继承过来的方法重新定义一次，重新填写方法中的代码。
• 重写必须继承，重载不用
构造函数
class Person: NSObject {
var name: String
///最简单的必选属性的构造函数
///构造函数的目的，给自己分配空间并设置初始值
///属性的初始化放在super.init前面
/// 重写父类方法需要加override
override init () {
name = "default name:Tom"
super.init()
}
/// 如果实现了 构造函数的重载，并且没有重写构造函数，那么系统不再提供原始的init()函数
/// 方法重载（类似OC自定义初始化方法）
init(name: String) {
self.name = name
super.init()
}
}
析构函数
相当于OC中的dealloc方法
deinit {
print("被释放了")
}
guard let & if let
相当于OC中用if来判断某个值是不是为空
我认为这个语法最大的好处是避免了写大量的 ？！，
用来判断的这个属性必须是可选的
guard 与 if 的区别是 guard只有在条件不满足的时候才会执行这段代码
guard let _:String = pe.name else {
return
}
如果要判断多个参数,一直在后面加
guard let _ = pe.name, let _ = pe.title else {
return
}
if let 可以在条件成立或者不成立的情况下，在{}中分别处理
if let name = pe.name {
print(name)
} else {
return
}
as
as 的三种情况
as？
- 前面的返回值是可选的
- guard let / if let 一定用 as?
as!
- 前面的返回值一定有值
as
- NSString -> String
- NSArray ->[ ]
- NSDictionary -> [ ]
- 这种情况是因为底层做了结构体和OC对象的桥接
try 处理错误异常
let jsonSTring = "{\"name\": \"zhang\"]"
let data = jsonSTring.data(using: .utf8)
//方法1. 推荐，如果解析成功就有值，否则 为nil
let json1 = try? JSONSerialization.jsonObject(with: data!, options: [])
print(json1 ?? "json1 为 nil")
//方法2. 墙裂不推荐 如果解析成功就有值，否则crash
//let json2 = try! JSONSerialization.jsonObject(with: data!, options: [])
//方法3. 异常处理,能够接受错误，可以在错误的情况下另行处理
do {
let json3 = try JSONSerialization.jsonObject(with: data!, options: [])
print(json3)
} catch {
print(error);
}
网络请求
GET
func getWithPath(path: String,param: Dictionary<String,Any>?,completion: @escaping ((_ result: Any?, _ success:Bool) -> ())) {
let url = URL(string: path.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed)!)
if let para = param {
//对参数进行处理
print(para)
} else {
}
let session = URLSession.shared
let dataTask = session.dataTask(with: url!) { (data, respond, error) in
if let data = data {
if let result = try? JSONSerialization.jsonObject(with: data, options: .allowFragments){
completion(result,true)
}
}else {
completion(error,false)
}
}
dataTask.resume()
}
POST
func postWithPath(path: String,paras: Dictionary<String,Any>?,success: @escaping ((_ result: Any) -> ()),failure: @escaping ((_ error: Error) -> ())) {
let url = URL(string: path)
var request = URLRequest.init(url: url!)
request.httpMethod = "POST"
print(path)
request.httpBody = path.data(using: .utf8)
let session = URLSession.shared
let dataTask = session.dataTask(with: request) { (data, respond, error) in
if let data = data {
if let result = try? JSONSerialization.jsonObject(with: data, options: .allowFragments) {
success(result)
}
}else {
failure(error!)
}
}
dataTask.resume()
}
