Nell'istanza Objective-C i dati possono essere public, protectedo private. Per esempio:
@interface Foo : NSObject
{
@public
int x;
@protected:
int y;
@private:
int z;
}
-(int) apple;
-(int) pear;
-(int) banana;
@end
Non ho trovato alcuna menzione di modificatori di accesso nel riferimento Swift. È possibile limitare la visibilità dei dati in Swift?
Risposte:
A partire da Swift 3.0.1 , sono disponibili 4 livelli di accesso , descritti di seguito dal più alto (meno restrittivo) al più basso (più restrittivo).
openepublicAbilita l'utilizzo di un'entità al di fuori del modulo di definizione (destinazione). In genere si utilizza openo si publicaccede quando si specifica l'interfaccia pubblica a un framework.
Tuttavia, l' openaccesso si applica solo alle classi e ai membri della classe e differisce publicdall'accesso come segue:
public le classi e i membri della classe possono essere sottoclassati e sovrascritti solo all'interno del modulo di definizione (destinazione).open le classi ei membri della classe possono essere sottoclassi e sovrascritti sia all'interno che all'esterno del modulo di definizione (target).// First.framework – A.swift
open class A {}
// First.framework – B.swift
public class B: A {} // ok
// Second.framework – C.swift
import First
internal class C: A {} // ok
// Second.framework – D.swift
import First
internal class D: B {} // error: B cannot be subclassed
internalConsente di utilizzare un'entità all'interno del modulo di definizione (destinazione). In genere si utilizza l' internalaccesso quando si definisce la struttura interna di un'app o di un framework.
// First.framework – A.swift
internal struct A {}
// First.framework – B.swift
A() // ok
// Second.framework – C.swift
import First
A() // error: A is unavailable
fileprivateLimita l'uso di un'entità al file di origine che lo definisce. In genere si utilizza l' fileprivateaccesso per nascondere i dettagli di implementazione di una parte specifica di funzionalità quando tali dettagli vengono utilizzati all'interno di un intero file.
// First.framework – A.swift
internal struct A {
fileprivate static let x: Int
}
A.x // ok
// First.framework – B.swift
A.x // error: x is not available
privateLimita l'uso di un'entità alla sua dichiarazione allegata. In genere si utilizza l' privateaccesso per nascondere i dettagli di implementazione di una parte specifica di funzionalità quando tali dettagli vengono utilizzati solo all'interno di una singola dichiarazione.
// First.framework – A.swift
internal struct A {
private static let x: Int
internal static func doSomethingWithX() {
x // ok
}
}
A.x // error: x is unavailable
Come indicato nella documentazione Swift - Controllo degli accessi , Swift ha 5 controlli di accesso :
aperto e pubblico : è possibile accedervi dalle entità del loro modulo e da qualsiasi entità del modulo che importa il modulo di definizione.
interno : è possibile accedervi solo dalle entità del loro modulo. È il livello di accesso predefinito.
fileprivato e privato : è possibile accedervi solo in modo limitato entro un ambito limitato in cui vengono definiti.
open è uguale a public nelle versioni precedenti di Swift, consente alle classi di altri moduli di usarli ed ereditarli, cioè: possono essere sottoclassi da altri moduli. Inoltre, consentono ai membri di altri moduli di utilizzarli e sovrascriverli. La stessa logica vale per i loro moduli.
public consente alle classi di altri moduli di usarli, ma non di ereditarli, cioè: non possono essere sottoclassi da altri moduli. Inoltre, consentono ai membri di altri moduli di usarli, ma NON di sovrascriverli. Per i loro moduli, hanno la stessa logica di apertura (consentono alle classi di usarli ed ereditarli; consentono ai membri di usarli e sovrascriverli).
fileprivate è accessibile da tutti i file.
è possibile accedere a private solo dalla loro singola dichiarazione e dalle estensioni di quella dichiarazione che si trovano nello stesso file; Per esempio:
// Declaring "A" class that has the two types of "private" and "fileprivate":
class A {
private var aPrivate: String?
fileprivate var aFileprivate: String?
func accessMySelf() {
// this works fine
self.aPrivate = ""
self.aFileprivate = ""
}
}
// Declaring "B" for checking the abiltiy of accessing "A" class:
class B {
func accessA() {
// create an instance of "A" class
let aObject = A()
// Error! this is NOT accessable...
aObject.aPrivate = "I CANNOT set a value for it!"
// this works fine
aObject.aFileprivate = "I CAN set a value for it!"
}
}
Come menzionato nella proposta SE-0169 , l'unico perfezionamento aggiunto a Swift 4 è che l' ambito del controllo dell'accesso privato è stato ampliato per essere accessibile dalle estensioni di tale dichiarazione nello stesso file; Per esempio:
struct MyStruct {
private let myMessage = "Hello World"
}
extension MyStruct {
func printMyMessage() {
print(myMessage)
// In Swift 3, you will get a compile time error:
// error: 'myMessage' is inaccessible due to 'private' protection level
// In Swift 4 it should works fine!
}
}
Quindi, non è necessario dichiarare myMessagecome file privato per essere accessibile in tutto il file.
Quando si parla di creare un "metodo privato" in Swift o ObjC (o ruby o java o ...) questi metodi non sono realmente privati. Non esiste un controllo di accesso effettivo intorno a loro. Qualsiasi linguaggio che offra anche un po 'di introspezione consente agli sviluppatori di ottenere quei valori dall'esterno della classe, se lo desiderano.
Quindi quello di cui stiamo veramente parlando qui è un modo per definire un'interfaccia pubblica che si limita a presentare le funzionalità che vogliamo e "nasconde" il resto che consideriamo "privato".
Il meccanismo di Swift per la dichiarazione delle interfacce è protocol, e può essere utilizzato a questo scopo.
protocol MyClass {
var publicProperty:Int {get set}
func publicMethod(foo:String)->String
}
class MyClassImplementation : MyClass {
var publicProperty:Int = 5
var privateProperty:Int = 8
func publicMethod(foo:String)->String{
return privateMethod(foo)
}
func privateMethod(foo:String)->String{
return "Hello \(foo)"
}
}
Ricorda, i protocolli sono tipi di prima classe e possono essere utilizzati ovunque un tipo può. E , se usati in questo modo, espongono solo le proprie interfacce, non quelle del tipo di implementazione.
Quindi, fintanto che usi MyClassinvece che MyClassImplementationnei tuoi tipi di parametri, ecc. Dovrebbe funzionare tutto:
func breakingAndEntering(foo:MyClass)->String{
return foo.privateMethod()
//ERROR: 'MyClass' does not have a member named 'privateMethod'
}
Ci sono alcuni casi di assegnazione diretta in cui devi essere esplicito con il tipo invece di fare affidamento su Swift per dedurlo, ma questo non sembra un problema:
var myClass:MyClass = MyClassImplementation()
Usare i protocolli in questo modo è semantico, ragionevolmente conciso e ai miei occhi assomiglia molto alle estensioni di classe che abbiamo usato per questo scopo in ObjC.
Per quanto ne so, non ci sono parole chiave "public", "private" o "protected". Ciò suggerirebbe che tutto sia pubblico.
Tuttavia, Apple potrebbe aspettarsi che le persone utilizzino " protocolli " (chiamati interfacce dal resto del mondo) e il modello di progettazione di fabbrica per nascondere i dettagli del tipo di implementazione.
Questo è spesso un buon modello di progettazione da utilizzare comunque; poiché consente di modificare la gerarchia delle classi di implementazione , mantenendo lo stesso sistema di tipi logici .
Utilizzando una combinazione di protocolli, chiusure e classi nidificate / interne, è possibile utilizzare qualcosa sulla falsariga del modello del modulo per nascondere le informazioni in Swift in questo momento. Non è super pulito o piacevole da leggere ma funziona.
Esempio:
protocol HuhThing {
var huh: Int { get set }
}
func HuhMaker() -> HuhThing {
class InnerHuh: HuhThing {
var innerVal: Int = 0
var huh: Int {
get {
return mysteriousMath(innerVal)
}
set {
innerVal = newValue / 2
}
}
func mysteriousMath(number: Int) -> Int {
return number * 3 + 2
}
}
return InnerHuh()
}
HuhMaker()
var h = HuhMaker()
h.huh // 2
h.huh = 32
h.huh // 50
h.huh = 39
h.huh // 59
innerVal e mysteryMath sono nascosti qui dall'uso esterno e il tentativo di scavare nell'oggetto dovrebbe risultare in un errore.
Sono solo una parte del percorso attraverso la mia lettura dei documenti di Swift, quindi se c'è un difetto qui per favore segnalalo, mi piacerebbe saperlo.
reflect(h)[0].1.value // 19
A partire da Xcode 6 beta 4, Swift ha modificatori di accesso. Dalle note di rilascio:
Swift access control ha tre livelli di accesso:
- È possibile accedere alle entità private solo dall'interno del file di origine in cui sono definite.
- È possibile accedere alle entità interne ovunque all'interno del target in cui sono definite.
- È possibile accedere alle entità pubbliche da qualsiasi punto all'interno del target e da qualsiasi altro contesto che importi il modulo del target corrente.
Il valore predefinito implicito è internal, quindi all'interno di una destinazione dell'applicazione è possibile lasciare disattivati i modificatori di accesso tranne dove si desidera essere più restrittivi. In un framework di destinazione (ad esempio, se stai incorporando un framework per condividere il codice tra un'app e una condivisione o un'estensione della vista Oggi), utilizza publicper designare l'API che desideri esporre ai client del tuo framework.
Swift 3.0 fornisce cinque diversi controlli di accesso:
L' accesso aperto e l' accesso pubblico consentono alle entità di essere utilizzate all'interno di qualsiasi file sorgente dal loro modulo di definizione e anche in un file sorgente da un altro modulo che importa il modulo di definizione. In genere si utilizza l'accesso aperto o pubblico quando si specifica l'interfaccia pubblica a un framework.
L' accesso interno consente alle entità di essere utilizzate all'interno di qualsiasi file sorgente dal loro modulo di definizione, ma non in alcun file sorgente al di fuori di quel modulo. In genere si utilizza l'accesso interno quando si definisce la struttura interna di un'app o di un framework.
L' accesso al file privato limita l'uso di un'entità al proprio file di origine di definizione. Utilizzare l'accesso privato al file per nascondere i dettagli di implementazione di una parte specifica di funzionalità quando tali dettagli vengono utilizzati all'interno di un intero file.
L' accesso privato limita l'uso di un'entità alla dichiarazione allegata. Utilizzare l'accesso privato per nascondere i dettagli di implementazione di una parte specifica di funzionalità quando tali dettagli vengono utilizzati solo all'interno di una singola dichiarazione.
L' accesso aperto è il livello di accesso più alto (meno restrittivo) e l' accesso privato è il livello di accesso più basso (più restrittivo).
Livelli di accesso predefiniti
Tutte le entità nel codice (con poche eccezioni specifiche) hanno un livello di accesso predefinito interno se non si specifica un livello di accesso esplicito. Di conseguenza, in molti casi non è necessario specificare un livello di accesso esplicito nel codice.
La nota di rilascio sull'argomento:
Le classi dichiarate come pubbliche non possono più essere sottoclasse al di fuori del loro modulo di definizione, ei metodi dichiarati come pubblici non possono più essere sovrascritti al di fuori del loro modulo di definizione. Per consentire a una classe di essere sottoclasse esternamente o un metodo di essere sovrascritto esternamente, dichiararli come aperti, che è un nuovo livello di accesso oltre al pubblico. Le classi e i metodi Objective-C importati sono ora tutti importati come aperti anziché pubblici. I test unitari che importano un modulo utilizzando un'importazione @testable potranno comunque subclassare classi pubbliche o interne, nonché sostituire metodi pubblici o interni. (SE-0117)
Maggiori informazioni e dettagli: The Swift Programming Language (controllo degli accessi)
Nella Beta 6, la documentazione afferma che ci sono tre diversi modificatori di accesso:
E questi tre si applicano a classi, protocolli, funzioni e proprietà.
public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}
Per ulteriori informazioni, controlla Controllo degli accessi .
Ora nella beta 4, hanno aggiunto modificatori di accesso a Swift.
dalle note di Xcode 6 beta 4 realese :
Swift access control ha tre livelli di accesso:
privateè possibile accedere alle entità solo dall'interno del file sorgente in cui sono de fi nite.internalè possibile accedere alle entità ovunque all'interno della destinazione in cui sono de fi nite.publicè possibile accedere alle entità da qualsiasi punto all'interno del target e da qualsiasi altro contesto che importi il modulo del target corrente.Per impostazione predefinita, la maggior parte delle entità in un file di origine ha accesso interno. Ciò consente agli sviluppatori di applicazioni di ignorare in gran parte il controllo degli accessi, consentendo agli sviluppatori di framework il pieno controllo sull'API di un framework.
Swift fornisce tre diversi livelli di accesso per le entità all'interno del codice. Questi livelli di accesso sono relativi al file di origine in cui è definita un'entità e anche al modulo a cui appartiene il file di origine.
- L'accesso pubblico consente alle entità di essere utilizzate all'interno di qualsiasi file di origine dal loro modulo di definizione e anche in un file di origine da un altro modulo che importa il modulo di definizione. In genere si utilizza l'accesso pubblico quando si specifica l'interfaccia pubblica a un framework.
- L'accesso interno consente alle entità di essere utilizzate all'interno di qualsiasi file sorgente dal loro modulo di definizione, ma non in alcun file sorgente al di fuori di quel modulo. In genere si utilizza l'accesso interno quando si definisce la struttura interna di un'app o di un framework.
- L'accesso privato limita l'uso di un'entità al proprio file sorgente di definizione. Usa l'accesso privato per nascondere i dettagli di implementazione di una parte specifica di funzionalità.
L'accesso pubblico è il livello di accesso più alto (meno restrittivo) e l'accesso privato è il livello di accesso più basso (o più restrittivo).
L'accesso predefinito è interno e in quanto tale non è necessario specificarlo. Notare inoltre che l' identificatore privato non funziona a livello di classe, ma a livello di file di origine. Ciò significa che per ottenere parti di una classe veramente private è necessario separarle in un file a parte. Questo introduce anche alcuni casi interessanti per quanto riguarda i test unitari ...
Un altro punto che ho fatto, che è commentato nel link sopra, è che non è possibile "aggiornare" il livello di accesso. Se sottoclassi qualcosa, puoi restringerlo di più, ma non il contrario.
Quest'ultimo bit influenza anche le funzioni, le tuple e sicuramente altre cose nel modo in cui se una funzione usa una classe privata , allora non è valido avere la funzione interna o pubblica , poiché potrebbero non avere accesso alla classe privata . Ciò si traduce in un avviso del compilatore ed è necessario dichiarare nuovamente la funzione come funzione privata .
Swift 3 e 4 hanno portato molti cambiamenti anche per i livelli di accesso di variabili e metodi. Swift 3 e 4 ora hanno 4 diversi livelli di accesso, dove l' accesso aperto / pubblico è il livello di accesso più alto (meno restrittivo) e l' accesso privato è il livello di accesso più basso (più restrittivo):
Interessante:
Invece di contrassegnare ogni singolo metodo o membro come "privato", è possibile coprire alcuni metodi (ad esempio in genere le funzioni di supporto) in un'estensione di una classe / struttura e contrassegnare l'intera estensione come "Privato".
class foo { }
private extension foo {
func somePrivateHelperFunction01() { }
func somePrivateHelperFunction02() { }
func somePrivateHelperFunction03() { }
}
Questa può essere una buona idea per ottenere un codice gestibile migliore. E puoi facilmente passare (ad esempio per test di unità) a non privato cambiando solo una parola.
Per Swift 1-3:
No, non è possibile. Non esistono affatto metodi e variabili privati / protetti.
Tutto è pubblico.
Aggiornamento A partire da Swift 4, è possibile vedere altre risposte in questo thread
Una delle opzioni che potresti usare è racchiudere la creazione dell'istanza in una funzione e fornire i getter e setter appropriati in un costruttore:
class Counter {
let inc: () -> Int
let dec: () -> Int
init(start: Int) {
var n = start
inc = { ++n }
dec = { --n }
}
}
let c = Counter(start: 10)
c.inc() // 11
c.inc() // 12
c.dec() // 11
La grammatica della lingua non ha le parole chiave "public", "private" o "protected". Ciò suggerirebbe che tutto sia pubblico. Naturalmente, potrebbe esserci un metodo alternativo per specificare i modificatori di accesso senza quelle parole chiave, ma non sono riuscito a trovarlo nel riferimento del linguaggio.
Si spera di risparmiare un po 'di tempo per coloro che desiderano qualcosa di simile ai metodi protetti:
Come per altre risposte, swift ora fornisce il modificatore "privato", che è definito per file piuttosto che per classe come quelli in Java o C # per esempio. Ciò significa che se desideri metodi protetti, puoi farlo con metodi privati rapidi se si trovano nello stesso file
ad es. File 1:
class BaseClass {
private func protectedMethod() {
}
}
class SubClass : BaseClass {
func publicMethod() {
self.protectedMethod() //this is ok as they are in same file
}
}
File 2:
func test() {
var a = BaseClass()
a.protectedMethod() //ERROR
var b = SubClass()
b.protectedMethod() //ERROR
}
class SubClass2 : BaseClass {
func publicMethod() {
self.protectedMethod() //ERROR
}
}
AVVIO DI SWIFT 2.2;)
Per impostazione predefinita Interno
fino a swift 2.0 c'erano solo tre livelli di accesso [Pubblico, interno, privato] ma in swift 3.0 apple aggiungeva due nuovi livelli di accesso che sono [Open, fileType] quindi ora in swift 3.0 ci sono 5 livelli di accesso Qui voglio cancellare il ruolo di questi due livelli di accesso 1. Aperto: questo è molto simile a Pubblico ma l'unica differenza è che il Pubblico può accedere alla sottoclasse e sovrascriverlo, e il livello di accesso Aperto non può accedervi questa immagine è presa dal sito web di Medium e questo descrive la differenza tra accesso aperto e pubblico
Ora al secondo nuovo livello di accesso 2. filetypeèuna versione più grande di private o un livello di accesso inferiore a interno Il fileType può accedere alla parte estesa di [class, struct, enum] e private non può accedere alla parte estesa di codice a cui può solo accedere l'ambito lessicale questa immagine è tratta dal sito web di Medium e descrive la differenza tra fileType e livello di accesso privato