Swift appel de méthodes statiques: type(de: auto) vs explicite nom de la classe

Dans swift, une instance func ne pouvez pas appeler un static/class func sans la préfixation de l'appel de méthode par le nom de la classe. OU vous pouvez utiliser type(of: self), e.g

class Foo {
    static func doIt() { }

    func callIt() {
        Foo.doIt() //This works
        type(of: self).doIt() //Or this

        doIt() //This doesn't compile (unresolved identifier)
    }
}

Ma question est, quelle est la différence ici?
Est-ce simplement une question de style de codage, ou est-il une différence, par exemple, statique ou dynamique, l'expédition se passe?

Si c'est juste le style de codage, ce qui est le style préféré?

  • Je ne crois pas qu'il existe une répartition dynamique. Nous ne sommes pas en Objective-C monde car il n'y a pas de @objc, dynamic, ou NSObject héritage.
  • En fait Swift classe sont Obj-C classes sous le capot (au moins lors de l'Obj-C runtime est incluse). Et "pure" Swift n'avez répartition dynamique en trop (pensez protocoles) – ce n'est pas seulement un Obj-C chose.
  • Je sais que Swift classes héritent de SwiftObject, mais est-il de même avec la solution open source d'exécution (à l'exclusion des protocoles)?
  • Ouais, je viens de modifier mon commentaire à la note que je n'ai pas regardé l'open source, de l'exécution dans les détails, mais je ne crois pas que Swift classes sont basées sur l'Obj-C des classes, comme il n'y a pas l'Obj-C runtime.
  • Suivre cette proposition pour apple pensées à ce sujet: github.com/apple/swift-evolution/blob/master/proposals/...
InformationsquelleAutor Orion Edwards | 2017-02-15
  1. 29

    Il y a deux différences principales.

    1. La valeur de self à l'intérieur de la méthode statique

    La metatype que vous appelez la méthode statique est disponible pour vous dans la méthode comme self (c'est tout simplement passé comme un paramètre implicite). Donc si vous appelez doIt() sur type(de: auto), self sera le dynamique metatype de l'instance. Si vous l'appelez sur Foo, self sera Foo.self.

    class Foo {
    static func doIt() {
        print("hey I'm of type \(self)")
    }

    func callDoItOnDynamicType() {
        type(of: self).doIt() //call on the dynamic metatype of the instance.
    }

    func classDoItOnFoo() {
        Foo.doIt() //call on the metatype Foo.self.
    }
}

class Bar : Foo {}

let f: Foo = Bar()

f.callDoItOnDynamicType() //hey I'm of type Bar
f.classDoItOnFoo()        // hey I'm of type Foo

    Cette différence peut être vraiment important pour les méthodes de fabrique, car il détermine le type d'instance que vous créez.

    class Foo {
    required init() {}

    static func create() -> Self {
        return self.init()
    }

    func createDynamic() -> Foo {
        return type(of: self).create()
    }

    func createFoo() -> Foo {
        return Foo.create()
    }
}

class Bar : Foo {}

let f: Foo = Bar()

print(f.createDynamic()) //Bar
print(f.createFoo())     // Foo

    2. L'appel de la méthode statique

    (Martin a déjà couverts cela, mais j'ai pensé que je voudrais ajouter, pour le bien de l'achèvement.)

    Pour class méthodes qui sont remplacées dans les sous-classes, la valeur de la metatype que vous appelez la méthode détermine la mise en œuvre d'appel.

    Si elle est appelée sur un metatype qui est connu au moment de la compilation (e.g Foo.doIt()), Swift est en mesure de statiquement l'envoi de l'appel. Toutefois, si vous appelez la méthode sur un metatype qui n'est pas connu jusqu'à l'exécution (e.g type(of: self)), l'appel de la méthode sera dynamiquement distribué à la mise en œuvre correcte de la metatype valeur.

    class Foo {
    class func doIt() {
        print("Foo's doIt")
    }

    func callDoItOnDynamicType() {
        type(of: self).doIt() //the call to doIt() will be dynamically dispatched.
    }

    func classDoItOnFoo() {
        Foo.doIt() //will be statically dispatched.
    }
}


class Bar : Foo {
    override class func doIt() {
        print("Bar's doIt")
    }
}

let f: Foo = Bar()

f.callDoItOnDynamicType() //Bar's doIt
f.classDoItOnFoo()        // Foo's doIt
    InformationsquelleAutor Hamish
  2. 4

    Pour un class méthode, cela fait une différence si la méthode est
    redéfinie dans une sous-classe:

    class Foo {
    class func doIt() {
        print("Foo doit")
    }

    func callViaClassname() {
        Foo.doIt()
    }

    func callViaTypeOf() {
        type(of: self).doIt()
    }
}

class Bar: Foo {
    override class func doIt() {
        print("Bar doit")
    }

}

Bar().callViaClassname() //Foo doit
Bar().callViaTypeOf() // Bar doit

    C'est également documenté dans "Types" de la Swift de Référence du Langage:

    Vous pouvez utiliser un type(of:) expression avec une instance d'un type pour accéder à cette instance dynamique, runtime type comme une valeur, ...

    je ne sais pas la différence pour un static méthode (qui est final
    et ne peut pas être redéfinie dans une sous-classe).
    Correction: Voir Hamish réponse pour la différence
    dans les deux statique et les méthodes de la classe.

    • La différence pour les deux static et class méthodes est la valeur de self à l'intérieur de la méthode, voir ma réponse 🙂
    • Oui, c'est un bon point, et je n'avais pas pensé à ce sujet.
    InformationsquelleAutor Martin R