Tut Swift zugriffsmodifizierer?

Von Swift 3.0.1 gibt es " 4-Ebenen-Zugang, wie unten beschrieben, von der die höchste (am wenigsten restriktiv) zu den niedrigsten (strengsten).

1. open und public

Aktivieren einer Entität verwendet werden, die außerhalb des definierenden Moduls (Ziel). Verwenden Sie in der Regel open oder public zugreifen, wenn Sie die öffentliche Schnittstelle zu einem framework.

Jedoch open Zugang gilt nur für Klassen und Schüler, und es unterscheidet sich von public Zugang wie folgt:

• public Klassen und Klassenmember können nur Unterklassen und überschrieben wird innerhalb der Definition-Modul (target).
• open Klassen und Klassenmember können als Unterklasse definiert und überschrieben, sowohl innerhalb als auch außerhalb des definierenden Moduls (Ziel).

//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

2. internal

Ermöglicht es, eine Einheit zu sein innerhalb der Definition-Modul (target). Verwenden Sie in der Regel internal Zugang bei der Definition einer app oder einem framework ' s interner Struktur.

//First.framework – A.swift

internal struct A {}

//First.framework – B.swift

A() // ok

//Second.framework – C.swift

import First

A() // error: A is unavailable

3. fileprivate

Schränkt die Verwendung von einer Entität zu seiner Definition von Quell-Datei. Verwenden Sie in der Regel fileprivate Zugang zu verstecken die details der Implementierung eines bestimmten Teil der Funktionalität, wenn diese details sind innerhalb einer gesamten Datei.

//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

4. private

Schränkt die Verwendung von einer Entität zu seiner umschließenden Erklärung. Verwenden Sie in der Regel private Zugang zu verstecken die details der Implementierung eines bestimmten Teil der Funktionalität, wenn Sie diese Angaben werden verwendet, nur in einer einzigen Erklärung.

//First.framework – A.swift

internal struct A {

    private static let x: Int

    internal static func doSomethingWithX() {
        x //ok
    }

}

A.x // error: x is unavailable

InformationsquelleAutor akashivskyy

Wenn man spricht über eine "private Methode" in Swift oder ObjC (oder ruby oder java oder...) diese Methoden sind nicht wirklich private. Es gibt keinen wirklichen Zugang Kontrolle um Sie herum. Jede Sprache, bietet sogar ein wenig Introspektion ermöglicht Entwicklern auf diese Werte außerhalb der Klasse, wenn Sie wirklich wollen.

Also, was wir wirklich reden hier ist eine Möglichkeit zur Definition einer öffentlichen Schnittstelle, die lediglich präsentiert die Funktionalität, die wir wollen, und "versteckt" die Ruhe, die wir als "privat".

Den Swift-Mechanismus für die Deklaration von Schnittstellen ist die protocol, und es kann für diesen Zweck verwendet werden.

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)"
  }
}

Denken Sie daran, die Protokolle sind erste-Klasse-Typen und kann verwendet werden, überall eine geben kann. Und, wenn verwendet, dieser Weg, Sie enthüllen nur Ihre eigenen interfaces, nicht die der Umsetzung geben.

So, so lange wie Sie MyClass statt MyClassImplementation in Ihrer parameter-Typen, etc. es sollte alles einfach funktionieren:

func breakingAndEntering(foo:MyClass)->String{
  return foo.privateMethod()
  //ERROR: 'MyClass' does not have a member named 'privateMethod'
}

Gibt es einige Fälle von der direkten Zuordnung, wo Sie explizit mit Typ-anstatt sich auf Swift zu erschließen, aber das scheint kaum ein deal breaker:

var myClass:MyClass = MyClassImplementation()

Unter Verwendung von Protokollen auf diese Weise semantisch, halbwegs übersichtlich, und für meine Augen sieht viel wie die Klasse Extentions wir haben mit für diesen Zweck in ObjC.

InformationsquelleAutor jemmons

Unter Verwendung einer Kombination von Protokollen, Verschlüsse und verschachtelte/innere Klassen, ist es möglich, etwas entlang der Linien von " das Modul-Muster zu verstecken Informationen in Swift jetzt. Es ist nicht super sauber oder schön zu Lesen, aber es funktioniert.

Beispiel:

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 und mysteriousMath sind hier versteckt, die von außerhalb nutzen und versuchen zu Graben Sie Ihren Weg in das Objekt sollte zu einem Fehler führen.

Ich bin nur Teil des Weges durch meine Lektüre des Swift-docs so, wenn es ein Fehler hier bitte zeigen Sie es aus, würde es gerne wissen.

InformationsquelleAutor Dave Kapp

Swift 3.0 bietet fünf verschiedene Zugangs-Kontrollen:

1. öffnen
2. öffentlichen
3. internen
4. fileprivate
5. private

Öffnen Zugang und öffentlichen Zugang ermöglichen Entitäten verwendet werden, innerhalb einer source-Datei von Ihrer Definition von Modul und auch in einem
Quell-Datei aus einem anderen Modul importiert das Modul definieren. Sie
in der Regel öffnen oder den Zugang der öffentlichkeit bei der Angabe der öffentlichen
Schnittstelle zu einem framework.

Internen Zugang ermöglicht, Entitäten verwendet werden, innerhalb einer source-Datei von Ihrer Definition Modul, nicht aber in einer Quelldatei außerhalb des
- Modul. In der Regel verwenden Sie den internen Zugriff bei der Definition einer app oder einem
framework ' s interner Struktur.

Datei-private Zugang schränkt die Nutzung auf ein Unternehmen zu seiner eigenen Definition von Quell-Datei. Verwenden Sie den Datei-privaten Zugang zum ausblenden der
details zur Implementierung einer bestimmten Funktionalität, wenn diese
details sind in einer gesamten Datei.

Private Zugang schränkt die Verwendung von eine Person, die den umschließenden Erklärung. Verwenden Sie einen privaten Zugang zum verstecken die details der Implementierung von
einen bestimmten Teil der Funktionalität, wenn Sie diese Angaben dienen nur
innerhalb einer einzigen Erklärung.

Öffnen Zugriff ist die höchste (am wenigsten restriktiv) Zugang Ebene und private Zugriff auf die niedrigsten (strengsten) Zugriff Ebene.

Standard-Zugriffsebenen

Alle Personen, die in Ihrem code (mit einigen spezifischen Ausnahmen) haben eine Standard-access-level der internen wenn Sie nicht geben Sie eine explizite Zugriffsberechtigung selbst. Als ein Ergebnis, in vielen Fällen brauchen Sie nicht zu geben Sie eine explizite Zugriffsberechtigung in Ihrem code.

Die release-note zu dem Thema:

Klassen als public deklariert, können Sie nicht mehr Unterklassen außerhalb der
Ihre Definition von Modul und Methoden als public deklariert, kann nicht mehr werden
überschrieben außerhalb Ihrer Definition-Modul. Zu erlauben, eine Klasse zu sein
extern Unterklassen eine Methode oder extern überschrieben, erklären
Sie als offen, das ist eine neue access-Ebene jenseits der öffentlichkeit. Importiert
Objective-C-Klassen und-Methoden sind jetzt alle importierten als offen, eher
als die öffentlichen. Unit-tests, importieren Sie ein Modul mit einer @import getestet werden
wird noch erlaubt sein, Unterklasse öffentliche oder interne Klassen sowie
als override public oder internen Methoden. (SE-0117)

Mehr Informationen & details :
Die Swift-Programmiersprache (Access Control)

InformationsquelleAutor CryingHippo

Access control-Mechanismen als eingeführt in Xcode 6:

Swift bietet drei verschiedene Zugriffsebenen für die Entitäten in Ihrem code. Diese Zugriffsebenen sind relativ zu der Quelldatei, in dem ein Element definiert ist, und auch relativ zum Modul-Quelldatei gehört.

• Zugang der öffentlichkeit ermöglicht Entitäten verwendet werden, innerhalb einer source-Datei von Ihrer Definition Modul, und auch in einer Quellcode-Datei aus einem anderen Modul importiert das Modul definieren. Sie verwenden in der Regel den öffentlichen Zugang bei der Angabe der öffentlichen Schnittstelle zu einem framework.
• Internen Zugriff ermöglicht Entitäten verwendet werden, innerhalb einer source-Datei von Ihrer Definition Modul, nicht aber in einer Quelldatei außerhalb des Moduls. In der Regel verwenden Sie den internen Zugriff bei der Definition einer app oder einem framework ' s interner Struktur.
• Privaten Zugang schränkt die Nutzung auf ein Unternehmen zu seiner eigenen Definition von Quell-Datei. Verwenden Sie einen privaten Zugang zum verstecken die details der Implementierung einer bestimmten Funktionalität.

Zugang der öffentlichkeit ist die höchste (am wenigsten restriktiv) Zugang Ebene und einen privaten Zugang ist das niedrigste (oder am meisten restriktiven) Zugriff Ebene.

Standard accecss es internen, und hat als solche nicht angegeben werden müssen. Beachten Sie auch, dass die private Planer hat nicht Arbeit auf Klassenebene, sondern auf der source-Datei-Ebene. Dies bedeutet, dass man Teile einer Klasse wirklich privaten müssen Sie getrennt in eine Datei. Dies führt auch einige interessante Fälle mit Bezug auf unit-Tests...

Ein weiterer Punkt, der mich gemacht, der kommentiert in den link oben, ist, dass Sie können nicht 'upgrade' auf der access-Ebene. Wenn Sie eine Unterklasse etwas eingeschränkt wurde, können Sie es mehr, aber nicht die andere Weise herum.

Dieser Letzte bit betrifft auch Funktionen, Tupel und sicher noch andere Sachen in der Weise, dass, wenn also eine Funktion verwendet eine private Klasse, dann ist es nicht gültig, um die Funktion internen oder öffentlichen, da Sie möglicherweise nicht über Zugriff auf die private Klasse. Dies führt zu einer compiler-Warnung, und Sie müssen deklarieren Sie die Funktion als private Funktion.

InformationsquelleAutor holroy

Einer der Optionen, die Sie nutzen könnten ist, um wickeln Sie die Instanz der Schöpfung in eine Funktion, und geben Sie die entsprechenden Getter und setter im Konstruktor:

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

InformationsquelleAutor Bartosz Ciechanowski

Swift 3 und 4 brachte eine Menge Veränderungen auch für die Zugriffsebenen von Variablen und Methoden. Swift 3 und 4 hat nun 4 verschiedene Zugriffsebenen, wo öffentlichen Zugriff ist die höchste (am wenigsten restriktiv) Zugang Ebene und private Zugriff auf die niedrigsten (strengsten) access level:

• private Funktionen, und die Mitglieder können nur zugegriffen werden, aus dem Bereich der Entität selbst (struct, class, ...) und deren Erweiterungen (Swift 3 auch die Erweiterungen eingeschränkt waren)
• fileprivate Funktionen, und die Mitglieder können nur den Zugriff innerhalb der Quelldatei, in dem Sie deklariert werden.
• internen Funktionen und Mitglieder (dies ist die Standardeinstellung, wenn Sie nicht explizit hinzufügen einer access-level key word), zugegriffen werden kann, die überall in der Zielgruppe, wo diese definiert sind. Thats, warum die TestTarget haben nicht automatisch Zugriff auf alle Quellen, Sie müssen so markiert werden, zugänglich in xCode die Datei " inspector.
• offenen oder öffentlichen Funktionen, und die Mitglieder können von überall abgerufen werden, die innerhalb der Ziel-und aus einem anderen Kontext, dass die Einfuhren der aktuellen target-Modul.

Interessant:

Statt der Kennzeichnung jeder einzelnen Methode oder Element als "privat", können Sie decken einige Methoden (z.B. in der Regel Hilfsfunktionen) in einer Erweiterung einer Klasse /Struktur und markieren Sie die ganze Erweiterung als "Privat".

class foo { }

private extension foo {
    func somePrivateHelperFunction01() { }
    func somePrivateHelperFunction02() { }
    func somePrivateHelperFunction03() { }
}

Dies kann eine gute Idee sein, um zu besser wartbaren code. Und man kann leicht wechseln (z.B. für unit-Tests) auf nicht-private, einfach indem ein Wort.

Apple-Dokumentation

InformationsquelleAutor LukeSideWalker

Hoffentlich um etwas Zeit zu sparen, für diejenigen, die wollen so etwas wie geschützte Methoden:

Als pro anderen Antworten, swift jetzt bietet die "private" - modifier - definierte Datei-Weise statt-Klasse-Weise wie diejenigen, die in Java oder C# beispielsweise. Dies bedeutet, dass, wenn Sie wollen, geschützten Methoden, die Sie tun können, es mit swift private Methoden , wenn Sie in der gleichen Datei

1. Erstellen Sie eine Basis-Klasse "protected" Methoden (eigentlich privaten)
2. Unterklasse dieser Klasse verwenden die gleichen Methoden
3. In anderen Dateien Sie können den Zugriff auf die Basisklasse Methoden, auch wenn Sie eine Unterklasse entweder

z.B. Datei 1:

class BaseClass {
    private func protectedMethod() {

    }
}

class SubClass : BaseClass {
    func publicMethod() {
        self.protectedMethod()  //this is ok as they are in same file
    }
}

Datei 2:

func test() {
    var a = BaseClass()
    a.protectedMethod() //ERROR


    var b = SubClass()
    b.protectedMethod() //ERROR
}

class SubClass2 : BaseClass {
    func publicMethod() {
        self.protectedMethod() //ERROR
    }

}

InformationsquelleAutor james_alvarez

bis swift 2.0 gab es nur drei access level [Public, internal, private]
aber in swift 3.0 apple hat zwei neue access-Ebene, die [ Öffnen, Dateityp ] so
jetzt in swift 3.0 gibt es 5 Zugriff Ebene
Ich möchte hier klar die Rolle, die diese zwei access-Ebene
1. Offen: dies ist ähnlich zu Öffentlich, aber der einzige Unterschied ist, dass der Öffentliche
Zugriff auf die Unterklasse und überschreiben, und Open-access-Ebene kann nicht zugreifen, dieses Bild stammt aus Mittel-website und diese beschreiben Sie den Unterschied zwischen offenen und öffentlichen Zugriff

Nun zum zweiten neuen Zugang Ebene
2. filetype ist die größere version von privater oder weniger access-Ebene als interne
Der Dateityp kann auf die erweiterten Teil der [Klasse, struct, enum]
und private kann nicht auf die erweiterten Teil der code kann jedoch nur auf die
lexikalische scope
dieses Bild stammt aus Mittel-website und diese beschreiben den Unterschied zwischen Dateityp und Privaten Zugang Ebene

InformationsquelleAutor Dilip Tilonia