स्विफ्ट - तरीके

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

उदाहरण के तरीके

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

उदाहरण के तरीके कार्यक्षमता प्रदान करते हैं

• इंस्टेंस प्रॉपर्टीज को एक्सेस और संशोधित करना
• आवृत्ति उदाहरण की जरूरत से संबंधित है

इंस्टेंस विधि को {} कर्ली ब्रेसेस के अंदर लिखा जा सकता है। इसमें प्रकार के उदाहरण के तरीकों और गुणों तक अंतर्निहित पहुंच है। जब एक विशिष्ट प्रकार के उदाहरण को बुलाया जाता है तो उसे उस विशेष उदाहरण तक पहुंच प्राप्त होगी।

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

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

उदाहरण

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}
let pri = calculations(a: 600, b: 300)
pri.result()

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

Result is: 880
Result is: 850

कक्षा गणना दो उदाहरण विधियों को परिभाषित करती है -

• init () को दो संख्याओं a और b को जोड़ने और परिणाम 'res' में संग्रहीत करने के लिए परिभाषित किया गया है
• 'c' मान को पास करने से 'res' को घटाने के लिए tot () का उपयोग किया जाता है

अंत में, ए और बी के मूल्यों के साथ गणना के तरीकों को मुद्रित करने के लिए कहा जाता है। इंस्टेंस मेथड्स 'के साथ एक्सेस किए जाते हैं।' डॉट सिंटैक्स

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

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

स्विफ्ट 4 पहले पैरामीटर नाम को स्थानीय पैरामीटर नामों और शेष पैरामीटर नामों को वैश्विक पैरामीटर नामों के रूप में घोषित करके विधियों में लचीलापन प्रदान करता है। यहां 'no1' को स्विफ्ट 4 विधियों द्वारा स्थानीय पैरामीटर नामों के रूप में घोषित किया गया है। 'no2' का उपयोग वैश्विक घोषणाओं के लिए किया जाता है और इसे कार्यक्रम के माध्यम से एक्सेस किया जाता है।

class division {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 / no2
      print(count)
   }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

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

600
320
3666

बाहरी पैरामीटर नाम # और _ चिह्न के साथ

भले ही स्विफ्ट 4 विधियाँ स्थानीय घोषणाओं के लिए पहला पैरामीटर नाम प्रदान करती हैं, उपयोगकर्ता के पास स्थानीय नामों से स्थानीय घोषणाओं को संशोधित करने का प्रावधान है। यह पहले पैरामीटर नाम के साथ '#' प्रतीक को उपसर्ग करके किया जा सकता है। ऐसा करने से, पहले पैरामीटर को पूरे मॉड्यूल में वैश्विक रूप से एक्सेस किया जा सकता है।

जब उपयोगकर्ता को बाहरी नाम के बाद के पैरामीटर नामों तक पहुंचने की आवश्यकता होती है, तो '_' चिन्ह की मदद से विधियों का नाम ओवरराइड हो जाता है।

class multiplication {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 * no2
      print(count)
   }
}

let counter = multiplication()

counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)

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

2400
500
45000

विधियों में स्व गुण

विधियों में एक निहित संपत्ति होती है जिसे उसके सभी परिभाषित प्रकार के उदाहरणों के लिए 'स्व' के रूप में जाना जाता है। 'स्व' संपत्ति का उपयोग इसके परिभाषित तरीकों के लिए वर्तमान उदाहरणों को संदर्भित करने के लिए किया जाता है।

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
      print("Inside Self Block: \(res)")
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

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

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

इंस्टैंस मेथड्स से मॉडिफाइड वैल्यू टाइप्स

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

struct area {
   var length = 1
   var breadth = 1
   
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      length *= res
      breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

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

9
15
270
450
81000
135000

उत्परिवर्तन विधि के लिए स्व संपत्ति

'स्वयं' संपत्ति के साथ संयुक्त उत्परिवर्तन विधियाँ परिभाषित पद्धति को एक नया उदाहरण प्रदान करती हैं।

struct area {
   var length = 1
   var breadth = 1
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      self.length *= res
      self.breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

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

39
65

टाइप मेथड्स

जब किसी विधि का एक विशेष उदाहरण कहा जाता है, तो इसे इंस्टेंस विधि कहा जाता है; और जब विधि किसी विशेष प्रकार की विधि कहती है, तो उसे 'टाइप मेथड्स' कहा जाता है। 'वर्गों ’के लिए टाइप विधियां for फंक’ कीवर्ड द्वारा परिभाषित की जाती हैं और संरचनाएं और गणना प्रकार प्रकार c फंक ’कीवर्ड से पहले the स्टैटिक’ कीवर्ड से परिभाषित होते हैं।

प्रकार के तरीकों को 'द्वारा बुलाया और एक्सेस किया जाता है।' वाक्य-विन्यास जहाँ एक विशेष उदाहरण को कॉल करने के बजाय पूरी विधि को लागू किया जाता है।

class Math {
   class func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

struct absno {
   static func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

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

35
5