swift中的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 只能定义static
    static 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: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.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! Student
            return 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: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.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 ===的应用

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