Swift Language
initializers

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

आप डिफ़ॉल्ट गुण मान सेट करने के लिए इनिशलाइज़र का उपयोग कर सकते हैं:

struct Example {
    var upvotes: Int
    init() {
        upvotes = 42
    }
}
let myExample = Example() // call the initializer
print(myExample.upvotes) // prints: 42

या, संपत्ति की घोषणा के हिस्से के रूप में डिफ़ॉल्ट संपत्ति मान निर्दिष्ट करें:

struct Example {
    var upvotes = 42 // the type 'Int' is inferred here
}

वर्गों और संरचनाओं को सभी संग्रहीत संपत्तियों को एक उपयुक्त प्रारंभिक मूल्य पर उस समय तक सेट करना होगा , जब तक एक उदाहरण बनाया जाता है। यह उदाहरण संकलित नहीं करेगा, क्योंकि शुरुआती ने downvotes लिए प्रारंभिक मूल्य नहीं दिया था:

struct Example {
    var upvotes: Int
    var downvotes: Int
    init() {
         upvotes = 0
    } // error: Return from initializer without initializing all stored properties
}

पैरामाटर्स के साथ अनुकूलन को अनुकूलित करना

struct MetricDistance {
    var distanceInMeters: Double

    init(fromCentimeters centimeters: Double) {
        distanceInMeters = centimeters / 100
    }
    init(fromKilometers kilos: Double) {
        distanceInMeters = kilos * 1000
    }
}

let myDistance = MetricDistance(fromCentimeters: 42)
// myDistance.distanceInMeters is 0.42
let myOtherDistance = MetricDistance(fromKilometers: 42)
// myOtherDistance.distanceInMeters is 42000

ध्यान दें कि आप पैरामीटर लेबल को छोड़ नहीं सकते हैं:

let myBadDistance = MetricDistance(42) // error: argument labels do not match any available overloads

पैरामीटर लेबल की चूक की अनुमति देने के लिए, लेबल के रूप में एक अंडरस्कोर _ उपयोग करें:

struct MetricDistance {
    var distanceInMeters: Double
    init(_ meters: Double) {
        distanceInMeters = meters
    }
}
let myDistance = MetricDistance(42) // distanceInMeters = 42

यदि आपके तर्क लेबल एक या अधिक गुणों के साथ नाम साझा करते हैं, तो संपत्ति मूल्यों को स्पष्ट रूप से सेट करने के लिए self का उपयोग करें:

struct Color {
    var red, green, blue: Double
    init(red: Double, green: Double, blue: Double) {
        self.red = red
        self.green = green
        self.blue = blue
    }
}

सुविधा init

स्विफ्ट कक्षाएं आरंभीकृत होने के कई तरीकों का समर्थन करती हैं। Apple के चश्मे के बाद इस 3 नियमों का सम्मान किया जाना चाहिए:

1. एक नामित इनिलाइज़र को अपने तत्काल सुपरक्लास से एक निर्दिष्ट इनिशलाइज़र को कॉल करना होगा।
2. एक सुविधा इनिलाइज़र को उसी वर्ग से एक और इनिशलाइज़र को कॉल करना होगा।
3. एक सुविधा इनिशियलाइज़र को अंततः एक निर्दिष्ट इनिशियलाइज़र को कॉल करना होगा।

class Foo {

    var someString: String
    var someValue: Int
    var someBool: Bool

    // Designated Initializer
    init(someString: String, someValue: Int, someBool: Bool)
    {
        self.someString = someString
        self.someValue = someValue
        self.someBool = someBool
    }

    // A convenience initializer must call another initializer from the same class.
    convenience init()
    {
        self.init(otherString: "")
    }
    
    // A convenience initializer must ultimately call a designated initializer.
convenience init(otherString: String)
    {
        self.init(someString: otherString, someValue:  0, someBool: false)
    }
}


class Baz: Foo
{
    var someFloat: Float
    
    // Designed initializer
    init(someFloat: Float)
    {
        self.someFloat = someFloat
        
        // A designated initializer must call a designated initializer from its immediate superclass.
        super.init(someString: "", someValue: 0, someBool: false)
    }
    
    // A convenience initializer must call another initializer from the same class.
    convenience init()
    {
        self.init(someFloat: 0)
    }
}

नामित प्रारंभिक

let c = Foo(someString: "Some string", someValue: 10, someBool: true)

सुविधा init ()

let a = Foo()

सुविधा init (अन्य स्ट्रिंग: स्ट्रिंग)

let b = Foo(otherString: "Some string")

नामित प्रारंभिक

let d = Baz(someFloat: 3)

सुविधा init ()

let e = Baz()

छवि स्रोत: स्विफ्ट प्रोग्रामिंग लैंग्वेज ई

थ्रस्टेबल इनटीलाइजर

फेंकने योग्य आरंभक के रूप में संरचना (या वर्ग) आरंभीकरण बनाने में त्रुटि हैंडलिंग का उपयोग करना:

उदाहरण त्रुटि हैंडलिंग एनम:

enum ValidationError: Error {
    case invalid
}

आप संरचना (या वर्ग) की अपेक्षित अपेक्षा को पूरा करने के लिए पैरामीटर की जांच करने के लिए एरर हैंडलिंग एनम का उपयोग कर सकते हैं

struct User {
    let name: String

    init(name: String?) throws {

        guard let name = name else { 
           ValidationError.invalid
        }

        self.name = name
    }
}

अब, आप द्वारा थ्रेशोबल इनिशियलाइज़र का उपयोग कर सकते हैं:

do {
   let user = try User(name: "Sample name")
            
   // success
}
catch ValidationError.invalid {
     // handle error
}