Funções / variáveis ​​estáticas versus classes nas classes Swift?

O código a seguir é compilado no Swift 1.2:

class myClass {
    static func myMethod1() {
    }
    class func myMethod2() {
    }
    static var myVar1 = ""
}

func doSomething() {
    myClass.myMethod1()
    myClass.myMethod2()
    myClass.myVar1 = "abc"
}

Qual é a diferença entre uma função estática e uma função de classe ? Qual devo usar e quando?

Se eu tentar definir outra variável class var myVar2 = "", ele diz:

Propriedades armazenadas de classe ainda não suportadas em classes; você quis dizer 'estático'?

Quando esse recurso é suportado, qual será a diferença entre uma variável estática e uma variável de classe (ou seja, quando ambas são definidas em uma classe)? Qual devo usar e quando?

(Xcode 6.3)

statice classambos associam um método a uma classe, em vez de uma instância de uma classe. A diferença é que as subclasses podem substituir os classmétodos; eles não podem substituir staticmétodos.

class teoricamente, as propriedades funcionarão da mesma maneira (as subclasses podem substituí-las), mas ainda não são possíveis no Swift.

Eu tentei a resposta de mipadi e comentários no playground. E pensou em compartilhá-lo. Aqui está. Acho que a resposta de mipadi deve ser considerada aceita.

class A{
    class func classFunction(){
    }
    static func staticFunction(){
    }
    class func classFunctionToBeMakeFinalInImmediateSubclass(){
    }
}

class B: A {
    override class func classFunction(){

    }

    //Compile Error. Class method overrides a 'final' class method
    override static func staticFunction(){

    }

    //Lets avoid the function called 'classFunctionToBeMakeFinalInImmediateSubclass' being overriden by subclasses

    /* First way of doing it
    override static func classFunctionToBeMakeFinalInImmediateSubclass(){
    }
    */

    // Second way of doing the same
    override final class func classFunctionToBeMakeFinalInImmediateSubclass(){
    }

    //To use static or final class is choice of style.
    //As mipadi suggests I would use. static at super class. and final class to cut off further overrides by a subclass
}

class C: B{
    //Compile Error. Class method overrides a 'final' class method
    override static func classFunctionToBeMakeFinalInImmediateSubclass(){

    }
}

Em relação ao POO , a resposta é muito simples:

As subclasses podem substituir métodos de classe , mas não podem substituir métodos estáticos .

Além da sua postagem, se você quiser declarar uma variável de classe (como você fez class var myVar2 = ""), faça o seguinte:

class var myVar2: String {
    return "whatever you want"
}

Eu também peguei essa confusão em um dos meus projetos e achei este post muito útil. Tentei o mesmo no meu playground e aqui está o resumo. Espero que isso ajude alguém com propriedades e funções do tipo armazenados static, final, class, classe substituindo vars etc.

class Simple {

    init() {print("init method called in base")}

    class func one() {print("class - one()")}

    class func two() {print("class - two()")}

    static func staticOne() {print("staticOne()")}

    static func staticTwo() {print("staticTwo()")}

    final func yesFinal() {print("yesFinal()")}

    static var myStaticVar = "static var in base"

    //Class stored properties not yet supported in classes; did you mean 'static'?
    class var myClassVar1 = "class var1"

    //This works fine
    class var myClassVar: String {
       return "class var in base"
    }
}

class SubSimple: Simple {
    //Successful override
    override class func one() {
        print("subClass - one()")
    }
    //Successful override
    override class func two () {
        print("subClass - two()")
    }

    //Error: Class method overrides a 'final' class method
    override static func staticOne() {

    }

    //error: Instance method overrides a 'final' instance method
    override final func yesFinal() {

    }

    //Works fine
    override class var myClassVar: String {
        return "class var in subclass"
    }
}

E aqui estão as amostras de teste:

print(Simple.one())
print(Simple.two())
print(Simple.staticOne())
print(Simple.staticTwo())
print(Simple.yesFinal(Simple()))
print(SubSimple.one())
print(Simple.myStaticVar)
print(Simple.myClassVar)
print(SubSimple.myClassVar)

//Output
class - one()
class - two()
staticOne()
staticTwo()
init method called in base
(Function)
subClass - one()
static var in base
class var in base
class var in subclass

Os testes no Swift 4 mostram a diferença de desempenho no simulador. Eu fiz uma classe com "class func" e struct com "static static" e as executei no teste.

func estático é:

• 20% mais rápido sem otimização do compilador
• 38% mais rápido quando a otimização -whole-module-optimization está ativada.

No entanto, a execução do mesmo código no iPhone 7 no iOS 10.3 mostra exatamente o mesmo desempenho.

Aqui está um exemplo de projeto no Swift 4 para Xcode 9, se você quiser se testar https://github.com/protyagov/StructVsClassPerformance

Há mais uma diferença. classpode ser usado para definir apenas propriedades de tipo computado . Se você precisar de uma propriedade de tipo armazenado, use static.

"Você define propriedades de tipo com a palavra-chave estática. Para propriedades de tipo computadas para tipos de classe, você pode usar a palavra-chave de classe para permitir que as subclasses substituam a implementação da superclasse."

Adicionar as respostas acima aos métodos estáticos é despacho estático significa que o compilador sabe qual método será executado em tempo de execução, pois o método estático não pode ser substituído, enquanto o método da classe pode ser um despacho dinâmico, pois a subclasse pode substituí-los.

Há mais uma diferença. A classe pode ser usada para definir somente propriedades de tipo computado. Se você precisar de uma propriedade de tipo armazenado, use static.

Classe: - tipo de referência

struct: - tipo de valor

classé usado dentro Reference Type(classe):

• propriedade computada
• método
• pode ser substituído pela subclasse

staticé usado dentro Reference Typee Value Type(classe, enum):

• propriedade computada e propriedade armazenada
• método
• não pode ser alterado pela subclasse

protocol MyProtocol {
//    class var protocolClassVariable : Int { get }//ERROR: Class properties are only allowed within classes
    static var protocolStaticVariable : Int { get }

//    class func protocolClassFunc()//ERROR: Class methods are only allowed within classes
    static func protocolStaticFunc()
}

struct ValueTypeStruct: MyProtocol {
    //MyProtocol implementation begin
    static var protocolStaticVariable: Int = 1

    static func protocolStaticFunc() {

    }
    //MyProtocol implementation end

//    class var classVariable = "classVariable"//ERROR: Class properties are only allowed within classes
    static var staticVariable = "staticVariable"

//    class func classFunc() {} //ERROR: Class methods are only allowed within classes
    static func staticFunc() {}
}

class ReferenceTypeClass: MyProtocol {
    //MyProtocol implementation begin
    static var protocolStaticVariable: Int = 2

    static func protocolStaticFunc() {

    }
    //MyProtocol implementation end

    var variable = "variable"

//    class var classStoredPropertyVariable = "classVariable"//ERROR: Class stored properties not supported in classes

    class var classComputedPropertyVariable: Int {
        get {
            return 1
        }
    }

    static var staticStoredPropertyVariable = "staticVariable"

    static var staticComputedPropertyVariable: Int {
        get {
            return 1
        }
    }

    class func classFunc() {}
    static func staticFunc() {}
}

final class FinalSubReferenceTypeClass: ReferenceTypeClass {
    override class var classComputedPropertyVariable: Int {
        get {
            return 2
        }
    }
    override class func classFunc() {}
}

//class SubFinalSubReferenceTypeClass: FinalSubReferenceTypeClass {}// ERROR: Inheritance from a final class

[Referência versus tipo de valor]