स्विफ्ट - अभिगम नियंत्रण

कोड ब्लॉक तक पहुंच को प्रतिबंधित करने के लिए, एक्सेस कंट्रोल के माध्यम से मॉड्यूल और अमूर्त किया जाता है। वर्गों, संरचनाओं और गणनाओं को उनके गुणों, विधियों, आरम्भकों और अभिगम नियंत्रण तंत्रों द्वारा सदस्यता के अनुसार पहुँचा जा सकता है। एक प्रोटोकॉल में लगातार, चर और फ़ंक्शन प्रतिबंधित हैं और एक्सेस कंट्रोल के माध्यम से वैश्विक और स्थानीय के रूप में उपयोग की अनुमति है। गुणों, प्रकारों और कार्यों पर लागू अभिगम नियंत्रण को 'निकाय' कहा जा सकता है।

एक्सेस कंट्रोल मॉडल मॉड्यूल और स्रोत फ़ाइलों पर आधारित है।

मॉड्यूल को कोड वितरण की एकल इकाई के रूप में परिभाषित किया गया है और इसे 'आयात' कीवर्ड का उपयोग करके आयात किया जा सकता है। एक स्रोत फ़ाइल को एक एकल स्रोत कोड फ़ाइल के रूप में परिभाषित किया जाता है जिसमें कई प्रकार और फ़ंक्शन का उपयोग करने के लिए एक मॉड्यूल होता है।

स्विफ्ट 4 भाषा द्वारा तीन अलग-अलग पहुंच स्तर प्रदान किए जाते हैं। वे सार्वजनिक, आंतरिक और निजी पहुंच वाले हैं।

S.No	पहुँच स्तर और परिभाषा
1	Public संस्थाओं को उनके परिभाषित मॉड्यूल से किसी भी स्रोत फ़ाइल में संसाधित करने में सक्षम बनाता है, दूसरे मॉड्यूल से एक स्रोत फ़ाइल जो परिभाषित मॉड्यूल को आयात करता है।
2	Internal संस्थाओं को उनके परिभाषित मॉड्यूल से किसी भी स्रोत फ़ाइल के भीतर उपयोग करने में सक्षम बनाता है, लेकिन उस मॉड्यूल के बाहर किसी भी स्रोत फ़ाइल में नहीं।
3	Private अपने स्वयं के परिभाषित स्रोत फ़ाइल के लिए एक इकाई के उपयोग को प्रतिबंधित करता है। निजी एक्सेस एक विशिष्ट कोड कार्यक्षमता के कार्यान्वयन विवरण को छिपाने के लिए भूमिका निभाता है।

वाक्य - विन्यास

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

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

फ़ंक्शन प्रकारों के लिए अभिगम नियंत्रण

कुछ कार्यों में बिना किसी रिटर्न मान के फ़ंक्शन के अंदर घोषित किए गए तर्क हो सकते हैं। निम्नलिखित कार्यक्रम योग और (बी) समारोह के तर्क के रूप में घोषित करता है। फ़ंक्शन के अंदर ही फ़ंक्शन कॉल सम () को लागू करके तर्कों के लिए मानों को पारित किया जाता है और इसके मूल्यों को मुद्रित किया जाता है जिससे रिटर्न मान समाप्त हो जाते हैं। फ़ंक्शन के रिटर्न प्रकार को निजी बनाने के लिए, निजी संशोधक के साथ फ़ंक्शन के समग्र पहुंच स्तर की घोषणा करें।

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)

जब हम खेल के मैदान का उपयोग करके उपरोक्त कार्यक्रम चलाते हैं, तो हमें निम्नलिखित परिणाम मिलते हैं -

30 20
50 40
30 24

अभिगम प्रकारों के लिए अभिगम नियंत्रण

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

Student Marks are: 98,97,95

स्विफ्ट 4 भाषा में गणना स्वचालित रूप से एक एन्यूमरेशन के अलग-अलग मामलों के लिए समान पहुंच स्तर प्राप्त करती है। उदाहरण के लिए छात्रों के नाम और तीन विषयों में प्राप्त अंकों तक पहुँचने के लिए विचार करें, नामकरण के छात्र के रूप में घोषित किया गया है और enum वर्ग में मौजूद सदस्यों का नाम है जो स्ट्रिंग डेटाटाइप के अंतर्गत आता है, अंक mark1, mark2 और datatate Integer के mark3 के रूप में दर्शाए जाते हैं। छात्र के नाम या अंकों तक पहुँचने के लिए उन्होंने स्कोर किया है। अब, स्विच केस छात्र के नाम को प्रिंट करेगा यदि उस मामले को निष्पादित किया जाता है तो वह छात्र द्वारा सुरक्षित किए गए अंकों को प्रिंट करेगा। यदि दोनों स्थिति विफल हो जाती है तो डिफ़ॉल्ट ब्लॉक निष्पादित हो जाएगा।

SubClasses के लिए अभिगम नियंत्रण

स्विफ्ट 4 उपयोगकर्ता को किसी भी वर्ग को उप-वर्ग करने की अनुमति देता है जिसे वर्तमान एक्सेस संदर्भ में एक्सेस किया जा सकता है। एक उपवर्ग में अपने सुपरक्लास की तुलना में एक उच्च पहुंच स्तर नहीं हो सकता है। उपयोगकर्ता को आंतरिक सुपरक्लास के सार्वजनिक उपवर्ग लिखने से प्रतिबंधित है।

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()

Welcome to Swift Super Class
Welcome to Swift Sub Class

कॉन्स्टेंट, वैरिएबल, प्रॉपर्टी और सब्सक्रिप्शन के लिए एक्सेस कंट्रोल

स्विफ्ट 4 स्थिर, परिवर्तनशील या संपत्ति को अपने प्रकार से सार्वजनिक रूप से परिभाषित नहीं किया जा सकता है। निजी प्रकार के साथ सार्वजनिक संपत्ति लिखना मान्य नहीं है। इसी तरह, एक सबस्क्रिप्ट अपने सूचकांक या रिटर्न प्रकार से अधिक सार्वजनिक नहीं हो सकता है।

जब एक स्थिर, परिवर्तनीय, संपत्ति, या सबस्क्रिप्ट एक निजी प्रकार का उपयोग करता है, तो स्थिर, चर, संपत्ति, या सबस्क्रिप्ट को भी निजी के रूप में चिह्नित किया जाना चाहिए -

private var privateInstance = SomePrivateClass()

गेटर्स एंड सेटर्स

कॉन्स्टेंट, वेरिएबल, प्रॉपर्टी और सब्सक्रिप्शन के लिए गेटर्स और सेटर अपने आप में स्थिर, वैरिएबल, प्रॉपर्टी या सबस्क्रिप्ट के समान एक्सेस स्तर प्राप्त करते हैं।

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

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

शुरुआती और डिफ़ॉल्ट शुरुआती के लिए अभिगम नियंत्रण

कस्टम इनिशियलाइज़र को उनके द्वारा इनिशियलाइज़ किए जाने वाले प्रकार से कम या बराबर एक्सेस स्तर दिया जा सकता है। एक आवश्यक आरंभक के पास उसी पहुंच स्तर का होना चाहिए, जिस वर्ग का है। एक इनिलाइज़र के मापदंडों के प्रकार इनिशियलाइज़र के अपने पहुँच स्तर से अधिक निजी नहीं हो सकते हैं।

इनिशिएट 'आवश्यक' कीवर्ड के प्रत्येक और प्रत्येक उपवर्ग को इनिट () फ़ंक्शन से पहले परिभाषित करने की आवश्यकता है।

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()

10
30
10

एक डिफ़ॉल्ट इनिशलाइज़र का उपयोग स्तर के समान ही होता है, जब तक कि उस प्रकार को सार्वजनिक के रूप में परिभाषित नहीं किया जाता है। जब डिफ़ॉल्ट इनिशियलाइज़ को सार्वजनिक के रूप में परिभाषित किया जाता है तो इसे आंतरिक माना जाता है। जब उपयोगकर्ता को किसी अन्य मॉड्यूल में नो-लॉजिक इनिशियलाइज़र के साथ तुलना करने के लिए सार्वजनिक प्रकार की आवश्यकता होती है, तो स्पष्ट रूप से एक सार्वजनिक नो-तर्क इनिशलाइज़र प्रदान करते हैं जो कि टाइप की परिभाषा के भाग के रूप में है।

प्रोटोकॉल के लिए अभिगम नियंत्रण

जब हम किसी मौजूदा प्रोटोकॉल से विरासत में नए प्रोटोकॉल को परिभाषित करते हैं, तो दोनों को एक-दूसरे के गुणों को प्राप्त करने के लिए समान पहुंच स्तर घोषित करना पड़ता है। स्विफ्ट 4 का उपयोग नियंत्रण उपयोगकर्ताओं को एक 'सार्वजनिक' प्रोटोकॉल को परिभाषित करने की अनुमति नहीं देगा जो एक 'आंतरिक' प्रोटोकॉल से विरासत में मिला है।

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

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

एक्सटेंशन्स के लिए एक्सेस कंट्रोल

स्विफ्ट 4 उपयोगकर्ताओं को एक विस्तार के लिए एक स्पष्ट पहुंच स्तर संशोधक प्रदान करने की अनुमति नहीं देता है जब उपयोगकर्ता प्रोटोकॉल अनुरूपता को जोड़ने के लिए उस एक्सटेंशन का उपयोग करता है। एक्सटेंशन के भीतर प्रत्येक प्रोटोकॉल आवश्यकता कार्यान्वयन के लिए डिफ़ॉल्ट एक्सेस स्तर अपने स्वयं के प्रोटोकॉल एक्सेस स्तर के साथ प्रदान किया जाता है।

जेनरिक के लिए अभिगम नियंत्रण

जेनरिक उपयोगकर्ता को अपने प्रकार के मापदंडों पर प्रकार की बाधाओं तक पहुँचने के लिए न्यूनतम पहुँच स्तर निर्दिष्ट करने की अनुमति देता है।

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()

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

प्रकार के उपनामों के लिए अभिगम नियंत्रण

उपयोगकर्ता अलग पहुँच नियंत्रण प्रकारों का इलाज करने के लिए प्रकार के उपनामों को परिभाषित कर सकता है। उपयोगकर्ता द्वारा समान पहुंच स्तर या विभिन्न पहुंच स्तरों को परिभाषित किया जा सकता है। जब टाइप उर्फ 'निजी' होता है, तो इसके संबद्ध सदस्यों को 'निजी, सार्वजनिक प्रकार के आंतरिक' के रूप में घोषित किया जा सकता है। जब उपनाम सार्वजनिक होता है तो सदस्यों को 'आंतरिक' या 'निजी' नाम से उपनाम नहीं दिया जा सकता है

आपके द्वारा परिभाषित किसी भी प्रकार के उपनामों को अभिगम नियंत्रण के प्रयोजनों के लिए अलग-अलग प्रकारों के रूप में माना जाता है। एक प्रकार के उपनाम के पास पहुंच के स्तर के बराबर या उससे कम पहुंच स्तर हो सकता है, जहां यह उपनाम है। उदाहरण के लिए, एक निजी प्रकार का उपनाम निजी, आंतरिक या सार्वजनिक प्रकार को अन्य नाम दे सकता है, लेकिन एक सार्वजनिक प्रकार का उपनाम आंतरिक या निजी प्रकार को अन्य नाम नहीं दे सकता है।

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)

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

स्विफ्ट एन्कोडिंग और डिकोडिंग

स्विफ्ट 4 एक नया परिचय देता है Codable प्रोटोकॉल, जो कि आप बिना किसी विशेष कोड को लिखे बिना कस्टम डेटा प्रकारों को क्रमबद्ध और डी-सीरियल करते हैं - और अपने मूल्य प्रकारों को खोने के बारे में चिंता किए बिना।

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

ध्यान दें कि Langauage कोडेबल प्रोटोकॉल के अनुरूप है। अब हम इसे एक सरल लाइन का उपयोग करके Json डेटा रिप्रेजेंटेशन में बदल देंगे।

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

स्विफ्ट आपके डेटा प्रकार के अंदर सभी मानों को स्वचालित रूप से एन्कोड करेगा।

आप डिकोडर फ़ंक्शन का उपयोग करके डेटा को डिकोड कर सकते हैं जैसे

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

JSONEncoder और उसकी संपत्ति सूची समकक्ष दोनों PropertyListEncoder के पास कस्टमाइज़ करने के लिए बहुत सारे विकल्प हैं कि वे कैसे काम करते हैं।