Kiedy mówi się o stworzeniu "prywatnej metody" w Swift lub ObjC (lub ruby lub java lub...) te metody nie sąnaprawdę prywatne. Nie ma wokół nich kontroli dostępu. Każdy język, który oferuje choć odrobinę introspekcji, pozwala programistom dotrzeć do tych wartości spoza klasy, jeśli naprawdę chcą.

Więc to, o czym tak naprawdę mówimy, to sposób na zdefiniowanie publicznego interfejsu, który po prostu prezentuje funkcjonalność, którą chcemy, i "ukrywa" reszta, którą uważamy za "prywatną".

Mechanizmem Swift do deklarowania interfejsów jest protocol i może być używany do tego celu.

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

Pamiętaj, protokoły są typami pierwszej klasy i mogą być używane wszędzie tam, gdzie Typ może. i, Kiedy są używane w ten sposób, ujawniają tylko własne interfejsy, a nie interfejsy typu implementującego.

Tak długo, jak używasz MyClass zamiast MyClassImplementation w swoich typach parametrów, itp. wszystko powinno działać:

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

Są pewne przypadki bezpośredniego przypisania, w których musisz być jednoznaczny z typem, zamiast polegać na Swift, aby wywnioskować, ale to nie wydaje się łamaczem transakcji: {]}

var myClass:MyClass = MyClassImplementation()

Używanie protokołów w ten sposób jest semantyczne, w miarę zwięzłe i moim oczom wygląda bardzo podobnie do rozszerzeń klas, których używamy do tego celu w ObjC.

Z tego co wiem, nie ma słów kluczowych "public", "private" czy "protected". To sugerowałoby, że wszystko jest publiczne.

Apple może jednak oczekiwać, że ludzie będą używać" protokołów " (zwanych interfejsami przez resztę świata) i factory design pattern do ukrywania szczegółów typu implementacji.

Jest to często dobry wzorzec projektowy do użycia, ponieważ pozwala zmienić hierarchię klas implementacji, zachowując logiczne typuj system ten sam.

Używając kombinacji protokołów, zamknięć i klas zagnieżdżonych/wewnętrznych, możliwe jest użycie czegoś zgodnie z wzorcem modułu do ukrycia informacji w Swift. To nie jest super czyste lub miło czytać, ale to działa.

Przykład:

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 i mysteriousMath są tu ukryte przed użyciem z zewnątrz, a próba wkopania się w obiekt powinna spowodować błąd.

Swift 4

Jak wspomniano w dokumentacja Swift-Kontrola dostępu, Swift 4 posiada 5 Kontroli Dostępu:

• open oraz publiczne: można uzyskać dostęp z jednostek ich modułu i dowolnych jednostek modułu, które importują moduł definiujący.

• wewnętrzne: mogą być dostępne tylko z jednostek ich modułu. Jest to domyślny dostęp poziom.

• fileprivate oraz prywatne: mogą być dostępne tylko w ograniczonym zakresie, w którym je zdefiniujesz.

Jaka jest różnica międzyotwartym Apublicznym ?

Open jest taki sam jak public w poprzednich wersjach Swift, pozwalają one na używanie klas z innych modułów i ich dziedziczenie, tzn. mogą być podklasowane od innych modułów. Również, pozwalają one członkom z innych modułów na ich użycie i nadpisanie. Ta sama logika dotyczy ich modułów.

Public zezwala klasom z innych modułów na ich używanie, ale Niena dziedziczenie ich, tzn.: nie mogą być podklasowane od innych modułów. Ponadto pozwalają członkom z innych modułów na ich używanie, ale nie nadpisują ich. Dla swoich modułów mają tę samą logikę open (pozwalają klasom na ich używanie i dziedziczenie; pozwalają członkom na używanie i nadpisywanie ich).

Jaka jest różnica między fileprivate A private ?

Fileprivate można uzyskać dostęp z całych plików.

Private mogą być dostępne tylko z jednej deklaracji i do rozszerzeń tej deklaracji, które znajdują się w tym samym pliku; na przykład:

// 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!"
    }
}

Jakie są różnice między Swift 3 a Swift 4 Access Control?

Jak wspomniano wse-0169 propozycja , jedyne udoskonalenie zostało dodane do Swift 4 jest to, że prywatny zakres kontroli dostępu został rozszerzony, aby był dostępny z rozszerzenia tej deklaracji w tym samym pliku; na przykład:

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!
    }
}

Nie ma więc potrzeby deklarowania myMessage jako fileprivate , aby był dostępny w całym pliku.

_{uwaga na pasku bocznym: jeśli napotkałeś problemy związane z nie kompilowaniem Swifta 4 z migrowanym starszym Swiftem 3 projekt, możesz sprawdzić to Q & A .}

[[2]}od Xcode 6 beta 4 Swift ma modyfikatory dostępu. Z informacji o wydaniu:

Kontrola dostępu Swift ma trzy poziomy dostępu:

• prywatne encje mogą być dostępne tylko z pliku źródłowego, w którym są zdefiniowane.
• wewnętrzne byty mogą być dostępne w dowolnym miejscu w obrębie celu, gdzie są zdefiniowane.
• publiczne podmioty mogą być dostępne z dowolnego miejsca w obrębie celu i z dowolnego innego kontekstu importuje moduł bieżącego celu.

Domyślną wartością domyślną jest internal, więc w aplikacji docelowej możesz pozostawić modyfikatory dostępu wyłączone, chyba że chcesz być bardziej restrykcyjny. W elemencie docelowym frameworka (np. jeśli osadzasz framework w celu udostępniania kodu między aplikacją a rozszerzeniem widoku udostępnianie lub widok dzisiaj), użyj public, aby wyznaczyć API, które chcesz udostępnić klientom frameworka.

Swift 3.0 zapewnia pięć różnych kontroli dostępu:

1. otwórz
2. public
3. wewnętrzny
4. fileprivate
5. private

Open access i public access umożliwiają użycie encji w dowolnym pliku źródłowym z ich modułu definiującego, a także w plik źródłowy z innego modułu, który importuje moduł definiujący. Ty zazwyczaj używaj otwartego lub publicznego dostępu przy określaniu publicznego interfejs do ramy.

Wewnętrzny dostęp umożliwia użycie encji w dowolnym pliku źródłowym z ich modułu definiującego, ale nie w żadnym pliku źródłowym poza tym moduł. Zazwyczaj używasz dostępu wewnętrznego podczas definiowania aplikacji lub struktura wewnętrzna frameworka.

File-private access ogranicza użycie encji do własnego definiującego pliku źródłowego. Użyj file-private access, aby ukryć szczegóły implementacji określonego elementu funkcjonalności, gdy te szczegóły są używane w całym pliku.

Private access ogranicza użycie podmiotu do załączonej deklaracji. Użyj dostępu prywatnego, aby ukryć szczegóły implementacji konkretną funkcjonalność, gdy dane te są używane tylko w ramach jednej deklaracji.

Open dostęp jest najwyższym (najmniej restrykcyjnym) poziomem dostępu i private dostęp jest najniższym (najbardziej restrykcyjnym) dostępem poziom.

Domyślne POZIOMY DOSTĘPU

Wszystkie encje w kodzie (z kilkoma wyjątkami) mają Domyślny poziom dostępu wewnętrzny, jeśli sam nie określisz jawnego poziomu dostępu. W rezultacie w wielu przypadkach nie musisz określać w kodzie jawnego poziomu dostępu.

Informacja o wydaniu na ten temat:

Klasy zadeklarowane jako publiczne nie mogą być już podklasowane poza ich moduł definiujący oraz metody zadeklarowana jako Publiczna nie może być już overridden poza ich definiującym modułem. Aby klasa była zewnętrznie podklasowane lub metoda, która ma być zewnętrznie nadpisana, deklaruje ich jako otwarte, co jest nowym poziomem dostępu poza publicznym. Importowane Objective-C klasy i metody są teraz importowane jako otwarte niż publiczne. Testy jednostkowe, które importują moduł za pomocą @ testable import nadal będą mogli podklasować klasy publiczne lub wewnętrzne, jak również jako nadrzędne publiczne lub wewnętrzne metody. (SE-0117)

Więcej informacji : Język Programowania Swift (Kontrola Dostępu)

Nie, to niemożliwe. Nie ma żadnych prywatnych/chronionych metod i zmiennych.

Wszystko jest publiczne.

W wersji Beta 6 dokumentacja stwierdza, że istnieją trzy różne modyfikatory dostępu:

• Public
• Wewnętrzny
• Private

I te trzy dotyczą klas, protokołów, funkcji i właściwości.

public var somePublicVariable = 0
internal let someInternalConstant = 0
private func somePrivateFunction() {}

Aby uzyskać więcej, sprawdź Kontrola dostępu.

Mechanizmy kontroli dostępu jak wprowadzone w Xcode 6:

Swift zapewnia trzy różne poziomy dostępu dla podmiotów w Twoim kodzie. Te poziomy dostępu odnoszą się do pliku źródłowego, w którym zdefiniowany jest obiekt, a także do modułu, do którego należy plik źródłowy.

• Public access umożliwia użycie encji w dowolnym pliku źródłowym z ich modułu definiującego, a także w pliku źródłowym z innego modułu importującego definiowanie modułu. Zazwyczaj używa się dostępu publicznego przy określaniu interfejsu publicznego dla frameworka.
• wewnętrzny dostęp umożliwia użycie encji w dowolnym pliku źródłowym z ich modułu definiującego, ale nie w żadnym pliku źródłowym poza tym modułem. Zazwyczaj używa się dostępu wewnętrznego podczas definiowania struktury wewnętrznej aplikacji lub struktury.
• Private access ogranicza użycie encji do własnego definiującego pliku źródłowego. Użyj dostępu prywatnego, aby ukryć szczegóły realizacji konkretnego elementu funkcjonalności.

Dostęp publiczny jest najwyższym (najmniej restrykcyjnym) poziomem dostępu, a dostęp prywatny jest najniższym (lub najbardziej restrykcyjnym) poziomem dostępu.

Domyślnie accecss it internal , i nie musi być określone jako takie. Zauważ również, że specyfikator private działa Nie na poziomie klasy, ale na poziomie pliku źródłowego. Oznacza to, że aby uzyskać części klasy naprawdę prywatne musisz oddzielić się do własnego pliku. Wprowadza to również kilka interesujących przypadków w odniesieniu do testów jednostkowych...

Kolejny punkt dla mnie, który jest komentowany w linku powyżej, jest to, że nie można "uaktualnić" poziomu dostępu. Jeśli podklasujesz coś, możesz to bardziej ograniczyć, ale nie na odwrót.

Ten ostatni bit wpływa również na funkcje, krotki i na pewno inne rzeczy w taki sposób, że jeśli np. funkcja używa klasy private , to nie jest poprawna aby mieć funkcję internallub public, ponieważ mogą nie mieć dostępu do klasy private. Powoduje to Ostrzeżenie kompilatora i musisz ponownie zadeklarować funkcję jako funkcję private .

Jedną z opcji, której możesz użyć, jest zawinięcie tworzenia instancji w funkcję i dostarczenie odpowiednich getterów i setterów do konstruktora:

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

Teraz w wersji beta 4 dodali modyfikatory dostępu do Swift.

From Xcode 6 beta 4 realese notes :

Kontrola dostępu Swift ma trzy poziomy dostępu:

• private encje mogą być dostępne tylko z pliku źródłowego, w którym są zdefiniowane.
• internal byty mogą być dostępne w dowolnym miejscu w obrębie celu, gdzie są zdefiniowane.
• public byty mogą być dostępne z dowolnego miejsca w obrębie celu i z dowolnego innego kontekstu importuje moduł bieżącego celu.

Domyślnie większość encji w pliku źródłowym ma dostęp wewnętrzny. Pozwala to twórcom aplikacji aby w dużej mierze ignorować kontrolę dostępu, jednocześnie umożliwiając programistom frameworku pełną kontrolę nad framework ' s API.

Gramatyka języka nie posiada słów kluczowych "public", "private" lub "protected". To sugerowałoby, że wszystko jest publiczne. Oczywiście, może być jakaś alternatywna metoda określania modyfikatorów dostępu bez tych słów kluczowych, ale nie mogłem jej znaleźć w referencji językowej.

Swift 3 i 4 przyniosły wiele zmian także dla poziomów dostępu do zmiennych i metod. Swift 3 i 4 mają teraz 4 różne poziomy dostępu, gdzie open / public access jest najwyższym (najmniej restrykcyjnym) poziomem dostępu, a private access jest najniższym (najbardziej restrykcyjnym) poziomem dostępu:

• private Funkcje i członkowie mogą być dostępne tylko z zakresu samego podmiotu (struct, class,...) i jego rozszerzeń (w języku Swift 3 również rozszerzenia zostały ograniczone)
• fileprivate Funkcje i członkowie mogą być dostępne tylko z pliku źródłowego, w którym są zadeklarowane.
• internal Funkcje i członkowie (co jest domyślne, jeśli nie dodasz jawnie słowa kluczowego poziomu dostępu) mogą być dostępne w dowolnym miejscu w obrębie celu, w którym są zdefiniowane. Dlatego TestTarget nie ma automatycznego dostępu do wszystkich źródeł, muszą być oznaczone jako dostępne w pliku xCode Inspektorze.
• otwarte lub publiczne Funkcje i członkowie mogą być dostępne z dowolnego miejsca w obiekcie docelowym i z dowolnego innego kontekstu, który importuje moduł bieżącego obiektu docelowego.

Ciekawe:

Zamiast zaznaczania każdej pojedynczej metody lub elementu jako "prywatne", możesz przykryć niektóre metody (np. typowe funkcje pomocnicze) w rozszerzeniu klasy / struktury i oznaczyć całe rozszerzenie jako"prywatne".

class foo { }

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

To może być dobry pomysł, w kolejności aby uzyskać lepszy dostęp do kodu. I możesz łatwo przełączyć się (np. do testów jednostkowych) na nie-prywatne, zmieniając tylko jedno słowo.

Dokumentacja Apple

Mam nadzieję, że zaoszczędzimy trochę czasu dla tych, którzy chcą czegoś podobnego do metod chronionych:

Zgodnie z innymi odpowiedziami, swift dostarcza teraz modyfikator "prywatny" -który jest zdefiniowany w kategoriach plików, a nie klas, jak na przykład w Javie lub C#. Oznacza to, że jeśli chcesz zabezpieczyć metody, możesz to zrobić za pomocą prywatnych metod swift , jeśli znajdują się one w tym samym pliku

1. Tworzenie klasy bazowej do przechowywania 'chronionych' metod (w rzeczywistości prywatnych)
2. podklasa ta Klasa używająca tych samych metod
3. w innych plikach nie możesz uzyskać dostępu do metod klasy bazowej, nawet jeśli podklasujesz albo

Np. plik 1:

class BaseClass {
    private func protectedMethod() {

    }
}

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

Plik 2:

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


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

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

}

Https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AccessControl.html#//apple_ref/doc/uid/TP40014097-CH41-ID3

START SWIFT 2.2;)

• Public
• wewnętrzny
• Private

Domyślnie wewnętrzny

Do swift 2.0 były tylko trzy poziomy dostępu [publiczny, wewnętrzny, prywatny] ale w swift 3.0 apple dodał dwa nowe poziomy dostępu, które są [Open, fileType] tak teraz w swift 3.0 jest 5 Poziom dostępu Tutaj chcę wyjaśnić rolę tych dwóch poziomów dostępu 1. Open: jest to bardzo podobne do publicznego, ale jedyną różnicą jest to, że publiczne może uzyskać dostęp do podklasy i nadpisać, a otwarty Poziom dostępu nie może uzyskać dostępu do tego Ten obraz jest pobrany ze strony Medium i to opisz różnicę między otwartym i publicznym dostępem

Teraz do drugiego nowego poziomu dostępu 2. filetype jest większą wersją prywatnego lub mniej dostępowego poziomu niż wewnętrzny Typ pliku może uzyskać dostęp do rozszerzonej części [class, struct, enum] i prywatny nie może uzyskać dostępu do rozszerzonej części kodu, może uzyskać dostęp tylko do zakres leksykalny to zdjęcie pochodzi ze strony Medium i opisuje różnicę między typem pliku a poziomem dostępu prywatnego