Swift - Kontrol Akses

Untuk membatasi akses ke blok kode, modul dan abstraksi dilakukan melalui kontrol akses. Kelas, struktur dan enumerasi dapat diakses sesuai dengan propertinya, metode, penginisialisasi dan subskripnya dengan mekanisme kontrol akses. Konstanta, variabel, dan fungsi dalam protokol dibatasi dan diizinkan akses sebagai global dan lokal melalui kontrol akses. Kontrol akses yang diterapkan ke properti, tipe, dan fungsi dapat disebut sebagai 'entitas'.

Model kontrol akses didasarkan pada modul dan file sumber.

Modul didefinisikan sebagai satu unit distribusi kode dan dapat diimpor menggunakan kata kunci 'impor'. File sumber didefinisikan sebagai file kode sumber tunggal dengan modul untuk mengakses berbagai jenis dan fungsi.

Tiga tingkat akses berbeda disediakan oleh bahasa Swift 4. Mereka adalah akses Publik, Internal dan Pribadi.

S.No	Tingkat & Definisi Akses
1	Public Memungkinkan entitas untuk diproses dengan file sumber apa pun dari modul penentu mereka, file sumber dari modul lain yang mengimpor modul penentu.
2	Internal Memungkinkan entitas untuk digunakan dalam file sumber apa pun dari modul yang menentukan, tetapi tidak dalam file sumber apa pun di luar modul itu.
3	Private Membatasi penggunaan entitas ke file sumber definisinya sendiri. Akses pribadi berperan untuk menyembunyikan detail implementasi dari fungsionalitas kode tertentu.

Sintaksis

public class SomePublicClass {}
internal class SomeInternalClass {}
private class SomePrivateClass {}

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

Kontrol Akses untuk jenis Fungsi

Beberapa fungsi mungkin memiliki argumen yang dideklarasikan di dalam fungsi tanpa nilai yang dikembalikan. Program berikut mendeklarasikan a dan b sebagai argumen untuk fungsi sum (). Di dalam fungsi itu sendiri, nilai untuk argumen a dan b diteruskan dengan memanggil fungsi panggilan sum () dan nilainya dicetak sehingga menghilangkan nilai yang dikembalikan. Untuk menjadikan jenis kembalian fungsi sebagai pribadi, deklarasikan tingkat akses keseluruhan fungsi dengan pengubah pribadi.

private func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

30 20
50 40
30 24

Kontrol Akses untuk jenis Enumerasi

public enum Student {
   case Name(String)
   case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Swift 4")
var studMarks = Student.Mark(98,97,95)

switch studMarks {
   case .Name(let studName):
      print("Student name is: \(studName).")
   case .Mark(let Mark1, let Mark2, let Mark3):
      print("Student Marks are: \(Mark1),\(Mark2),\(Mark3).")
   
}

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

Student Marks are: 98,97,95

Enumerasi dalam bahasa Swift 4 secara otomatis menerima tingkat akses yang sama untuk kasus individual enumerasi. Pertimbangkan misalnya untuk mengakses nama siswa dan tanda yang dijamin dalam tiga mata pelajaran nama pencacahan dinyatakan sebagai siswa dan anggota yang ada di kelas enumerasi adalah nama yang termasuk dalam tipe data string, tanda direpresentasikan sebagai mark1, mark2 dan mark3 dari datatype Integer. Untuk mengakses nama siswa atau nilai yang telah mereka nilai. Sekarang, sakelar kasus akan mencetak nama siswa jika blok kasus tersebut dijalankan jika tidak maka akan mencetak nilai yang dijamin oleh siswa. Jika kedua kondisi gagal, blok default akan dieksekusi.

Kontrol Akses untuk Subkelas

Swift 4 memungkinkan pengguna untuk membuat subkelas kelas apa pun yang dapat diakses dalam konteks akses saat ini. Subkelas tidak boleh memiliki tingkat akses yang lebih tinggi dari superkelasnya. Pengguna dilarang menulis subclass publik dari superclass internal.

public class cricket {
   internal func printIt() {
      print("Welcome to Swift 4 Super Class")
   }
}

internal class tennis: cricket {
   override internal func printIt() {
      print("Welcome to Swift 4 Sub Class")
   }
}

let cricinstance = cricket()
cricinstance.printIt()

let tennisinstance = tennis()
tennisinstance.printIt()

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

Welcome to Swift Super Class
Welcome to Swift Sub Class

Kontrol Akses untuk Konstanta, variabel, properti, dan langganan

Konstanta, variabel, atau properti Swift 4 tidak dapat didefinisikan sebagai publik daripada tipenya. Menulis properti publik dengan tipe privat tidak valid. Demikian pula, subskrip tidak bisa lebih publik daripada indeks atau tipe kembaliannya.

Ketika sebuah konstanta, variabel, properti, atau subskrip menggunakan tipe privat, konstanta, variabel, properti, atau subskrip juga harus ditandai sebagai privat -

private var privateInstance = SomePrivateClass()

Getters dan Setter

Getter dan setter untuk konstanta, variabel, properti, dan subskrip secara otomatis menerima tingkat akses yang sama dengan konstanta, variabel, properti, atau subskrip miliknya.

class Samplepgm {
   var counter: Int = 0{
      willSet(newTotal) {
         print("Total Counter is: \(newTotal)")
      }
      didSet {
         if counter > oldValue {
            print("Newly Added Counter \(counter - oldValue)")
         }
      }
   }
}

let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Kontrol Akses untuk Penginisialisasi dan Penginisialisasi Default

Penginisialisasi kustom dapat diberi tingkat akses yang kurang dari atau sama dengan jenis yang diinisialisasi. Penginisialisasi yang diperlukan harus memiliki tingkat akses yang sama dengan kelasnya. Jenis parameter penginisialisasi tidak boleh lebih pribadi daripada tingkat akses penginisialisasi itu sendiri.

Untuk mendeklarasikan setiap subclass dari inisialisasi kata kunci 'diperlukan' perlu didefinisikan sebelum fungsi init ().

class classA {
   required init() {
      let a = 10
      print(a)
   }
}
class classB: classA {
   required init() {
      let b = 30
      print(b)
   }
}
let res = classA()
let print = classB()

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

10
30
10

Penginisialisasi default memiliki tingkat akses yang sama dengan jenis yang diinisialisasinya, kecuali jenis tersebut didefinisikan sebagai publik. Ketika inisialisasi default didefinisikan sebagai publik, itu dianggap internal. Ketika pengguna membutuhkan tipe publik agar dapat diinisialisasi dengan inisialisasi tanpa argumen di modul lain, sediakan inisialisasi tanpa argumen publik secara eksplisit sebagai bagian dari definisi tipe.

Kontrol Akses untuk Protokol

Ketika kita mendefinisikan protokol baru untuk mewarisi fungsionalitas dari protokol yang ada, keduanya harus dinyatakan sebagai tingkat akses yang sama untuk mewarisi properti satu sama lain. Kontrol akses Swift 4 tidak mengizinkan pengguna untuk menentukan protokol 'publik' yang mewarisi dari protokol 'internal'.

public protocol tcpprotocol {
   init(no1: Int)
}
public class mainClass {
   var no1: Int      // local storage
   init(no1: Int) {
      self.no1 = no1 // initialization
   }
}
class subClass: mainClass, tcpprotocol {
   var no2: Int
   init(no1: Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   
   // Requires only one parameter for convenient method
   required override convenience init(no1: Int) {
      self.init(no1:no1, no2:0)
   }
}

let res = mainClass(no1: 20)
let print = subClass(no1: 30, no2: 50)

print("res is: \(res.no1)")
print("res is: \(print.no1)")
print("res is: \(print.no2)")

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

res is: 20
res is: 30
res is: 50

Kontrol Akses untuk Ekstensi

Swift 4 tidak mengizinkan pengguna untuk menyediakan pengubah tingkat akses eksplisit untuk suatu ekstensi ketika pengguna menggunakan ekstensi itu untuk menambahkan kesesuaian protokol. Tingkat akses default untuk setiap penerapan persyaratan protokol dalam ekstensi disediakan dengan tingkat akses protokolnya sendiri.

Kontrol Akses untuk Generik

Generik memungkinkan pengguna untuk menentukan tingkat akses minimum untuk mengakses batasan tipe pada parameter tipenya.

public struct TOS<T> {
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
}

var tos = TOS<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Type Parameters")
print(tos.items)

tos.push(item: "Naming Type Parameters")
print(tos.items)
let deletetos = tos.pop()

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Type Parameters]
[Swift 4, Generics, Type Parameters, Naming Type Parameters]

Kontrol Akses untuk Alias ​​Jenis

Pengguna dapat menentukan tipe alias untuk menangani tipe kontrol akses yang berbeda. Tingkat akses yang sama atau tingkat akses yang berbeda dapat ditentukan oleh pengguna. Ketika tipe alias adalah 'private', anggotanya yang terkait dapat dideklarasikan sebagai 'private, internal of public type'. Ketika tipe alias adalah publik, anggota tidak bisa menjadi alias sebagai nama 'internal' atau 'pribadi'

Semua tipe alias yang Anda tentukan akan diperlakukan sebagai tipe berbeda untuk tujuan kontrol akses. Suatu alias tipe dapat memiliki tingkat akses yang kurang dari atau sama dengan tingkat akses dari jenis aliasnya. Misalnya, alias tipe privat bisa alias tipe privat, internal, atau publik, tapi tipe alias publik tidak bisa alias tipe internal atau privat.

public protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct Stack<T>: Container {
   // original Stack<T> implementation
   var items = [T]()
   mutating func push(item: T) {
      items.append(item)
   }
   mutating func pop() -> T {
      return items.removeLast()
   }
   
   // conformance to the Container protocol
   mutating func append(item: T) {
      self.push(item: item)
   }
   var count: Int {
      return items.count
   }
   subscript(i: Int) -> T {
      return items[i]
   }
}
func allItemsMatch<
   C1: Container, C2: Container
   where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
   (someContainer: C1, anotherContainer: C2) -> Bool {
   
   // check that both containers contain the same number of items
   if someContainer.count != anotherContainer.count {
      return false
   }
   
   // check each pair of items to see if they are equivalent
   for i in 0..<someContainer.count {
      if someContainer[i] != anotherContainer[i] {
         return false
      }
   }
   // all items match, so return true
   return true
}
var tos = Stack<String>()
tos.push(item: "Swift 4")
print(tos.items)

tos.push(item: "Generics")
print(tos.items)

tos.push(item: "Where Clause")
print(tos.items)

var eos = ["Swift 4", "Generics", "Where Clause"]
print(eos)

Ketika kami menjalankan program di atas menggunakan playground, kami mendapatkan hasil sebagai berikut -

[Swift 4]
[Swift 4, Generics]
[Swift 4, Generics, Where Clause]
[Swift 4, Generics, Where Clause]

Encoding dan Decoding Cepat

Swift 4 memperkenalkan yang baru Codable Protokol, yang memungkinkan Anda membuat serial dan De-serialisasi tipe data khusus tanpa menulis kode khusus apa pun - dan tanpa harus khawatir kehilangan tipe nilai Anda.

struct Language: Codable {
   var name: String
   var version: Int
}
let swift = Language(name: "Swift", version: 4)
let java = Language(name: "java", version: 8)
let R = Language(name: "R", version: 3

Perhatikan bahwa Langauage sesuai dengan Codable Protocol. Sekarang kita akan mengubahnya menjadi Representasi Data Json menggunakan satu baris sederhana.

let encoder = JSONEncoder()
if let encoded = try? encoder.encode(java) {
   //Perform some operations on this value.
}

Swift secara otomatis akan menyandikan semua nilai di dalam tipe data Anda.

Anda dapat memecahkan kode data menggunakan fungsi Decoder seperti

let decoder = JSONDecoder()
if let decoded = try? decoder.decode(Language.self, from: encoded) {
   //Perform some operations on this value.
}

Baik JSONEncoder dan mitra daftar propertinya PropertyListEncoder memiliki banyak opsi untuk menyesuaikan cara kerjanya.