Unterscheidung in Swift zwischen Großbuchstaben „Selbst“ und Kleinbuchstaben „Selbst“

Während ich auf einem Swift-Spielplatz spielte, bemerkte ich, dass Selfmit Großbuchstaben "S" neben Kleinbuchstaben auch verfügbar ist self. Gibt es einen Unterschied zwischen ihnen? Wenn ja, wofür werden diese beiden verwendet, insbesondere für Self?

Selfbezieht sich auf den Typ des aktuellen "Dings" innerhalb eines Protokolls (was auch immer dem Protokoll entspricht). Ein Beispiel für seine Verwendung finden Sie unter Protokollfunktion, die Self zurückgibt .

Die offiziellen Dokumente, für die ich gefunden habe, befinden sich Selfin der protokollassoziierten Typdeklaration in der Programmiersprache Swift. Es ist überraschenderweise nicht in den Abschnitten über Protokolle oder verschachtelte Typen dokumentiert:

Jetzt gibt es jedoch einen Absatz über die AufnahmeSelf Type eines Codebeispiels in das offizielle Kapitel der Swift Programming Language über Typen

Selfkann auch in Klassen verwendet werden und ist nützlich. Hier ist ein Artikel darüber.

Hier ist ein Beispiel. Sie haben eine Klasse namens MyClass. MyClassMethoden haben, die Instanzen davon zurückgeben. Jetzt fügen Sie eine Unterklasse von MyClassaufgerufen hinzu MySubclass. Sie möchten, dass diese Methoden Instanzen von MySubclassstatt zurückgeben MyClass. Der folgende Code zeigt, wie es geht. Beachten Sie, dass die Methoden entweder Instanzmethoden oder Klassenmethoden sein können.

class MyClass: CustomStringConvertible {

    let text: String

    // Use required to ensure subclasses also have this init method
    required init(text: String) {
        self.text = text
    }

    class func create() -> Self {
        return self.init(text: "Created")
    }

    func modify() -> Self {
        return type(of: self).init(text: "modifid: " + text)
    }

    var description: String {
        return text
    }

}

class MySubclass: MyClass {
    required init(text: String) {
        super.init(text: "MySubclass " + text)
    }
}

let myClass = MyClass.create()
let myClassModified = myClass.modify()

let mySubclass = MySubclass.create()
let mySubclassModified = mySubclass.modify()

print(myClass)
print(myClassModified)
print(mySubclass)
print(mySubclassModified)

Die folgende Zeile wurde ausgedruckt:

// Created
// modifid: Created
// MySubclass Created
// MySubclass modifid: MySubclass Created

Verwenden Sie in der Protokoll- und Erweiterungsdeklaration Self else self

extension protocolName where Self: UIView 
{
  func someFunction()
  {
    self.layer.shadowColor = UIColor.red.cgColor
  }
}

Ich denke, diese Frage könnte eine einfachere Antwort gebrauchen, die sich mehr auf den Unterschied zwischen Selfund konzentriert selfund sich möglicherweise an Personen richtet, die Swift noch nicht kennen.

self - expliziter Verweis auf den aktuellen Typ oder die Instanz des Typs, in dem er vorkommt.

class MyClass {
  func showClass() {
       print("\(self)")
    }
  }
let someClass = MyClass()
someClass.showClass()
// prints "MyClass"

Self- Wird speziell in protocolund extensionDeklarationen verwendet , um auf den möglichen Typ zu verweisen, der dem Protokoll entspricht.

protocol MyProtocol {
   static func returnSelf() -> Self
}

class MyClass: MyProtocol {
   // define class
}

MyClass.returnSelf() 
// returns MyClass

Der Unterschied besteht darin, dass selfin Typen und Instanzen von Typen verwendet wird, um auf den Typ zu verweisen, in dem er sich befindet. und Selfwird in Protokollen und Erweiterungen verwendet, bei denen das tatsächliche typenoch nicht bekannt ist.

In noch einfacheren Worten, selfwird innerhalb eines vorhandenen Typs verwendet; Selfwird verwendet, um auf einen Typ zu verweisen, der Selfnoch nicht vorhanden ist.

Lesen Sie hier mehr:

• Self- https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_543
• self- https://docs.swift.org/swift-book/ReferenceManual/Expressions.html
• Beides - https://medium.com/the-traveled-ios-developers-guide/swift-keywords-v-3-0-1-f59783bf26c

Self kann auch als Rückgabetyp im Protokollerweiterungsmethoden-Body verwendet werden, der eine bestätigende Typinstanz zurückgibt, und für das Typ-Casting mit "as". Siehe Beispiel unten:

extension <Protocol-Name> where Self:<Class-Name> {
static func foo(_ param:Type)-> Self{
    guard let abc = method() as? Self else{
        return xyz
    }
}}

Kurz gesagt, Self kann verwendet werden, um den Typ zu referenzieren, der das Protokoll bestätigt.

Ich verstehe Self als Typnamen (z. B. Klassenname) und self als Instanz einer Klasse / Struktur, zum Beispiel:

struct Person {
     static var documentNumner = "9484930"
     var name: String
     var computedFullName: String {
        return ("\(self.name) with document number: \(Self.documentNumner)")

    }
}

Sie können self nicht mit einer statischen Eigenschaft verwenden, aber Sie können Self verwenden