self和Self、== 和===的区别

1. `self`和`Self`

1.1 `self`

大家都知道self关键字在实例方法中指当前对象，和OC中的作用一样，但是在OC中在类方法中是无法被使用的，而swift中是可以使用的，接下来我们看看self在这环境下的表示类型。

实例中的self的类型：

在实例方法中self表示的类型是SwiftTestClass_self类型，就是当前类的实例对象

类型中的self：

如上图所示，self的类型显示是SwiftTestClass_self.Type类型,那么。Type是什么类型，字面上来说self是SwiftTestClass_self类型本身

如果我们个类中添加一个静态常量，那么在类方法和今天方法中可以通过self.xxx来访问这个常量，因为他们都属于这个类型本身，self.xxx也就是在访问这个类本身的常量

1.2 `Self`

1.2.1 实例方法中的`Self`

Self在实例方法、静态方法、类方法中可以通过Self.xxx来访问静态属性

static let classLet: Int = 0
/// 实例方法
func instanceMethod() -> Void {print("Self.class====\(Self.classLet)")}
/// 静态方法
static func classMethod() -> Void {print("Self.class====\(Self.classLet)")
}
/// 类方法
class func classMethod2() -> Void {print("Self.class====\(Self.classLet)")
}

接下来我们观察下下面代码的代码的打印结果：

static func classMethod() -> Void {print("Self.self====\(Self.self)")print("self====\(self)")print("SwiftTestClass_self.self====\(SwiftTestClass_self.self)")print(Self.self==self)print(SwiftTestClass_self.self == self)print(SwiftTestClass_self.self == Self.self)
}
/**
打印结果:
Self.self====SwiftTestClass_self
self====SwiftTestClass_self
SwiftTestClass_self.self====SwiftTestClass_self
true
true
true
*/

根据官方文档介绍，这个Self的值是等于type(of: self)获取的，也就是这个指是动态获取的

我们看下面示例代码：

static let classLet: Int = 0
/// 可以成功赋值
let instaceLet = classLet
var instaceVar = classLet//let instanceLet2 = self.classLet || Self.classLet 如果使用类中的属性初始化实例中的属性，上面那种赋值是可以的，但是slef.xxx不可以的，会出现编译错误， 因为当前self是未定义的，不存在的lazy var instanceVar2 = Self.classLet
// 如果给懒加载的属性赋值 可以使用Self.xxx,但是不能使用self.xxx, 如果使用懒加载的属性，要注意区分 self 和 Self。因为实例已经完成了初始化，此时 self 是有效的。 此时的self代表当前实例对象， Self代表当前类。你使用类的属性，应该使用类对象，而不是实例对象

1.2.2 协议中的`Self`

Self用于协议中（Protocol）中限制相关类型(实例加载xib创建的空间实例)

protocol GYLoadNibProtocl {}
// 当这个协议被UIView或者UIView子类使用的时候，默认实现loadFromNib方法，后续实现类可以再进行重写。
//Self 不仅指代的是实现该协议的类型本身，也包括了这个类型的子类
//where Self : UIView ： 限制当View和View的子类遵守这个协议之后，默认有实现 loadFromNib这个方法
extension GYLoadNibProtocl where Self : UIView {//在协议里面不允许定义class 只能定义staticstatic func loadFromNib(_ nibname: String? = nil) -> Self {//Self (大写) 当前类对象//self(小写) 当前对象let loadName = nibname == nil ? "\(self)" : nibname!return Bundle.main.loadNibNamed(loadName, owner: nil, options: nil)?.first as! Self}
}

Self用于类（Class）的返回值

protocol TestProtocol {func getSelf() -> Self
}class TestSubClass: TestProtocol {var name = "ceshi"//作为类的返回值class func getInstance() -> Self {return TestSubClass() as! Self}func getInstance2() -> Self {return TestSubClass() as! Self}
}
//此时Self是最终实现协议的那个类型
let sub = TestSubClass()
print(sub)
let sub2 = TestSubClass.getInstance()
print("sub2.name=====\(sub2.name)")

2. `==`和`===`的区别

2.1 `==`的应用

==：是Equatable协议中定义的方法，它的否定形式!=，支持自定义比较，规则可以由开发者自行定义比较规则

//关于此协议可以点击api查看具体的介绍
public protocol Equatable {/// Returns a Boolean value indicating whether two values are equal.////// Equality is the inverse of inequality. For any values `a` and `b`,/// `a == b` implies that `a != b` is `false`.////// - Parameters:///   - lhs: A value to compare.///   - rhs: Another value to compare.static func == (lhs: Self, rhs: Self) -> Bool
}

我们可以自定义一个类，然后遵守此协议实现比较方法：

//定义一个学生类，声明两个属性
class Student: NSObject {var name: Stringvar age: Intinit(name: String, age: Int) {self.name = nameself.age = age}//自定义对象，想要比较两个对象是否相等， 那么需要实现isEqual方法 实现比较规则你 猜测”==“的底层是调用isEqual方法， 而isEqual方法可能和hash值有关/**/// Subclasses of `NSObject` can customize Equatable conformance by overriding/// `isEqual(_:)`. If two objects are equal, they must have the same hash/// value, so if you override `isEqual(_:)`, make sure you also override the `hash` property.NSObject的子类 如果想自定义比较，需要重写isEqual(_:)方法。如果两个对象比较，他们必须有一个相同的hash值，因此你必须重写isEqual(_:)， 并确认你也重写hash属性*/override func isEqual(_ object: Any?) -> Bool {if object == nil {return false}//is  相当于OC中的isKindof方法，判断是否是某个类或则子类的实例if object is Student {let obj = object as! Studentreturn name==obj.name && age == obj.age} else {return false}}//经过实践 如果不实现这个属性 只要重写isEqual(_:) 这个方法也可以比较两个对象override var hash: Int {return self.hash}
}let student = Student.init(name: "guo", age: 22)
let student1 = Student.init(name: "guo", age: 22)
//如果Student 不是继承是NSObject，并且没有遵守Equatable协议 是无法使用”==“ 来比较两个student对象的,如果集成NSObject,那就可以使用”==“来比较，
print("比较两个数=======\(student==student1)")//打印结果： true

如果自定义的类不是集成NSObject，而是遵循Equatable是什么情况了

class Person: Equatable {//需要重写== 方法static func == (lhs: Person, rhs: Person) -> Bool {return lhs.name==rhs.name && lhs.age==rhs.age}var name: Stringvar age: Intinit(name: String, age: Int) {self.name = nameself.age = age}
}let person = Student.init(name: "guo", age: 22)
let person1 = Student.init(name: "guo", age: 22)
print("比较两个数=======\(person==person1)")
//打印结果： true

如果是直接遵守Equatable协议的，那么需要实现协议方法static func == (lhs: Person, rhs: Person) -> Bool {},可以直接在这个方法中实现自定义的比较规则，然后就可以标记两个对象了

2.2 `===`的应用

===:比较的是指针，所以只能比较引用类型，否定形式!==,不支持开发者自定义规则