Qual è la differenza tra un protocollo esteso da AnyObject e un protocollo di solo classe?

Question

Sia questa dichiarazione

protocol SomeProtocol : AnyObject { 
} 

e questa dichiarazione

protocol SomeProtocol : class { 
} 

sembrano fare in modo che solo le classi possono essere conformi a questo protocollo (vale a dire che le istanze del protocollo sono riferimenti agli oggetti), e non avere altri effetti

C'è qualche differenza tra loro? Si dovrebbe preferire l'altro? Se no, perché ci sono due modi per fare la stessa cosa?

Sto usando l'ultimo Xcode rilasciato 6.3.1.

Answer 1

Ho fatto un misspoke prima. @ Martinin dovrebbe davvero rispondere a questa domanda, poiché è lui a correggermi e a fornire le informazioni corrette.

La differenza reale è che un protocollo con il qualificatore di classe può essere applicato solo a una classe, non a una struct o enum.

Martin, perché non rispondi e l'OP può accettare la tua risposta?

Answer 2

AnyObject è un protocollo a cui tutte le classi sono implicitamente conformi (source). Quindi direi che non c'è differenza: puoi usare entrambi per richiedere un vincolo di classe.

Answer 3

Aggiornamento: Dopo essersi consultato con the powers that be, le due definizioni sono supposto essere equivalente, con AnyObject essere utilizzato come uno stand-in, mentre class veniva finito. In futuro il secondo eliminerà il primo ma, per ora, presentano alcune piccole differenze.

La differenza sta nella semantica delle dichiarazioni @objc. Con AnyObject, l'aspettativa è che le classi conformi possano o meno essere oggetti Objective-C corretti, ma la lingua li tratta comunque (in quanto a volte si perde il dispatch statico). Da questo punto di vista è possibile trattare uno AnyObject e altri. vincolo protocollo come un modo per chiedere @objc funzioni membro come mostrato nell'esempio nella documentazione per AnyObject nel STL:

import Foundation 
class C { 
    @objc func getCValue() -> Int { return 42 } 
} 

// If x has a method @objc getValue()->Int, call it and 
// return the result. Otherwise, return nil. 
func getCValue1(x: AnyObject) -> Int? { 
    if let f:()->Int = x.getCValue { // <=== 
     return f() 
    } 
    return nil 
} 
// A more idiomatic implementation using "optional chaining" 
func getCValue2(x: AnyObject) -> Int? { 
    return x.getCValue?() // <=== 
} 
// An implementation that assumes the required method is present 
func getCValue3(x: AnyObject) -> Int { // <=== 
    return x.getCValue() // x.getCValue is implicitly unwrapped. // <=== 
} 

Lo stesso esempio cade immediatamente se si modifica che ad un protocollo class -deriving:

import Foundation 

protocol SomeClass : class {} 

class C : SomeClass { 
    @objc func getCValue() -> Int { return 42 } 
} 

// If x has a method @objc getValue()->Int, call it and 
// return the result. Otherwise, return nil. 
func getCValue1(x: SomeClass) -> Int? { 
    if let f:()->Int = x.getCValue { // <=== SomeClass has no member 'getCValue' 
     return f() 
    } 
    return nil 
} 

// A more idiomatic implementation using "optional chaining" 
func getCValue2(x: SomeClass) -> Int? { 
    return x.getCValue?() // <=== SomeClass has no member 'getCValue' 
} 

// An implementation that assumes the required method is present 
func getCValue3(x: SomeClass) -> Int { // <=== 
    return x.getCValue() // <=== SomeClass has no member 'getCValue' 
} 

così sembra class è una versione più conservativa di AnyObject che deve essere utilizzato quando vi interessa soltanto la semantica di riferimento e non sulle ricerche membri dinamici o Objective-C bridging.

Answer 4

Nella sezione The Swift Programming Language (Swift 4), nella sezione Protocolli di sola classe. Ha menzionato solo AnyObject, ma non class.

È possibile limitare l'adozione del protocollo ai tipi di classe (e non a strutture o enumerazioni) aggiungendo il protocollo AnyObject all'elenco di ereditarietà di un protocollo.

protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol { 
    // class-only protocol definition goes here 
} 

Per questo motivo, io ti suggerirei di usare AnyObject sopra class per il nuovo codice o nuovo progetto. Oltre a questo, non vedo alcuna differenza evidente tra loro.