Secondo la documentazione ufficiale swift

“Il controllo accessi limita l’accesso a parti del codice dal codice in altri file e moduli sorgente. Questa funzione consente di nascondere i dettagli di implementazione del codice e di specificare un’interfaccia preferita attraverso la quale è possibile accedere e utilizzare tale codice.”

Swift 5 ha cinque controllo di accesso. Sono aperti, pubblici, interni, privati e privati. Tali controlli di accesso sono definiti in base agli usi nel modulo e nel file sorgente. In questo tutorial, impareremo cosa, dove e come utilizzare il controllo degli accessi in swift.

open (meno restrittivo)

Tutto ciò che definisce con open è accessibile all’interno o senza il modulo. le entità a livello di accesso aperto sono accessibili da qualsiasi luogo. Ciò significa che una variabile aperta può accedere, una funzione aperta può sovrascrivere e la classe aperta può essere sottoclasse all’interno di un modulo e all’esterno di un modulo importando quel modulo.

Un esempio è la classe “UITableViewCell” nel framework UIKit. Possiamo sottoclasse qualsiasi classe come classe UITableViewCell importando il modulo UIKit. Se vedi la definizione di “UITableViewCell”, vedrai il controllo di accesso aperto prima della definizione della classe all’interno del modulo UIKit. Ecco perché possiamo sottoclasse qualsiasi classe come classe UITableViewCell importando UIKit.

@available(iOS 2.0, *)open class UITableViewCell : UIView, NSCoding, UIGestureRecognizerDelegate { }

pubblico (restrittivo rispetto all’aperto)

Come l’accesso aperto, è possibile accedere anche alle entità pubbliche all’interno o all’esterno di un modulo. Ma c’è una grande differenza tra aperto e pubblico.

la classe pubblica non può essere sottoclassata e il metodo pubblico non può essere sovrascritto al di fuori del modulo definito. Deve essere necessario sottoclasse o sovrascrivere all’interno del modulo in cui hanno definito.

Controlla l’esempio seguente

//module 1open class X{}
open func bar(){}public class Y{}
public func foo(){}//module 2class A: X{} // success
override func bar(){} // successclass B: Y{} //error
override func foo(){} // error

interno ( controllo di accesso a livello di modulo)

“interno” abilita l’uso di entità ovunque all’interno del modulo definito. “interno” è il livello di accesso predefinito. Normalmente un modulo è un framework o un’app che può essere utilizzata come una singola unità.

All’interno di un target (modulo) tutte le entità sono di default interne (se esplicitamente non ha definito alcun controllo di accesso). È definito in questo modo che tutto all’interno del modulo può essere accessibile da chiunque da qualsiasi punto all’interno di quel modulo.

fileprivate( controllo di accesso a livello di file)

le entità fileprivate possono essere accessibili solo all’interno di un file swift. Un file swift può avere diverse classi o strutture. Tutte le entità private di file all’interno di un file swift sono accessibili da tutte le classi o strutture in quel file. Senza di loro, qualsiasi altra classe al di fuori di quel file non può accedervi. Generalmente nasconde l’implementazione da altri file sorgente del modulo.

//** ViewController.swift **//class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad() let a = A()
a.x()
a.z() //error let b = B()
b.Y() // error
}
}class A {fileprivate func x(){
print("Inside ViewController file")
}
}
//** SecondViewController.swift **//class B{fileprivate func Y(){
print("Outside ViewController file")
}
}extension A{
fileprivate func Z(){
print("Outside ViewController file, extension of A")
}
}

private( controllo di accesso a livello di classe)

private è il controllo di accesso più utilizzato e più limitato. Le entità private possono accedere solo all’interno della classe (inclusa l’estensione) che hanno dichiarato. Viene generalmente utilizzato per nascondere l’implementazione o la funzionalità interna al di fuori di una classe specifica.

// ** ViewController.swift **//class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
x()
let a = A()
a.Y() // error
}
}extension ViewController{
private func x(){
print("Inside x")
}
}class A {
private func Y(){
print("Inside Y")
}
}

Differenza tra l’accesso rapido controllo

Ora vedremo la differenza tra quelli modificatore di accesso in base a diversi parametri, come una forma di tabella

Congratulazioni 🎉 🎉 🎉 credo che ora hai qualche idea sul controllo di accesso nel linguaggio di programmazione swift. Troverete una breve discussione di loro sulla documentazione ufficiale swift.

Se hai trovato questo articolo utile si prega di condividere e dare qualche applauso Controllare i miei altri articoli su Medium e collegarmi su LinkedIn.

Grazie per aver letto & Felice codifica 🙂

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.