Quelle est la différence entre func statique et func de classe dans Swift?

Je peux voir ces définitions dans la bibliothèque Swift:

extension Bool : BooleanLiteralConvertible {
    static func convertFromBooleanLiteral(value: Bool) -> Bool
}

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    class func convertFromBooleanLiteral(value: BooleanLiteralType) -> Self
}

Quelle est la différence entre une fonction membre définie comme static funcet une autre définie comme class func? Est-ce simplement staticpour les fonctions statiques des structures et des énumérations, ainsi que classpour les classes et les protocoles? Y a-t-il d'autres différences que l'on devrait connaître? Quelle est la justification de cette distinction dans la syntaxe elle-même?

Est-ce simplement que statique est pour les fonctions statiques des structures et des énumérations, et la classe pour les classes et les protocoles?

Voilà la principale différence. Certaines autres différences sont que les fonctions de classe sont distribuées dynamiquement et peuvent être remplacées par des sous-classes.

Les protocoles utilisent le mot-clé class, mais il n'exclut pas les structures de l'implémentation du protocole, ils utilisent simplement statique à la place. La classe a été choisie pour les protocoles, il n'y aurait donc pas besoin d'un troisième mot-clé pour représenter statique ou classe.

De Chris Lattner sur ce sujet:

Nous avons envisagé d'unifier la syntaxe (par exemple en utilisant "type" comme mot-clé), mais cela ne fait pas simplement des choses. Les mots clés "classe" et "statique" sont bons pour la familiarité et sont assez descriptifs (une fois que vous comprenez comment + les méthodes fonctionnent), et ouvrent la porte à l'ajout potentiel de méthodes vraiment statiques aux classes. La bizarrerie principale de ce modèle est que les protocoles doivent choisir un mot-clé (et nous avons choisi "classe"), mais dans l'ensemble c'est le bon compromis.

Et voici un extrait qui montre certains des comportements de substitution des fonctions de classe:

class MyClass {
    class func myFunc() {
        println("myClass")
    }
}

class MyOtherClass: MyClass {
    override class func myFunc() {
        println("myOtherClass")
    }
}

var x: MyClass = MyOtherClass()
x.dynamicType.myFunc() //myOtherClass
x = MyClass()
x.dynamicType.myFunc() //myClass

Pour être plus clair, je fais un exemple ici,

class ClassA {
  class func func1() -> String {
    return "func1"
  }

  static func func2() -> String {
    return "func2"
  }

  /* same as above
  final class func func2() -> String {
    return "func2"
  }
  */
}

static func est identique à final class func

Parce qu'il l'est final, nous ne pouvons pas le remplacer dans la sous-classe comme ci-dessous:

class ClassB : ClassA {
  override class func func1() -> String {
    return "func1 in ClassB"
  }

  // ERROR: Class method overrides a 'final` class method
  override static func func2() -> String {
    return "func2 in ClassB"
  }
}

J'ai fait quelques expériences dans une aire de jeux et j'ai tiré quelques conclusions.

TL; DR

Comme vous pouvez le voir, dans le cas de class, l'utilisation class funcou static funcn'est qu'une question d'habitude.

Exemple de terrain de jeu avec explication:

class Dog {
    final func identity() -> String {
        return "Once a woofer, forever a woofer!"
    }

    class func talk() -> String {
        return "Woof woof!"
    }

    static func eat() -> String {
        return "Miam miam"
    }

    func sleep() -> String {
        return "Zzz"
    }
}

class Bulldog: Dog {
    // Can not override a final function
//    override final func identity() -> String {
//        return "I'm once a dog but now I'm a cat"
//    }

    // Can not override a "class func", but redeclare is ok
    func talk() -> String {
        return "I'm a bulldog, and I don't woof."
    }

    // Same as "class func"
    func eat() -> String {
        return "I'm a bulldog, and I don't eat."
    }

    // Normal function can be overridden
    override func sleep() -> String {
        return "I'm a bulldog, and I don't sleep."
    }
}

let dog = Dog()
let bullDog = Bulldog()

// FINAL FUNC
//print(Dog.identity()) // compile error
print(dog.identity()) // print "Once a woofer, forever a woofer!"
//print(Bulldog.identity()) // compile error
print(bullDog.identity()) // print "Once a woofer, forever a woofer!"

// => "final func" is just a "normal" one but prevented to be overridden nor redeclared by subclasses.


// CLASS FUNC
print(Dog.talk()) // print "Woof woof!", called directly from class
//print(dog.talk()) // compile error cause "class func" is meant to be called directly from class, not an instance.
print(Bulldog.talk()) // print "Woof woof!" cause it's called from Bulldog class, not bullDog instance.
print(bullDog.talk()) // print "I'm a bulldog, and I don't woof." cause talk() is redeclared and it's called from bullDig instance

// => "class func" is like a "static" one, must be called directly from class or subclassed, can be redeclared but NOT meant to be overridden.

// STATIC FUNC
print(Dog.eat()) // print "Miam miam"
//print(dog.eat()) // compile error cause "static func" is type method
print(Bulldog.eat()) // print "Miam miam"
print(bullDog.eat()) // print "I'm a bulldog, and I don't eat."

// NORMAL FUNC
//print(Dog.sleep()) // compile error
print(dog.sleep()) // print "Zzz"
//print(Bulldog.sleep()) // compile error
print(bullDog.sleep()) // print "I'm a bulldog, and I don't sleep."

Pour déclarer une propriété de variable de type, marquez la déclaration avec le staticmodificateur de déclaration. Les classes peuvent marquer les propriétés calculées de type avec le classmodificateur de déclaration à la place pour permettre aux sous-classes de remplacer l'implémentation de la superclasse. Les propriétés de type sont décrites dans les propriétés de type.

REMARQUE
Dans une déclaration de classe, le mot clé statica le même effet que le marquage de la déclaration avec les modificateurs de déclaration classet final.

Source: langage de programmation Swift - Propriétés des variables de type

Selon le livre Swift 2.2 publié par apple:

«Vous indiquez des méthodes de type en écrivant le staticmot - clé avant le mot-clé func de la méthode. Les classes peuvent également utiliser le classmot clé pour permettre aux sous-classes de remplacer l'implémentation de cette méthode par la superclasse . »

Depuis Swift2.0, Apple dit:

"Toujours préfixer les exigences de propriété de type avec le mot clé statique lorsque vous les définissez dans un protocole. Cette règle s'applique même si les exigences de propriété de type peuvent être préfixées avec la classe ou le mot clé statique lorsqu'ils sont implémentés par une classe:"

Cet exemple effacera tous les aspects!

import UIKit

class Parent {
    final func finalFunc() -> String { // Final Function, cannot be redeclared.
        return "Parent Final Function."
    }

    static func staticFunc() -> String { // Static Function, can be redeclared.
        return "Parent Static Function."
    }

    func staticFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Static Function, redeclared with same name but as non-static(normal) function."
    }

    class func classFunc() -> String { // Class Function, can be redeclared.
        return "Parent Class Function."
    }

    func classFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Class Function, redeclared with same name but as non-class(normal) function."
    }

    func normalFunc() -> String { // Normal function, obviously cannot be redeclared.
        return "Parent Normal Function."
    }
}

class Child:Parent {

    // Final functions cannot be overridden.

    override func staticFunc() -> String { // This override form is of the redeclared version i.e: "func staticFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Static Function redeclared and overridden, can simply be called Child Normal Function."
    }

    override class func classFunc() -> String { // Class function, can be overidden.
        return "Child Class Function."
    }

    override func classFunc() -> String { // This override form is of the redeclared version i.e: "func classFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Class Function, redeclared and overridden, can simply be called Child Normal Function."
    }

    override func normalFunc() -> String { // Normal function, can be overridden.
        return "Child Normal Function."
    }
}

let parent = Parent()
let child = Child()

// Final
print("1. " + parent.finalFunc())   // 1. Can be called by object.
print("2. " + child.finalFunc())    // 2. Can be called by object, parent(final) function will be called.
// Parent.finalFunc()               // Cannot be called by class name directly.
// Child.finalFunc()                // Cannot be called by class name directly.

// Static
print("3. " + parent.staticFunc())  // 3. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("4. " + child.staticFunc())   // 4. Cannot be called by object, this is override form redeclared version (normal function).
print("5. " + Parent.staticFunc())  // 5. Can be called by class name directly.
print("6. " + Child.staticFunc())   // 6. Can be called by class name direcly, parent(static) function will be called.

// Class
print("7. " + parent.classFunc())   // 7. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("8. " + child.classFunc())    // 8. Cannot be called by object, this is override form redeclared version (normal function).
print("9. " + Parent.classFunc())   // 9. Can be called by class name directly.
print("10. " + Child.classFunc())   // 10. Can be called by class name direcly, child(class) function will be called.

// Normal
print("11. " + parent.normalFunc())  // 11. Can be called by object.
print("12. " + child.normalFunc())   // 12. Can be called by object, child(normal) function will be called.
// Parent.normalFunc()               // Cannot be called by class name directly.
// Child.normalFunc()                // Cannot be called by class name directly.

/*
 Notes:
 ___________________________________________________________________________
 |Types------Redeclare------Override------Call by object------Call by Class|
 |Final----------0--------------0---------------1------------------0-------|
 |Static---------1--------------0---------------0------------------1-------|
 |Class----------1--------------1---------------0------------------1-------|
 |Normal---------0--------------1---------------1------------------0-------|
 ---------------------------------------------------------------------------

 Final vs Normal function: Both are same but normal methods can be overridden.
 Static vs Class function: Both are same but class methods can be overridden.
 */

Production:

C'est ce qu'on appelle les méthodes de type et elles sont appelées avec la syntaxe à points, comme les méthodes d'instance. Cependant, vous appelez des méthodes de type sur le type, pas sur une instance de ce type. Voici comment appeler une méthode de type sur une classe appelée SomeClass: