Funzioni / variabili statiche vs di classe nelle classi Swift?

Il seguente codice viene compilato in Swift 1.2:

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

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

Qual è la differenza tra una funzione statica e una funzione di classe ? Quale dovrei usare e quando?

Se provo a definire un'altra variabile class var myVar2 = "", dice:

Proprietà archiviate della classe non ancora supportate nelle classi; intendevi "statico"?

Quando questa funzione è supportata, quale sarà la differenza tra una variabile statica e una variabile di classe (ovvero quando entrambe sono definite in una classe)? Quale dovrei usare e quando?

(Xcode 6.3)

staticed classentrambi associano un metodo a una classe, piuttosto che un'istanza di una classe. La differenza è che le sottoclassi possono ignorare i classmetodi; non possono ignorare i staticmetodi.

class le proprietà funzioneranno teoricamente allo stesso modo (le sottoclassi possono sovrascriverle), ma non sono ancora possibili in Swift.

Ho provato la risposta e i commenti di mipadi nel parco giochi. E ho pensato di condividerlo. Ecco qui. Penso che la risposta di mipadi dovrebbe essere contrassegnata come accettata.

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(){

    }
}

Per quanto riguarda OOP , la risposta è troppo semplice:

Le sottoclassi possono ignorare i metodi di classe , ma non possono ignorare i metodi statici .

Oltre al tuo post, se vuoi dichiarare una variabile di classe (come hai fatto tu class var myVar2 = ""), dovresti farlo come segue:

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

Ho avuto questa confusione anche in uno dei miei progetti e ho trovato questo post molto utile. Ho provato lo stesso nel mio parco giochi ed ecco il riassunto. Spero che questo aiuti qualcuno con proprietà e le funzioni di tipo memorizzati static, final, class, classe sovrascrivendo 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"
    }
}

Ed ecco gli esempi di test:

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

I test in Swift 4 mostrano differenze di prestazioni nel simulatore. Ho creato una classe con "class func" e struct con "static func" e li ho eseguiti in prova.

la funzione statica è:

• 20% più veloce senza ottimizzazione del compilatore
• 38% più veloce quando è abilitata l'ottimizzazione dell'intero modulo.

Tuttavia, eseguire lo stesso codice su iPhone 7 con iOS 10.3 mostra esattamente le stesse prestazioni.

Ecco un esempio di progetto in Swift 4 per Xcode 9 se ti piace metterti alla prova https://github.com/protyagov/StructVsClassPerformance

C'è un'altra differenza. classpuò essere utilizzato per definire solo le proprietà del tipo di tipo calcolato . Se invece hai bisogno di una proprietà di tipo memorizzato usa staticinvece.

"Definisci le proprietà del tipo con la parola chiave statica. Per le proprietà del tipo calcolate per i tipi di classe, puoi invece utilizzare la parola chiave class per consentire alle sottoclassi di sovrascrivere l'implementazione della superclasse."

Aggiungendo alle risposte precedenti i metodi statici sono invio statico significa che il compilatore sa quale metodo verrà eseguito in fase di esecuzione poiché il metodo statico non può essere sovrascritto mentre il metodo di classe può essere un invio dinamico poiché la sottoclasse può ignorarli.

C'è un'altra differenza. La classe può essere utilizzata per definire le proprietà del tipo solo di tipo calcolato. Se è necessaria una proprietà di tipo memorizzato, utilizzare statico.

Classe: - tipo di riferimento

struct: - tipo di valore

classè usato all'interno Reference Type(classe):

• proprietà calcolata
• metodo
• può essere sovrascritto dalla sottoclasse

staticè usato dentro Reference Typee Value Type(classe, enum):

• proprietà calcolata e proprietà memorizzata
• metodo
• non può essere modificato dalla sottoclasse

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

[Tipo di riferimento vs tipo di valore]