स्विफ्ट - प्रारंभिक

स्विफ्ट 4 में एक बार घोषित की गई कक्षाएं, संरचनाएं और गणनाएं एक वर्ग का उदाहरण तैयार करने के लिए आरंभ की जाती हैं। प्रारंभिक मूल्य संग्रहीत संपत्ति के लिए आरम्भिक है और नए उदाहरणों के लिए भी मूल्यों को आगे बढ़ने के लिए आरम्भ किया गया है। आरंभीकरण फ़ंक्शन बनाने का कीवर्ड 'init ()' विधि द्वारा किया जाता है। स्विफ्ट 4 इनिशियलाइज़र का उद्देश्य वस्तुनिष्ठ-सी से भिन्न है कि यह किसी भी मूल्य को वापस नहीं करता है। इसका कार्य इसके प्रसंस्करण से पहले नए बनाए गए उदाहरणों की प्रारंभिक जांच करना है। स्विफ्ट 4 भी उदाहरणों से निपटने के बाद मेमोरी मैनेजमेंट ऑपरेशन करने के लिए 'डीइनुअलाइजेशन' प्रक्रिया प्रदान करता है।

संग्रहीत गुणों के लिए प्रारंभिक भूमिका

संग्रहीत संपत्ति को इंस्टेंस को संसाधित करने से पहले अपने वर्गों और संरचनाओं के लिए इंस्टेंस को इनिशियलाइज़ करना होगा। संग्रहीत गुण असाइन करने के लिए इनिशियलाइज़र का उपयोग करते हैं और मूल्यों को इनिशियलाइज़ करते हैं जिससे प्रॉपर्टी प्रेक्षकों को कॉल करने की आवश्यकता का उन्मूलन होता है। शुरुआती का उपयोग संग्रहीत संपत्ति में किया जाता है

  • एक प्रारंभिक मूल्य बनाने के लिए।

  • प्रॉपर्टी डेफिनिशन के भीतर डिफ़ॉल्ट प्रॉपर्टी वैल्यू असाइन करने के लिए।

  • किसी विशेष डेटा प्रकार 'init ()' के लिए एक इंस्टेंस को इनिशियलाइज़ करने के लिए प्रयोग किया जाता है। Init () फ़ंक्शन के अंदर कोई तर्क पारित नहीं किया जाता है।

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

init() {
   //New Instance initialization goes here
}

उदाहरण

struct rectangle {
   var length: Double
   var breadth: Double
   init() {
      length = 6
      breadth = 12
   }
}

var area = rectangle()
print("area of rectangle is \(area.length*area.breadth)")

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

area of rectangle is 72.0

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

डिफ़ॉल्ट रूप से संपत्ति मान सेट करना

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

struct rectangle {
   var length = 6
   var breadth = 12
}

var area = rectangle()
print("area of rectangle is \(area.length*area.breadth)")

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

area of rectangle is 72

यहाँ इनिट () में लंबाई और चौड़ाई घोषित करने के बजाय मूल्यों की घोषणा में ही इनिशियलाइज़ किया जाता है।

पैरामीटर प्रारंभ

स्विफ्ट 4 भाषा में उपयोगकर्ता के पास इनिट () का उपयोग करके इनिलाइज़र की परिभाषा के भाग के रूप में मापदंडों को शुरू करने का प्रावधान है।

struct Rectangle {
   var length: Double
   var breadth: Double
   var area: Double
   
   init(fromLength length: Double, fromBreadth breadth: Double) {
      self.length = length
      self.breadth = breadth
      area = length * breadth
   }
   init(fromLeng leng: Double, fromBread bread: Double) {
      self.length = leng
      self.breadth = bread
      area = leng * bread
   }
}

let ar = Rectangle(fromLength: 6, fromBreadth: 12)
print("area is: \(ar.area)")

let are = Rectangle(fromLeng: 36, fromBread: 12)
print("area is: \(are.area)")

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

area is: 72.0
area is: 432.0

स्थानीय और बाहरी पैरामीटर

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

इसे दूर करने के लिए, स्विफ्ट 4 प्रत्येक और हर पैरामीटर के लिए एक स्वचालित बाहरी नाम का परिचय देता है ()। यह स्वचालित बाहरी नाम हर इनिशियलाइज़ेशन पैरामीटर से पहले लिखे गए स्थानीय नाम के बराबर है।

struct Days {
   let sunday, monday, tuesday: Int
   init(sunday: Int, monday: Int, tuesday: Int) {
      self.sunday = sunday
      self.monday = monday
      self.tuesday = tuesday
   }
   init(daysofaweek: Int) {
      sunday = daysofaweek
      monday = daysofaweek
      tuesday = daysofaweek
   }
}

let week = Days(sunday: 1, monday: 2, tuesday: 3)
print("Days of a Week is: \(week.sunday)")
print("Days of a Week is: \(week.monday)")
print("Days of a Week is: \(week.tuesday)")

let weekdays = Days(daysofaweek: 4)
print("Days of a Week is: \(weekdays.sunday)")
print("Days of a Week is: \(weekdays.monday)")
print("Days of a Week is: \(weekdays.tuesday)")

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

Days of a Week is: 1
Days of a Week is: 2
Days of a Week is: 3
Days of a Week is: 4
Days of a Week is: 4
Days of a Week is: 4

बाहरी नाम के बिना पैरामीटर

जब एक प्रारंभिक नाम के लिए बाहरी नाम की आवश्यकता नहीं होती है तो डिफ़ॉल्ट व्यवहार को ओवरराइड करने के लिए '_' का उपयोग किया जाता है।

struct Rectangle {
   var length: Double
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

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

area is: 180.0
area is: 370.0
area is: 110.0

वैकल्पिक संपत्ति प्रकार

जब किसी उदाहरण पर संग्रहीत संपत्ति किसी भी मूल्य को वापस नहीं करती है, तो उस संपत्ति को एक 'वैकल्पिक' प्रकार के साथ घोषित किया जाता है जो दर्शाता है कि उस विशेष प्रकार के लिए 'कोई मूल्य नहीं' लौटाया गया है। जब संग्रहीत संपत्ति को 'वैकल्पिक' के रूप में घोषित किया जाता है, तो यह प्रारंभ में ही मूल्य को 'एनआईएल' होने के लिए स्वचालित रूप से आरंभ करता है।

struct Rectangle {
   var length: Double?
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

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

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

प्रारंभ के दौरान लगातार गुणों को संशोधित करना

प्रारंभिककरण भी उपयोगकर्ता को निरंतर संपत्ति के मूल्य को संशोधित करने की अनुमति देता है। प्रारंभिककरण के दौरान, वर्ग संपत्ति अपने वर्ग के उदाहरणों को सुपर क्लास द्वारा संशोधित करने की अनुमति देती है न कि उपवर्ग द्वारा। पिछले कार्यक्रम में उदाहरण के लिए विचार करें 'लंबाई' को मुख्य वर्ग में 'चर' के रूप में घोषित किया गया है। नीचे दिए गए कार्यक्रम चर 'लंबाई' को 'स्थिर' चर के रूप में संशोधित किया गया है।

struct Rectangle {
   let length: Double?
   
   init(frombreadth breadth: Double) {
      length = breadth * 10
   }
   init(frombre bre: Double) {
      length = bre * 30
   }
   init(_ area: Double) {
      length = area
   }
}

let rectarea = Rectangle(180.0)
print("area is: \(rectarea.length)")

let rearea = Rectangle(370.0)
print("area is: \(rearea.length)")

let recarea = Rectangle(110.0)
print("area is: \(recarea.length)")

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

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

डिफ़ॉल्ट प्रारंभकर्ता

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

class defaultexample {
   var studname: String?
   var stmark = 98
   var pass = true
}
var result = defaultexample()

print("result is: \(result.studname)")
print("result is: \(result.stmark)")
print("result is: \(result.pass)")

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

result is: nil
result is: 98
result is: true

उपरोक्त कार्यक्रम को क्लास के नाम के साथ 'डिफ्लेक्सप्लांट' के रूप में परिभाषित किया गया है। तीन सदस्य कार्यों को 'स्टूडियोनाम' के रूप में डिफ़ॉल्ट रूप से आरंभ किया जाता है? 'शून्य' मानों को संग्रहीत करने के लिए, 'stmark' को 98 और 'पास' को बूलियन मान 'सत्य' के रूप में देखें। इसी तरह कक्षा के सदस्य प्रकारों को संसाधित करने से पहले कक्षा में सदस्य मानों को डिफ़ॉल्ट के रूप में आरंभीकृत किया जा सकता है।

संरचना के प्रकार के लिए सदस्य प्रारंभिक

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

struct Rectangle {
   var length = 100.0, breadth = 200.0
}
let area = Rectangle(length: 24.0, breadth: 32.0)

print("Area of rectangle is: \(area.length)")
print("Area of rectangle is: \(area.breadth)")

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

Area of rectangle is: 24.0
Area of rectangle is: 32.0

संरचनाएं 'लंबाई' के लिए '100.0' और 'चौड़ाई' के रूप में 'लंबाई' के लिए प्रारंभ होने के दौरान उनके सदस्यता कार्यों के लिए डिफ़ॉल्ट रूप से आरंभीकृत की जाती हैं। लेकिन 24.0 और 32.0 के रूप में चर लंबाई और चौड़ाई के प्रसंस्करण के दौरान मूल्यों को ओवरराइड किया जाता है।

मूल्य प्रकार के लिए प्रारंभिक प्रतिनिधि

इनिशियलाइज़र डेलिगेशन को अन्य इनिशियलाइज़र से इनिशियलाइज़र के रूप में परिभाषित किया गया है। इसका मुख्य कार्य मल्टीपल इनिशियलाइज़र के पार कोड दोहराव से बचने के लिए पुन: प्रयोज्य के रूप में कार्य करना है।

struct Stmark {
   var mark1 = 0.0, mark2 = 0.0
}
struct stdb {
   var m1 = 0.0, m2 = 0.0
}

struct block {
   var average = stdb()
   var result = Stmark()
   init() {}
   init(average: stdb, result: Stmark) {
      self.average = average
      self.result = result
   }

   init(avg: stdb, result: Stmark) {
      let tot = avg.m1 - (result.mark1 / 2)
      let tot1 = avg.m2 - (result.mark2 / 2)
      self.init(average: stdb(m1: tot, m2: tot1), result: result)
   }
}

let set1 = block()
print("student result is: \(set1.average.m1, set1.average.m2)
\(set1.result.mark1, set1.result.mark2)")

let set2 = block(average: stdb(m1: 2.0, m2: 2.0),
result: Stmark(mark1: 5.0, mark2: 5.0))
print("student result is: \(set2.average.m1, set2.average.m2)
\(set2.result.mark1, set2.result.mark2)")

let set3 = block(avg: stdb(m1: 4.0, m2: 4.0),
result: Stmark(mark1: 3.0, mark2: 3.0))
print("student result is: \(set3.average.m1, set3.average.m2)
\(set3.result.mark1, set3.result.mark2)")

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

(0.0,0.0) (0.0,0.0)
(2.0,2.0) 5.0,5.0)
(2.5,2.5) (3.0,3.0)

शुरुआती प्रतिनिधि के लिए नियम

मान प्रकार वर्ग के प्रकार
संरचना और गणना जैसे मूल्य प्रकारों के लिए विरासत का समर्थन नहीं किया जाता है। अन्य इनिशियलाइज़र्स का उल्लेख self.init के माध्यम से किया जाता है वंशानुक्रम समर्थित है। सभी संग्रहीत संपत्ति मान चेक किए गए हैं

क्लास इनहेरिटेंस एंड इनिशियलाइज़ेशन

वर्ग प्रकारों में दो प्रकार के आरम्भिकारक होते हैं, जो यह जाँचते हैं कि परिभाषित संचित गुण प्रारंभिक आरम्भिक और सुविधा आरम्भक नाम से एक प्रारंभिक मूल्य प्राप्त करते हैं।

नामित शुरुआती और सुविधा शुरुआती

नामित प्रारंभिक सुविधा प्रारंभिक
एक वर्ग के लिए प्राथमिक के रूप में माना जाता है एक वर्ग के लिए प्रारंभिक समर्थन के रूप में माना जाता है
सभी वर्ग गुणों को आरंभीकृत किया जाता है और आगे के आरंभीकरण के लिए उपयुक्त सुपरक्लास इनिशलाइज़र कहा जाता है विशिष्ट उपयोग के मामले या इनपुट मूल्य प्रकार के लिए वर्ग उदाहरण बनाने के लिए डिजाइन इनिशियलाइज़र को सुविधा इनिशियलाइज़र के साथ कहा जाता है
हर वर्ग के लिए कम से कम एक निर्दिष्ट इनिशिएटिव परिभाषित किया गया है जब क्लास को इनिशियलाइज़र की आवश्यकता न हो तो सुविधा इनिशियलाइज़र को अनिवार्य रूप से परिभाषित करने की आवश्यकता नहीं है।
Init (पैरामीटर) {स्टेटमेंट} सुविधा init (पैरामीटर) {स्टेटमेंट}

नामित शुरुआती के लिए कार्यक्रम

class mainClass {
   var no1 : Int // local storage
   init(no1 : Int) {
      self.no1 = no1 // initialization
   }
}

class subClass : mainClass {
   var no2 : Int // new subclass storage
   init(no1 : Int, no2 : Int) {
      self.no2 = no2 // initialization
      super.init(no1:no1) // redirect to superclass
   }
}

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

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

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

res is: 10
res is: 10
res is: 20

सुविधा शुरुआती के लिए कार्यक्रम

class mainClass {
   var no1 : Int // local storage
   init(no1 : Int) {
      self.no1 = no1 // initialization
   }
}

class subClass : mainClass {
   var no2 : Int
   init(no1 : Int, no2 : Int) {
      self.no2 = no2
      super.init(no1:no1)
   }
   // Requires only one parameter for convenient method
   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 अपने उपवर्गों को डिफ़ॉल्ट रूप से अपने सदस्य प्रकारों के लिए अपने सुपरक्लास इनिशियलाइज़र को विरासत में प्राप्त करने की अनुमति नहीं देता है। इनहेरिटेंस केवल कुछ हद तक सुपर क्लास इनिशियलाइज़र पर लागू होता है, जिस पर ऑटोमैटिक इनिशिएटिव इंहेरिटेंस में चर्चा की जाएगी।

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

class sides {
   var corners = 4
   var description: String {
      return "\(corners) sides"
   }
}

let rectangle = sides()
print("Rectangle: \(rectangle.description)")

class pentagon: sides {
   override init() {
      super.init()
      corners = 5
   }
}

let bicycle = pentagon()
print("Pentagon: \(bicycle.description)")

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

Rectangle: 4 sides
Pentagon: 5 sides

एक्शन में नामित और सुविधा शुरुआती

class Planet {
   var name: String
   init(name: String) {
      self.name = name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}

let plName = Planet(name: "Mercury")
print("Planet name is: \(plName.name)")

let noplName = Planet()
print("No Planets like that: \(noplName.name)")

class planets: Planet {
   var count: Int
   init(name: String, count: Int) {
      self.count = count
      super.init(name: name)
   }
   override convenience init(name: String) {
      self.init(name: name, count: 1)
   }
}

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

Planet name is: Mercury
No Planets like that: [No Planets]

फेलियर इनिशियलाइज़र

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

  • अमान्य पैरामीटर मान।
  • आवश्यक बाहरी स्रोत की अनुपस्थिति।
  • प्रारंभिक अवस्था को सफल होने से रोकने वाली स्थिति।

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

struct studrecord {
   let stname: String
   init?(stname: String) {
      if stname.isEmpty {return nil }
      self.stname = stname
   }
}
let stmark = studrecord(stname: "Swing")

if let name = stmark {
   print("Student name is specified")
}
let blankname = studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

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

Student name is specified
Student name is left blank

गणना के लिए अनुपलब्ध प्रारंभिक

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

enum functions {
   case a, b, c, d
   init?(funct: String) {
      switch funct {
      case "one":
         self = .a
      case "two":
         self = .b
      case "three":
         self = .c
      case "four":
         self = .d
      default:
         return nil
      }
   }
}
let result = functions(funct: "two")

if result != nil {
   print("With In Block Two")
}
let badresult = functions(funct: "five")

if badresult == nil {
   print("Block Does Not Exist")
}

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

With In Block Two
Block Does Not Exist

कक्षाओं के लिए अनुपलब्ध प्रारंभिक

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

class studrecord {
   let studname: String!
   init?(studname: String) {
      self.studname = studname
      if studname.isEmpty { return nil }
   }
}

if let stname = studrecord(studname: "Failable Initializers") {
   print("Module is \(stname.studname)")
}

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

Module is Optional("Failable Initializers")

एक अनुपूरक प्रारंभिक ओवरराइडिंग

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

जब एक नॉन-फेकल सबक्लास इनिशियलाइज़ के साथ एक फालतू सुपरक्लास इनिशियलाइज़र को ओवरराइड कर रहा होता है, तब उपक्लास इनिशियलाइज़र सुपरक्लास इनिशियलाइज़र को नहीं सौंप सकता।

एक गैर-फेलियर इनिशियलाइज़र एक फ़र्ज़ी इनिशियलाइज़र को कभी नहीं सौंप सकता है।

नीचे दिए गए कार्यक्रम में फेकल और नॉन-फेलियर इनिशियलाइज़र का वर्णन किया गया है।

class Planet {
   var name: String
   
   init(name: String) {
      self.name = name
   }
   convenience init() {
      self.init(name: "[No Planets]")
   }
}
let plName = Planet(name: "Mercury")
print("Planet name is: \(plName.name)")

let noplName = Planet()
print("No Planets like that: \(noplName.name)")
   
class planets: Planet {
   var count: Int
   
   init(name: String, count: Int) {
      self.count = count
      super.init(name: name)
   }
   override convenience init(name: String) {
      self.init(name: name, count: 1)
   }
}

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

Planet name is: Mercury
No Planets like that: [No Planets]

Init! फेलियर इनिशियलाइज़र

स्विफ्ट 4 प्रदान करता है 'init?' एक वैकल्पिक उदाहरण को परिभाषित करने के लिए प्रारंभिक आरम्भक। विशिष्ट प्रकार के एक अंतर्निहित अलिखित वैकल्पिक उदाहरण को परिभाषित करने के लिए 'init!' अधिकृत है।

struct studrecord {
let stname: String

   init!(stname: String) {
      if stname.isEmpty {return nil }
      self.stname = stname
   }
}
let stmark = studrecord(stname: "Swing")

if let name = stmark {
   print("Student name is specified")
}

let blankname = studrecord(stname: "")

if blankname == nil {
   print("Student name is left blank")
}

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

Student name is specified
Student name is left blank

आवश्यक प्रारंभकर्ता

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

class classA {
   required init() {
      var a = 10
      print(a)
   }
}

class classB: classA {
   required init() {
      var b = 30
      print(b)
   }
}

let res = classA()
let print = classB()

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

10
30
10