Wie kann ich den Aufruf einer statischen Funktion auf ein Protokoll, in einer generischen Art und Weise?

Schöne Frage. Hier ist meine bescheidene Sicht:

Gibt es einen Punkt, um die Deklaration einer statischen Funktion auf ein Protokoll?

So ziemlich das gleiche wie Instanz-Methoden deklariert, in einem Protokoll.

Der client mit dem Protokoll zum Aufruf der Funktion mit einem Typ konform zu dem Protokoll ohnehin Recht?

Ja, genau wie Instanz-Funktionen.

, Bricht der Gedanke, nicht zu wissen, die Art der konform zum Protokoll IMO.

NÖ. Betrachten Sie den folgenden code:

protocol Feline {
    var name: String { get }
    static func createRandomFeline() -> Feline
    init()
}

extension Feline {
    static func createRandomFeline() -> Feline {
        return arc4random_uniform(2) > 0 ? Tiger() : Leopard()
    }
}

class Tiger: Feline {
    let name = "Tiger"
    required init() {}
}

class Leopard: Feline {
    let name = "Leopard"
    required init() {}
}

let feline: Feline = arc4random_uniform(2) > 0 ? Tiger() : Leopard()
let anotherFeline = feline.dynamicType.createRandomFeline()

Ich weiß nicht, den tatsächlichen Typ in der variable feline. Ich weiß nur, dass es nicht entsprechen Feline. Ich bin jedoch der Aufruf eines statischen Protokoll-Methode.

Gibt es einen besseren Weg, dies zu tun?

Ich sehe, Sie möchte aufrufen einer statischen Methode/Funktion deklariert, in einem Protokoll, ohne eine dem Wert entspricht, der Protokoll.

Etwas wie dieses:

Feline.createRandomFeline() // DANGER: compiler is not happy now

Ehrlich gesagt, ich weiß nicht, der Grund, warum dies nicht möglich.

Danke @appzYourLife für die Hilfe! Deine Antwort inspiriert meine Antwort.

@appzYourLife meine Frage beantwortet. Ich hatte eine zugrunde liegende Problem, das ich versuche zu lösen ist, und der folgende code löst mein Problem, also werde ich das hier posten, vielleicht hilft es ja jemandem mit meiner derselben zugrunde liegenden Frage:

 protocol MyProtocol {
     static func aStaticFunc()
 }

 class SomeClassThatUsesMyProtocolButDoesntConformToIt {

     var myProtocolType: MyProtocol.Type
     init(protocolType: MyProtocol.Type) {
         myProtocolType = protocolType
     }

     func aFunction() {
         myProtocolType.aStaticFunc()
     }
 }

Mithilfe von Protokollen wie Java-interfaces ist selten eine gute Idee. Sie sind meta-Typen, bedeutete für die Definition von Verträgen, die eine ganz andere Art der Sache.

Dass gesagt wird, nur für den Punkt verstehen, ich finde die meisten einfachen und effektiven Weg für die Schaffung der äquivalent zu einer statischen factory-Methode, ein Protokoll zu schreiben, eine Kostenlose Funktion.

Sollte es den Protokoll-Namen, in der Hoffnung, dass name-clashes, und verbessern die Auffindbarkeit.

In anderen Sprachen, createP wäre ein statisches Element von P, die mit Namen erstellen und als P. create(...), die drastisch verbessern die Auffindbarkeit und garantieren, um zu verhindern, dass name-clashes.

Swift, obwohl, dies ist nicht eine option für die Protokolle, so dass, wenn die Protokolle sind für einige Grund wirklich als Ersatz für Schnittstellen, mindestens einschließlich dem Protokoll, das die Namen in der Funktion-name ist ein hässlicher workaround, der immer noch leicht besser als nichts.

P. S. im Fall das Ziel tatsächlich zu erreichen, so etwas wie eine Hierarchie-Vererbung mit einer struct -, union-Stil enums sind das Werkzeug, soll diesem Zweck dienen 🙂

protocol P
{
    var x: Int { get }
}

func createP() -> P
{
    if (todayIsMonday())
    {
        return A()
    }
    else
    {
        return B()
    }
}

class A: P
{
    var x = 5
}

class B: P
{
    var x = 7
}

Hatte ich eine situation, wo ich erstellen müssen derselben DomainModel Objekt aus 2 andere Antwort. also diese (static Methode in protocol mir geholfen) Ansatz hat mir geholfen.

protocol BaseResponseKeyList: CodingKey {
   static func getNameKey()->Self
}

enum FirstResponseKeyList: String, BaseResponseKeyList {
    case name

    func getNameKey()->FirstResponseKeyList {
       return .name
    }
}

enum SecondResponseKeyList: String, BaseResponseKeyList {
    case userName

    func getNameKey()->SecondResponseKeyList {
       return .userName
    }
}

struct MyDomainModel<T:BaseResponseKeyList> : Decodable {
    var name:String?

    required init(from d:Decoder) {
       do {
            let container = try d.container(keyedBy:T.self)
            name = try container.decode(String.self, forKey:T.getNameKey())
        }catch(_) {
            print("error")
        }
    }
}

let myDomainModel = try JSONDecoder().decode(MyDomainModel <FirstResponseKeyList>.self, from: data)
let myDomainModel2 = try JSONDecoder().decode(MyDomainModel <SecondResponseKeyList>.self, from: data2)