Dalam Objective-C instance data dapat berupa public, protectedatau private. Sebagai contoh:

@interface Foo : NSObject
{
  @public
    int x;
  @protected:
    int y;
  @private:
    int z;
  }
-(int) apple;
-(int) pear;
-(int) banana;
@end

Saya belum menemukan penyebut akses yang disebutkan dalam referensi Swift. Apakah mungkin membatasi visibilitas data di Swift?

Pada Swift 3.0.1 , ada 4 tingkat akses , dijelaskan di bawah ini dari yang tertinggi (paling ketat) hingga terendah (paling ketat).

1. opendanpublic

Aktifkan entitas untuk digunakan di luar modul penentu (target). Anda biasanya menggunakan openatau publicmengakses ketika menentukan antarmuka publik untuk suatu kerangka kerja.

Namun, openakses hanya berlaku untuk kelas dan anggota kelas , dan itu berbeda dari publicakses sebagai berikut:

• public kelas dan anggota kelas hanya dapat disubklasifikasikan dan diganti dalam modul pendefinisian (target).
• open kelas dan anggota kelas dapat disubklasifikasikan dan diganti baik di dalam maupun di luar modul (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

2. internal

Memungkinkan entitas untuk digunakan dalam modul yang menentukan (target). Anda biasanya menggunakan internalakses saat mendefinisikan struktur internal aplikasi atau kerangka kerja.

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

Membatasi penggunaan entitas untuk file sumber yang menentukan. Anda biasanya menggunakanfileprivate akses untuk menyembunyikan detail implementasi dari bagian fungsionalitas tertentu ketika detail itu digunakan dalam seluruh 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

4. private

Membatasi penggunaan suatu entitas pada deklarasi terlampir. Anda biasanya menggunakan privateakses untuk menyembunyikan detail implementasi dari bagian fungsionalitas tertentu ketika detail tersebut hanya digunakan dalam satu deklarasi.

// First.framework – A.swift

internal struct A {

    private static let x: Int

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

}

A.x // error: x is unavailable

Swift 4 / Swift 5

Seperti yang disebutkan dalam Dokumentasi Swift - Kontrol Akses , Swift memiliki 5 Kontrol Akses :

• buka dan publik : dapat diakses dari entitas modul mereka dan entitas modul apa pun yang mengimpor modul yang menentukan.

• intern : hanya dapat diakses dari entitas modul mereka. Ini adalah tingkat akses standar.

• fileprivate dan pribadi : hanya dapat diakses secara terbatas dalam ruang lingkup terbatas di mana Anda mendefinisikannya.

Apa perbedaan antara terbuka dan publik ?

terbuka sama dengan publik pada versi Swift sebelumnya, mereka memungkinkan kelas dari modul lain untuk menggunakan dan mewarisinya, yaitu: mereka dapat disubkelas dari modul lain. Juga, mereka memungkinkan anggota dari modul lain untuk menggunakan dan menimpanya. Logika yang sama berlaku untuk modul mereka.

publik mengizinkan kelas dari modul lain untuk menggunakannya, tetapi tidak mewarisi mereka, yaitu: mereka tidak dapat subkelas dari modul lain. Juga, mereka memungkinkan anggota dari modul lain untuk menggunakannya, tetapi TIDAK untuk menimpanya. Untuk modul mereka, mereka memiliki logika open yang sama (mereka memungkinkan kelas untuk menggunakan dan mewarisinya; Mereka memungkinkan anggota untuk menggunakan dan menimpanya).

Apa perbedaan antara fileprivate dan privat ?

fileprivate dapat diakses dari seluruh file mereka.

pribadi hanya dapat diakses dari deklarasi tunggal mereka dan ke ekstensi deklarasi yang ada di file yang sama; Misalnya:

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

Apa perbedaan antara Kontrol Akses Swift 3 dan Swift 4?

Seperti yang disebutkan dalam proposal SE-0169 , satu-satunya penyempurnaan telah ditambahkan ke Swift 4 adalah bahwa ruang lingkup kontrol akses pribadi telah diperluas agar dapat diakses dari ekstensi deklarasi tersebut dalam file yang sama; Misalnya:

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

Jadi, tidak perlu menyatakan myMessagesebagai fileprivate untuk dapat diakses di seluruh file.

Ketika seseorang berbicara tentang membuat "metode pribadi" di Swift atau ObjC (atau ruby ​​atau java atau ...) metode tersebut tidak benar - benar pribadi. Tidak ada kontrol akses aktual di sekitar mereka. Bahasa apa pun yang menawarkan bahkan sedikit introspeksi memungkinkan pengembang mencapai nilai-nilai itu dari luar kelas jika mereka benar-benar menginginkannya.

Jadi apa yang sebenarnya kita bicarakan di sini adalah cara untuk mendefinisikan antarmuka publik yang hanya menyajikan fungsi yang kita inginkan, dan "menyembunyikan" sisanya yang kita anggap "pribadi".

Mekanisme Swift untuk mendeklarasikan antarmuka adalah protocol, dan dapat digunakan untuk tujuan ini.

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

Ingat, protokol adalah tipe kelas satu dan bisa digunakan di mana saja. Dan , ketika digunakan dengan cara ini, mereka hanya mengekspos antarmuka mereka sendiri, bukan dari tipe implementasi.

Jadi, selama Anda menggunakan dan MyClassbukan MyClassImplementationpada tipe parameter Anda, dll. Itu semua hanya akan berfungsi:

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

Ada beberapa kasus penugasan langsung di mana Anda harus eksplisit dengan tipe alih-alih mengandalkan Swift untuk menyimpulkannya, tetapi itu sepertinya bukan pemecah kesepakatan:

var myClass:MyClass = MyClassImplementation()

Menggunakan protokol dengan cara ini semantik, cukup ringkas, dan bagi saya sangat mirip dengan Kelas Extentions yang telah kami gunakan untuk tujuan ini di ObjC.

Sejauh yang saya tahu, tidak ada kata kunci 'publik', 'pribadi' atau 'dilindungi'. Ini akan menyarankan semuanya bersifat publik.

Namun Apple mungkin mengharapkan orang untuk menggunakan " protokol " (disebut antarmuka oleh seluruh dunia) dan pola desain pabrik untuk menyembunyikan detail dari jenis implementasi.

Ini sering merupakan pola desain yang baik untuk digunakan; karena memungkinkan Anda mengubah hierarki kelas implementasi Anda , sambil menjaga sistem tipe logis yang sama.

Menggunakan kombinasi protokol, penutupan, dan kelas bersarang / dalam, dimungkinkan untuk menggunakan sesuatu di sepanjang garis pola modul untuk menyembunyikan informasi di Swift sekarang. Ini tidak super bersih atau enak dibaca tetapi tidak berfungsi.

Contoh:

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 dan misteriusMath disembunyikan di sini dari penggunaan luar dan berusaha menggali jalan Anda ke objek harus menghasilkan kesalahan.

Saya hanya bagian dari jalan saya membaca Swift docs jadi jika ada cacat di sini tolong tunjukkan, ingin tahu.

Pada Xcode 6 beta 4, Swift memiliki pengubah akses. Dari catatan rilis:

Kontrol akses cepat memiliki tiga tingkat akses:

• entitas pribadi hanya dapat diakses dari dalam file sumber di mana mereka didefinisikan.
• entitas internal dapat diakses di mana saja dalam target di mana mereka didefinisikan.
• entitas publik dapat diakses dari mana saja di dalam target dan dari konteks lain yang mengimpor modul target saat ini.

Default tersirat adalah internal, jadi dalam target aplikasi Anda dapat mematikan pengubah akses kecuali di mana Anda ingin lebih membatasi. Dalam target kerangka kerja (misalnya jika Anda menyematkan kerangka kerja untuk berbagi kode antara aplikasi dan berbagi atau ekstensi tampilan Hari Ini), gunakan publicuntuk menunjuk API yang ingin Anda paparkan ke klien kerangka kerja Anda.

Swift 3.0 menyediakan lima kontrol akses yang berbeda:

1. Buka
2. publik
3. intern
4. fileprivate
5. pribadi

Akses terbuka dan akses publik memungkinkan entitas untuk digunakan dalam file sumber apa pun dari modul mereka, dan juga dalam file sumber dari modul lain yang mengimpor modul yang menentukan. Anda biasanya menggunakan akses terbuka atau publik ketika menentukan antarmuka publik untuk suatu kerangka kerja.

Akses internal memungkinkan entitas untuk digunakan dalam file sumber apa pun dari modul mereka, tetapi tidak dalam file sumber apa pun di luar modul itu. Anda biasanya menggunakan akses internal ketika mendefinisikan struktur internal aplikasi atau kerangka kerja.

Akses file-pribadi membatasi penggunaan entitas untuk file sumber yang menentukan sendiri. Gunakan akses file-pribadi untuk menyembunyikan detail implementasi dari bagian fungsionalitas tertentu ketika detail tersebut digunakan dalam seluruh file.

Akses pribadi membatasi penggunaan suatu entitas pada deklarasi terlampir. Gunakan akses pribadi untuk menyembunyikan detail implementasi dari bagian fungsionalitas tertentu ketika detail tersebut hanya digunakan dalam satu deklarasi.

Akses terbuka adalah tingkat akses tertinggi (paling ketat) dan akses pribadi adalah tingkat akses terendah (paling ketat).

Tingkat Akses Default

Semua entitas dalam kode Anda (dengan beberapa pengecualian spesifik) memiliki tingkat akses standar internal jika Anda tidak menentukan sendiri tingkat akses eksplisit. Akibatnya, dalam banyak kasus Anda tidak perlu menentukan tingkat akses eksplisit dalam kode Anda.

Catatan rilis pada topik:

Kelas yang dideklarasikan sebagai publik tidak lagi dapat disubklasifikasi di luar modul pendefinisiannya, dan metode yang dideklarasikan sebagai publik tidak dapat lagi ditimpa di luar modul pendefinisiannya. Untuk memungkinkan kelas untuk menjadi subclass eksternal atau metode yang akan ditimpa secara eksternal, menyatakan mereka sebagai terbuka, yang merupakan tingkat akses baru di luar publik. Kelas dan metode Objective-C yang Diimpor sekarang semuanya diimpor sebagai terbuka daripada publik. Tes unit yang mengimpor modul menggunakan impor @testable masih akan diizinkan untuk mensubkelas kelas publik atau internal serta mengabaikan metode publik atau internal. (SE-0117)

Informasi lebih lanjut & detail: Bahasa Pemrograman Swift (Kontrol Akses)

Dalam Beta 6, dokumentasi menyatakan bahwa ada tiga pengubah akses yang berbeda:

• Publik
• Intern
• Pribadi

Dan ketiganya berlaku untuk Kelas, Protokol, fungsi dan properti.

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

Untuk lebih lanjut, periksa Kontrol Akses .

Sekarang dalam versi beta 4, mereka telah menambahkan pengubah akses ke Swift.

dari Xcode 6 beta 4 catatan nyata :

Kontrol akses cepat memiliki tiga tingkat akses:

• private entitas hanya dapat diakses dari dalam fi le sumber di mana mereka didefinisikan.
• internal entitas dapat diakses di mana saja dalam target di mana mereka didefinisikan.
• public entitas dapat diakses dari mana saja di dalam target dan dari konteks lain yang mengimpor modul target saat ini.

Secara default, sebagian besar entitas dalam fi le sumber memiliki akses internal. Hal ini memungkinkan pengembang aplikasi untuk sebagian besar mengabaikan kontrol akses sementara memungkinkan pengembang kerangka kontrol penuh atas API framework.

Mekanisme kontrol akses sebagai diperkenalkan pada Xcode 6 :

Swift menyediakan tiga tingkat akses berbeda untuk entitas dalam kode Anda. Level akses ini relatif terhadap file sumber di mana entitas didefinisikan, dan juga relatif terhadap modul yang dimiliki file sumber.

• Akses publik memungkinkan entitas untuk digunakan dalam file sumber apa pun dari modul mereka, dan juga dalam file sumber dari modul lain yang mengimpor modul yang menentukan. Anda biasanya menggunakan akses publik ketika menentukan antarmuka publik untuk suatu kerangka kerja.
• Akses internal memungkinkan entitas untuk digunakan dalam file sumber apa pun dari modul mereka, tetapi tidak dalam file sumber apa pun di luar modul itu. Anda biasanya menggunakan akses internal ketika mendefinisikan struktur internal aplikasi atau kerangka kerja.
• Akses pribadi membatasi penggunaan entitas untuk file sumber yang menentukan sendiri. Gunakan akses pribadi untuk menyembunyikan detail implementasi dari bagian fungsionalitas tertentu.

Akses publik adalah tingkat akses tertinggi (paling ketat) dan akses pribadi adalah tingkat akses terendah (atau paling ketat).

Default mengaksesnya internal , dan tidak perlu ditentukan. Perhatikan juga bahwa specifier pribadi tidak berfungsi pada level kelas, tetapi pada level file sumber. Ini berarti bahwa untuk mendapatkan bagian dari kelas yang benar-benar pribadi Anda perlu memisahkan ke dalam file sendiri. Ini juga memperkenalkan beberapa kasus menarik berkaitan dengan pengujian unit ...

Hal lain yang saya sampaikan, yang dikomentari di tautan di atas, adalah Anda tidak dapat 'meningkatkan' tingkat akses. Jika Anda mensubklasifikasikan sesuatu, Anda dapat membatasi lebih banyak, tetapi tidak sebaliknya.

Bit terakhir ini juga memengaruhi fungsi, tupel, dan tentunya hal-hal lain dengan cara jika jika suatu fungsi menggunakan kelas privat , maka tidak valid untuk memiliki fungsi internal atau publik , karena mereka mungkin tidak memiliki akses ke kelas privat . Ini menghasilkan peringatan kompiler, dan Anda harus mendeklarasikan ulang fungsi sebagai fungsi pribadi .

Swift 3 dan 4 membawa banyak perubahan juga untuk tingkat akses variabel dan metode. Swift 3 dan 4 sekarang memiliki 4 tingkat akses yang berbeda, di mana akses terbuka / publik adalah tingkat akses tertinggi (paling ketat) dan akses pribadi adalah tingkat akses terendah (paling ketat):

• fungsi pribadi dan anggota hanya dapat diakses dari dalam lingkup entitas itu sendiri (struct, class, ...) dan ekstensi-nya (dalam Swift 3 juga ekstensi dibatasi)
• fungsi dan anggota fileprivate hanya dapat diakses dari dalam file sumber tempat mereka dideklarasikan.
• fungsi internal dan anggota (yang merupakan default, jika Anda tidak secara eksplisit menambahkan kata kunci tingkat akses) dapat diakses di mana saja dalam target di mana mereka didefinisikan. Itulah mengapa TestTarget tidak memiliki akses otomatis ke semua sumber, mereka harus ditandai sebagai dapat diakses di inspektur file xCode.
• fungsi dan anggota publik atau terbuka dapat diakses dari mana saja di dalam target dan dari konteks lain yang mengimpor modul target saat ini.

Menarik:

Alih-alih menandai setiap metode atau anggota sebagai "pribadi", Anda dapat membahas beberapa metode (misalnya fungsi pembantu) dalam ekstensi kelas / struct dan tandai seluruh ekstensi sebagai "Pribadi".

class foo { }

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

Ini bisa menjadi ide yang bagus, untuk mendapatkan kode yang bisa dikelola lebih baik. Dan Anda dapat dengan mudah beralih (misalnya untuk pengujian unit) ke non-pribadi hanya dengan mengubah satu kata.

Dokumentasi Apple

Untuk Swift 1-3:

Tidak, itu tidak mungkin. Tidak ada metode dan variabel pribadi / yang dilindungi sama sekali.

Semuanya bersifat publik.

Pembaruan Sejak Swift 4, dimungkinkan melihat jawaban lain di utas ini

Salah satu opsi yang bisa Anda gunakan adalah untuk membungkus kreasi instance ke dalam fungsi dan memasok getter dan setters yang sesuai dalam sebuah 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

Tata bahasa tidak memiliki kata kunci 'publik', 'pribadi' atau 'dilindungi'. Ini akan menyarankan semuanya bersifat publik. Tentu saja, mungkin ada beberapa metode alternatif untuk menentukan pengubah akses tanpa kata kunci tersebut tetapi saya tidak dapat menemukannya dalam referensi bahasa.

Semoga menghemat waktu bagi mereka yang menginginkan sesuatu yang mirip dengan metode yang dilindungi:

Sebagai jawaban lain, swift sekarang menyediakan pengubah 'pribadi' - yang didefinisikan berdasarkan file daripada kelas-bijaksana seperti yang ada di Jawa atau C # misalnya. Ini berarti bahwa jika Anda ingin metode yang dilindungi, Anda dapat melakukannya dengan metode pribadi cepat jika mereka berada di file yang sama

1. Buat kelas dasar untuk menampung metode 'dilindungi' (sebenarnya pribadi)
2. Subkelas kelas ini untuk menggunakan metode yang sama
3. Dalam file lain Anda tidak dapat mengakses metode kelas dasar, bahkan ketika Anda subkelas

mis. 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
    }

}

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

MULAI SWIFT 2.2;)

• Publik
• Intern
• Pribadi

Secara default Internal

sampai swift 2.0 hanya ada tiga tingkat akses [Publik, internal, swasta] tetapi di apple cepat Swift 3.0 menambahkan dua tingkat akses baru yaitu [Buka, fileType] jadi sekarang di swift 3.0 ada 5 tingkat akses Di sini saya ingin menghapus peran dari dua tingkat akses ini 1. Buka: ini sangat mirip dengan Publik tetapi satu-satunya perbedaan adalah bahwa Publik dapat mengakses subclass dan menimpanya, dan tingkat akses Terbuka tidak dapat mengakses bahwa gambar ini diambil dari situs web Medium dan ini menggambarkan perbedaannya antara akses terbuka dan publik

Sekarang ke level akses baru kedua 2. filetype adalah versi yang lebih besar dari privat atau level akses yang kurang dari internal FileType dapat mengakses bagian [class, struct, enum] yang diperluas dan privat tidak dapat mengakses bagian kode yang diperluas, hanya bisa mengakses lingkup leksikal gambar ini diambil dari situs web Medium dan ini menggambarkan perbedaan antara fileType dan tingkat akses Privat