स्विफ्ट - त्वरित गाइड

स्विफ्ट 4 आईओएस और ओएस एक्स के विकास के लिए ऐप्पल इंक द्वारा विकसित एक नई प्रोग्रामिंग भाषा है। स्विफ्ट 4 सी संगतता के बाधाओं के बिना, सी और उद्देश्य-सी में से सबसे अच्छा गोद लेती है।

स्विफ्ट 4 सुरक्षित प्रोग्रामिंग पैटर्न का उपयोग करता है।
स्विफ्ट 4 आधुनिक प्रोग्रामिंग सुविधाएँ प्रदान करता है।
स्विफ्ट 4 सिंटेक्स की तरह ऑब्जेक्टिव-सी प्रदान करता है।
स्विफ्ट 4 आईओएस और ओएस एक्स ऐप लिखने का एक शानदार तरीका है।
स्विफ्ट 4 मौजूदा कोको फ्रेमवर्क के लिए सहज पहुंच प्रदान करता है।
स्विफ्ट 4 भाषा के प्रक्रियात्मक और वस्तु-उन्मुख भागों को एकीकृत करता है।
स्विफ्ट 4 को इनपुट / आउटपुट या स्ट्रिंग हैंडलिंग जैसी कार्यात्मकताओं का समर्थन करने के लिए एक अलग पुस्तकालय आयात की आवश्यकता नहीं है।

स्विफ्ट 4 मैक ओएस और आईओएस पर मौजूदा ओब्ज-सी प्रणाली के समान रनटाइम का उपयोग करता है, जो स्विफ्ट 4 कार्यक्रमों को कई मौजूदा आईओएस 6 और ओएस एक्स 10.8 प्लेटफार्मों पर चलने में सक्षम बनाता है।

स्विफ्ट 4 खेल के मैदान की सुविधा के साथ आता है, जहां स्विफ्ट 4 प्रोग्रामर अपना कोड लिख सकते हैं और तुरंत परिणाम देखने के लिए इसे निष्पादित कर सकते हैं।

स्विफ्ट की पहली सार्वजनिक रिलीज़ 2010 में रिलीज़ हुई थी Chris Lattnerपहले आधिकारिक संस्करण के साथ आने के लिए लगभग 14 साल, और बाद में, इसे कई अन्य योगदानकर्ताओं द्वारा समर्थित किया गया था। स्विफ्ट 4 को Xcode 6 बीटा में शामिल किया गया है।

स्विफ्ट डिजाइनरों ने कई अन्य लोकप्रिय भाषाओं जैसे कि ऑब्जेक्टिव-सी, रस्ट, हास्केल, रूबी, पायथन, सी #, और सीएलयू से विचारों को लिया।

स्थानीय पर्यावरण सेटअप

स्विफ्ट 4 सीखने के उद्देश्य के लिए एक खेल का मैदान प्रदान करता है और हम इसे सेटअप करने जा रहे हैं। प्लेग्राउंड में अपना स्विफ्ट 4 कोडिंग शुरू करने के लिए आपको xCode सॉफ्टवेयर की आवश्यकता है। एक बार जब आप स्विफ्ट 4 की अवधारणाओं के साथ सहज होते हैं, तो आप iOS / OS x अनुप्रयोग विकास के लिए xCode IDE का उपयोग कर सकते हैं।

शुरू करने के लिए, हम आपको पहले से ही Apple डेवलपर वेबसाइट पर एक खाता मानते हैं। एक बार लॉग इन करने के बाद, निम्न लिंक पर जाएं - Apple डेवलपर्स के लिए डाउनलोड करें

यह निम्न प्रकार से उपलब्ध कई सॉफ्टवेयरों को सूचीबद्ध करेगा -

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

अब आपके पास आपके मशीन पर xCode स्थापित है। अगला, एप्लिकेशन फ़ोल्डर से Xcode खोलें और नियम और शर्तों को स्वीकार करने के बाद आगे बढ़ें। यदि सब कुछ ठीक है, तो आपको निम्न स्क्रीन मिलेगी -

चुनते हैं Get started with a playgroundविकल्प और खेल के मैदान के लिए एक नाम दर्ज करें और मंच के रूप में आईओएस का चयन करें। अंत में, आप इस प्रकार के रूप में खेल का मैदान खिड़की मिल जाएगा -

निम्नलिखित डिफ़ॉल्ट स्विफ्ट 4 प्लेग्राउंड विंडो से लिया गया कोड है।

import UIKit
var str = "Hello, playground"

यदि आप OS X प्रोग्राम के लिए एक ही प्रोग्राम बनाते हैं, तो इसमें इम्पोर्ट कोको शामिल होगा और प्रोग्राम इस प्रकार दिखेगा -

import Cocoa
var str = "Hello, playground"

जब उपरोक्त कार्यक्रम लोड हो जाता है, तो इसे प्लेग्राउंड परिणाम क्षेत्र (राइट हैंड साइड) में निम्न परिणाम प्रदर्शित करना चाहिए।

Hello, playground

बधाई हो, आपके पास अपना स्विफ्ट 4 प्रोग्रामिंग वातावरण तैयार है और आप अपने सीखने के वाहन "ट्यूटोरियल पॉइंट" के साथ आगे बढ़ सकते हैं।

पर्यावरण की स्थापना करते हुए हमने पहले ही स्विफ्ट 4 कार्यक्रम का एक टुकड़ा देखा है। चलो एक बार फिर से निम्नलिखित के साथ शुरू करते हैंHello, World! OS X खेल के मैदान के लिए बनाया गया कार्यक्रम, जिसमें शामिल हैं import Cocoa जैसा कि नीचे दिखाया गया है -

/* My first program in Swift 4 */
var myString = "Hello, World!"

print(myString)

यदि आप आईओएस खेल के मैदान के लिए एक ही कार्यक्रम बनाते हैं, तो इसमें शामिल होगा import UIKit और कार्यक्रम इस प्रकार दिखेगा -

import UIKit
var myString = "Hello, World!"
print(myString)

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

Hello, World!

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

स्विफ्ट 4 में आयात

आप उपयोग कर सकते हैं importअपने स्विफ्ट 4 प्रोग्राम में सीधे किसी भी उद्देश्य-सी फ्रेमवर्क (या सी लाइब्रेरी) को आयात करने का विवरण। उदाहरण के लिए, ऊपरimport cocoa कथन सभी कोको पुस्तकालयों, एपीआई और रनटाइम्स बनाता है जो स्विफ्ट 4 में उपलब्ध ओएस एक्स के सभी के लिए विकास परत बनाते हैं।

कोको को ऑब्जेक्टिव-सी में लागू किया जाता है, जो सी का एक सुपरसेट है, इसलिए सी और यहां तक कि सी ++ को आपके स्विफ्ट 4 अनुप्रयोगों में मिश्रण करना आसान है।

स्विफ्ट 4 में टोकन

स्विफ्ट 4 कार्यक्रम में विभिन्न टोकन शामिल हैं और एक टोकन या तो एक कीवर्ड, एक पहचानकर्ता, एक निरंतर, एक स्ट्रिंग शाब्दिक, या एक प्रतीक है। उदाहरण के लिए, निम्नलिखित स्विफ्ट 4 स्टेटमेंट में तीन टोकन शामिल हैं -

print("test!")
The individual tokens are:
print("test!")

टिप्पणियाँ आपके स्विफ्ट 4 कार्यक्रम में ग्रंथों की मदद करने जैसी हैं। उन्हें संकलक द्वारा अनदेखा किया जाता है। बहु-पंक्ति टिप्पणियाँ / * से शुरू होती हैं और पात्रों के साथ समाप्त होती हैं * / जैसा कि नीचे दिखाया गया है -

/* My first program in Swift 4 */

मल्टी-लाइन टिप्पणियों को स्विफ्ट 4 में घोंसला दिया जा सकता है। निम्नलिखित स्विफ्ट 4 में एक वैध टिप्पणी है -

/* My first program in Swift 4 is Hello, World!
/* Where as second program is Hello, Swift 4! */ */

टिप्पणी की शुरुआत में एकल-पंक्ति टिप्पणियों का उपयोग // लिखा जाता है।

// My first program in Swift 4

अर्धविराम

स्विफ्ट 4 को आपके कोड में प्रत्येक कथन के बाद अर्धविराम (;) टाइप करने की आवश्यकता नहीं है, हालांकि यह वैकल्पिक है; और यदि आप अर्धविराम का उपयोग करते हैं, तो संकलक इसके बारे में शिकायत नहीं करता है।

हालाँकि, यदि आप एक ही पंक्ति में कई स्टेटमेंट्स का उपयोग कर रहे हैं, तो एक अर्धविराम को सीमांकक के रूप में उपयोग करना आवश्यक है, अन्यथा कंपाइलर एक सिंटैक्स त्रुटि उठाएगा। आप उपरोक्त हैलो, विश्व लिख सकते हैं! कार्यक्रम इस प्रकार है -

/* My first program in Swift 4 */
var myString = "Hello, World!"; print(myString)

पहचानकर्ता

स्विफ्ट 4 आइडेंटिफायर एक ऐसा नाम है जिसका इस्तेमाल वैरिएबल, फंक्शन या किसी अन्य यूजरडिफाइंड आइटम की पहचान करने के लिए किया जाता है। एक पहचानकर्ता वर्णमाला A से Z या z या एक अंडरस्कोर _ से शुरू होता है, जिसके बाद शून्य या अधिक अक्षर, अंडरस्कोर और अंक (0 से 9) होते हैं।

स्विफ्ट 4 विशेष अक्षर जैसे @, $, और% को पहचानकर्ताओं के भीतर अनुमति नहीं देता है। स्विफ्ट 4 एक हैcase sensitiveप्रोग्रामिंग भाषा। इस प्रकार, स्विफ्ट 4 में मैनपावर और मैनपावर दो अलग-अलग पहचानकर्ता हैं। यहां स्वीकार्य पहचानकर्ताओं के कुछ उदाहरण दिए गए हैं -

Azad        zara   abc   move_name   a_123
myname50    _temp  j     a23b9       retVal

एक पहचानकर्ता के रूप में आरक्षित शब्द का उपयोग करने के लिए, आपको इससे पहले और बाद में एक बैकटिक (`) लगाना होगा। उदाहरण के लिए,class एक वैध पहचानकर्ता नहीं है, लेकिन `class`वैध है।

कीवर्ड

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

घोषणाओं में प्रयुक्त खोजशब्द

कक्षा	deinit	enum	एक्सटेंशन
समारोह	आयात	में इस	अंदर का
लश्कर	ऑपरेटर	निजी	मसविदा बनाना
जनता	स्थिर	struct	सबस्क्रिप्ट
typealias	वर

बयानों में उपयोग किए गए कीवर्ड

टूटना	मामला	जारी रखें	चूक
कर	अन्य	असफल	के लिये
अगर	में	वापसी	स्विच
कहाँ पे	जबकि

अभिव्यक्तियों और प्रकारों में उपयोग किए जाने वाले कीवर्ड

जैसा	dynamicType	असत्य	है
शून्य	स्वयं	स्वयं	उत्तम
सच	_COLUMN_	_FILE_	_समारोह_
_LINE_

विशेष संदर्भों में प्रयुक्त खोजशब्द

संबद्धता	सुविधा	गतिशील	didSet
अंतिम	प्राप्त	इन्फ़िक्स	अंदर बाहर
आलसी	बाएं	परिवर्तनशील	कोई नहीं
nonmutating	ऐच्छिक	अवहेलना	पोस्टफ़िक्स
प्रधानता	उपसर्ग	मसविदा बनाना	अपेक्षित
सही	सेट	प्रकार	किसी का नहीं
कमज़ोर	स्थापित करेगा

व्हाइटस्पेस

एक लाइन जिसमें केवल व्हॉट्सएप होता है, संभवतः एक टिप्पणी के साथ, एक रिक्त लाइन के रूप में जाना जाता है, और एक स्विफ्ट 4 कंपाइलर पूरी तरह से इसे अनदेखा करता है।

व्हॉट्सएप का प्रयोग स्विफ्ट 4 में रिक्त स्थान, टैब, न्यूलाइन वर्ण और टिप्पणियों का वर्णन करने के लिए किया जाता है। व्हाट्सएप एक स्टेटमेंट के एक हिस्से को दूसरे से अलग करता है और कंपाइलर को यह पहचानने में सक्षम करता है कि एक स्टेटमेंट में कोई तत्व, जैसे इंट, एंड और अगला एलिमेंट कहां से शुरू होता है। इसलिए, निम्नलिखित कथन में -

var age

बीच में कम से कम एक व्हाट्सएप चरित्र (आमतौर पर एक स्थान) होना चाहिए var तथा ageसंकलक के लिए उन्हें भेद करने में सक्षम होने के लिए। दूसरी ओर, निम्नलिखित कथन में -

int fruit = apples + oranges   //get the total fruits

फल और =, या सेब और सेब के बीच कोई व्हाट्सएप वर्ण आवश्यक नहीं है, हालांकि आप बेहतर पठनीयता के लिए कुछ को शामिल करने के लिए स्वतंत्र हैं।

एक ऑपरेटर के दोनों तरफ का स्थान बराबर होना चाहिए, उदाहरण के लिए।

int fruit = apples +oranges    //is a wrong statement
int fruit = apples + oranges   //is a Correct statement

शाब्दिक

एक शाब्दिक एक पूर्णांक, फ्लोटिंग-पॉइंट नंबर या स्ट्रिंग प्रकार के मूल्य का स्रोत कोड प्रतिनिधित्व है। निम्नलिखित शाब्दिक उदाहरण हैं -

92               // Integer literal
4.24159          // Floating-point literal
"Hello, World!"  // String literal

स्विफ्ट में छपाई

कुछ भी तेज़ी से प्रिंट करने के लिए हमारे पास 'प्रिंट' कीवर्ड है।

प्रिंट के तीन अलग-अलग गुण हैं।

Items - आइटम मुद्रित किया जाना है

Separator - आइटम के बीच विभाजक

Terminator - किस लाइन के साथ मूल्य समाप्त होना चाहिए, आइए उसी का एक उदाहरण और वाक्यविन्यास देखें।

print("Items to print", separator: "Value " , terminator: "Value")
// E.g. of print statement.

print("Value one")
// prints "Value one \n" Adds, \n as terminator and " " as separator by
default.

print("Value one","Value two", separator: " Next Value" , terminator: " End")
//prints "Value one Next Value Value two End"

उपरोक्त कोड में पहला प्रिंट स्टेटमेंट डिफॉल्ट रूप से टर्मिनेटर के रूप में newline फीड जोड़ता है, जहां दूसरे प्रिंट स्टेटमेंट में हमने टर्मिनेटर के रूप में "End" दिया है, इसलिए यह \ n के बजाय "End" प्रिंट करेगा।

हम अपनी आवश्यकता के अनुसार अपने कस्टम सेपरेटर और टर्मिनेटर दे सकते हैं।

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

आप स्ट्रिंग, चरित्र, विस्तृत चरित्र, पूर्णांक, फ्लोटिंग पॉइंट, बूलियन, आदि जैसे विभिन्न डेटा प्रकारों की जानकारी संग्रहीत करना पसंद कर सकते हैं। एक चर के डेटा प्रकार के आधार पर, ऑपरेटिंग सिस्टम मेमोरी आवंटित करता है और फैसला करता है कि आरक्षित में क्या संग्रहीत किया जा सकता है। याद।

अंतर्निहित डेटा प्रकार

स्विफ्ट 4 प्रोग्रामर को बिल्ट-इन के साथ-साथ उपयोगकर्ता-परिभाषित डेटा प्रकारों का एक समृद्ध वर्गीकरण प्रदान करता है। चरों की घोषणा करते समय निम्न प्रकार के बुनियादी डेटा प्रकार सबसे अधिक होते हैं -

Int or UInt- यह पूरे नंबर के लिए उपयोग किया जाता है। अधिक विशेष रूप से, आप 32 या 64 बिट हस्ताक्षरित पूर्णांक को परिभाषित करने के लिए Int32, Int64 का उपयोग कर सकते हैं, जबकि UInt32 या UInt64 32 या 64 बिट अहस्ताक्षरित पूर्णांक चर को परिभाषित करने के लिए। उदाहरण के लिए, 42 और -23।
Float- इसका उपयोग 32-बिट फ्लोटिंग-पॉइंट संख्या और छोटे दशमलव बिंदुओं के साथ संख्याओं का प्रतिनिधित्व करने के लिए किया जाता है। उदाहरण के लिए, 3.14159, 0.1, और -273.158।
Double- इसका उपयोग 64-बिट फ्लोटिंग-पॉइंट संख्या का प्रतिनिधित्व करने के लिए किया जाता है और इसका उपयोग तब किया जाता है जब फ़्लोटिंग-पॉइंट मान बहुत बड़ा होना चाहिए। उदाहरण के लिए, 3.14159, 0.1, और -273.158।
Bool - यह एक बूलियन मूल्य का प्रतिनिधित्व करता है जो या तो सच है या गलत है।
String- यह वर्णों का एक क्रमबद्ध संग्रह है। उदाहरण के लिए, "हैलो, वर्ल्ड!"
Character- यह एकल-वर्ण स्ट्रिंग शाब्दिक है। उदाहरण के लिए, "सी"
Optional - यह एक वैरिएबल का प्रतिनिधित्व करता है, जो या तो वैल्यू या नो वैल्यू पकड़ सकता है।
Tuples - इसका उपयोग एकल कंपाउंड मान में कई मानों को समूहित करने के लिए किया जाता है।

हमने यहां कुछ महत्वपूर्ण बिंदुओं को सूचीबद्ध किया है जो पूर्णांक प्रकार से संबंधित हैं -

32-बिट प्लेटफ़ॉर्म पर, Int Int के समान आकार है।
64-बिट प्लेटफॉर्म पर, Int Int64 के समान आकार है।
32-बिट प्लेटफ़ॉर्म पर, UInt UInt32 के समान आकार है।
64-बिट प्लेटफॉर्म पर, UInt UInt64 के समान आकार है।
Int8, Int16, Int32, Int64 का उपयोग 8 बिट, 16 बिट, 32 बिट और हस्ताक्षरित पूर्णांक के 64 बिट रूपों का प्रतिनिधित्व करने के लिए किया जा सकता है।
UInt8, UInt16, UInt32, और UInt64 का उपयोग 8 बिट, 16 बिट, 32 बिट और 64 बिट्स के अहस्ताक्षरित पूर्णांक का प्रतिनिधित्व करने के लिए किया जा सकता है।

बद्ध मान

निम्न तालिका चर प्रकार को दर्शाती है कि स्मृति में मूल्य को संग्रहीत करने के लिए कितना मेमोरी लगता है, और अधिकतम और न्यूनतम मूल्य क्या है जो इस प्रकार के चर में संग्रहीत किया जा सकता है।

प्रकार	ठेठ बिट चौड़ाई	विशिष्ट श्रेणी
Int8	1byte	-127 से 127
UInt8	1byte	0 से 255 रु
int32	4 निवाले	-2147483648 से 2147483647
UInt32	4 निवाले	0 से 4294967295 पर
Int64	8bytes	-9223372036854775808 से 9223372036854775807
UInt64	8bytes	0 से 18446744073709551615
फ्लोट	4 निवाले	1.2E-38 से 3.4E + 38 (~ 6 अंक)
दोहरा	8bytes	2.3E-308 से 1.7E + 308 (~ 15 अंक)

उपनाम लिखें

आप मौजूदा प्रकार का उपयोग करके एक नया नाम बना सकते हैं typealias। यहाँ टाइप करने के लिए नए प्रकार को परिभाषित करने के लिए सरल वाक्यविन्यास दिया गया है -

typealias newname = type

उदाहरण के लिए, निम्न पंक्ति संकलक को निर्देश देती है कि Feet का दूसरा नाम है Int -

typealias Feet = Int

अब, निम्नलिखित घोषणा पूरी तरह से कानूनी है और एक पूर्णांक चर बनाता है जिसे दूरी कहा जाता है -

typealias Feet = Int
var distance: Feet = 100
print(distance)

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

प्रकार की सुरक्षा

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

चूंकि स्विफ्ट 4 टाइप-सुरक्षित है, यह आपके कोड को संकलित करते समय टाइप-चेक करता है और किसी भी बेमेल प्रकार को त्रुटियों के रूप में चिह्नित करता है।

var varA = 42
varA = "This is hello"
print(varA)

जब हम उपरोक्त कार्यक्रम संकलित करते हैं, तो यह निम्नलिखित संकलन समय त्रुटि पैदा करता है।

main.swift:2:8: error: cannot assign value of type 'String' to type 'Int'
varA = "This is hello"

प्रकार का आविष्कार

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

// varA is inferred to be of type Int
var varA = 42
print(varA)

// varB is inferred to be of type Double
var varB = 3.14159
print(varB)

// varC is also inferred to be of type Double
var varC = 3 + 0.14159
print(varC)

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

42
3.14159
3.14159

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

स्विफ्ट 4 निम्नलिखित मूल प्रकार के चर का समर्थन करता है -

Int or UInt- यह पूरे नंबर के लिए उपयोग किया जाता है। अधिक विशेष रूप से, आप 32 या 64 बिट हस्ताक्षरित पूर्णांक को परिभाषित करने के लिए Int32, Int64 का उपयोग कर सकते हैं, जबकि UInt32 या UInt64 32 या 64 बिट अहस्ताक्षरित पूर्णांक चर को परिभाषित करने के लिए। उदाहरण के लिए, 42 और -23।
Float- इसका उपयोग 32-बिट फ्लोटिंग-पॉइंट संख्या का प्रतिनिधित्व करने के लिए किया जाता है। इसका उपयोग छोटे दशमलव अंकों के साथ संख्याओं को रखने के लिए किया जाता है। उदाहरण के लिए, 3.14159, 0.1, और -273.158।
Double- इसका उपयोग 64-बिट फ्लोटिंग-पॉइंट संख्या का प्रतिनिधित्व करने के लिए किया जाता है और इसका उपयोग तब किया जाता है जब फ़्लोटिंग-पॉइंट मान बहुत बड़ा होना चाहिए। उदाहरण के लिए 3.14159, 0.1, और -273.158।
Bool - यह एक बूलियन मूल्य का प्रतिनिधित्व करता है जो या तो सच है या गलत है।
String- यह वर्णों का एक क्रमबद्ध संग्रह है। उदाहरण के लिए, "हैलो, वर्ल्ड!"
Character- यह एकल-वर्ण स्ट्रिंग शाब्दिक है। उदाहरण के लिए, "सी"

स्विफ्ट 4 विभिन्न अन्य प्रकार के चर को भी परिभाषित करने की अनुमति देता है, जिसे हम बाद के अध्यायों में कवर करेंगे, जैसे कि Optional, Array, Dictionaries, Structures, तथा Classes।

निम्नलिखित अनुभाग स्विफ्ट 4 प्रोग्रामिंग में विभिन्न प्रकार के चर को घोषित करने और उपयोग करने के तरीके को कवर करेगा।

परिवर्तनीय घोषणा

एक चर घोषणा संकलक को बताती है कि चर के लिए भंडारण कहां और कितना बनाना है। इससे पहले कि आप चर का उपयोग करें, आपको उन्हें उपयोग करने की घोषणा करनी चाहिएvar कीवर्ड इस प्रकार है -

var variableName = <initial value>

निम्नलिखित उदाहरण से पता चलता है कि स्विफ्ट 4 में एक चर को कैसे घोषित किया जाए -

var varA = 42
print(varA)

एनोटेशन टाइप करें

आप एक प्रदान कर सकते हैं type annotationजब आप एक चर घोषित करते हैं, तो चर को किस प्रकार के मूल्यों के बारे में स्पष्ट किया जा सकता है। यहाँ वाक्य रचना है -

var variableName:<data type> = <optional initial value>

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

var varA = 42
print(varA)

var varB:Float

varB = 3.14159
print(varB)

42
3.1415901184082

नामकरण चर

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

आप अपने चरों को नाम देने के लिए सरल या यूनिकोड वर्णों का उपयोग कर सकते हैं। निम्नलिखित उदाहरणों से पता चलता है कि आप चर का नाम कैसे दे सकते हैं -

var _var = "Hello, Swift 4!"
print(_var)

var 你好 = "你好世界"
print(你好)

Hello, Swift 4!
你好世界

मुद्रण योग्य चर

आप प्रिंट फ़ंक्शन के साथ एक स्थिर या चर के वर्तमान मूल्य को प्रिंट कर सकते हैं। आप कोष्ठक में नाम को लपेटकर एक वैरिएबल मान को प्रक्षेपित कर सकते हैं और प्रारंभिक कोष्ठक से पहले बैकस्लैश से बच सकते हैं: निम्नलिखित मान्य उदाहरण हैं -

var varA = "Godzilla"
var varB = 1000.00

print("Value of \(varA) is more than \(varB) millions")

Value of Godzilla is more than 1000.0 millions

स्विफ्ट 4 भी पेश करता है Optionalsप्रकार, जो एक मूल्य की अनुपस्थिति को संभालता है। वैकल्पिक का कहना है कि या तो "एक मूल्य है, और यह x के बराबर है" या "वहाँ एक मूल्य नहीं है"।

एक वैकल्पिक अपने आप में एक प्रकार है, वास्तव में स्विफ्ट 4 के नए सुपर-संचालित एनम में से एक है। इसके दो संभावित मूल्य हैं,None तथा Some(T), कहाँ पे T स्विफ्ट 4 में उपलब्ध सही डेटा प्रकार का एक संबद्ध मूल्य है।

यहाँ एक वैकल्पिक पूर्णांक घोषणा है -

var perhapsInt: Int?

यहाँ एक वैकल्पिक स्ट्रिंग घोषणा है -

var perhapsStr: String?

उपरोक्त घोषणा स्पष्ट रूप से इसे प्रारंभ करने के बराबर है nil जिसका कोई मतलब नहीं है -

var perhapsStr: String? = nil

आइए निम्न उदाहरण लें कि स्विफ्ट 4 में वैकल्पिक कैसे काम करते हैं -

var myString:String? = nil

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

myString has nil value

वैकल्पिक उपयोग करने के समान हैं nil with pointers in Objective-C, but they work for any type, not just classes.

Forced Unwrapping

If you defined a variable as optional, then to get the value from this variable, you will have to unwrap it. This just means putting an exclamation mark at the end of the variable.

Let's take a simple example −

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result −

Optional("Hello, Swift 4!")

Now let's apply unwrapping to get the correct value of the variable −

var myString:String?

myString = "Hello, Swift 4!"

if myString != nil {
   print( myString! )
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result.

Hello, Swift 4!

Automatic Unwrapping

You can declare optional variables using exclamation mark instead of a question mark. Such optional variables will unwrap automatically and you do not need to use any further exclamation mark at the end of the variable to get the assigned value. Let's take a simple example −

var myString:String!
myString = "Hello, Swift 4!"

if myString != nil {
   print(myString)
} else {
   print("myString has nil value")
}

When we run the above program using playground, we get the following result −

Hello, Swift 4!

Optional Binding

Use optional binding to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

An optional binding for the if statement is as follows −

if let constantName = someOptional {
   statements
}

Let's take a simple example to understand the usage of optional binding −

var myString:String?
myString = "Hello, Swift 4!"

if let yourString = myString {
   print("Your string has - \(yourString)")
} else {
   print("Your string does not have a value")
}

When we run the above program using playground, we get the following result −

Your string has - Hello, Swift 4!

Swift 4 also introduces Tuples type, which are used to group multiple values in a single compound Value.

The values in a tuple can be of any type, and do not need to be of same type.

For example, ("Tutorials Point", 123) is a tuple with two values, one of string Type, and other is integer type. It is a legal command.

let ImplementationError = (501, "Not implemented") is an error when something on the server is not implemented, It returns two values. Error Code, and Description.

You can create tuples from as many values as you want and from any number of different data types.

Here’s the syntax of Tuple declaration −

var TupleName = (Value1, value2,… any number of values)

Here’s a Tuple declaration −

var error501 = (501, “Not implemented”)

You can access the values of tuple using the index numbers that start from 0.

Here’s an example of accessing tuple Values −

print(“The code is\(error501.0)”)
print(“The definition of error is\(error501.1)”)

You can name the variables of a tuple while declaring , and you can call them using their names

var error501 = (errorCode: 501, description: “Not Implemented”)
print(error501.errorCode)   // prints 501.

Tuples are helpful in returning multiple values from a function. Like, a web application might return a tuple of type ("String", Int) to show whether the loading was successful or failed.

By returning different values in a tuple we can make decisions depending on different tuple types.

Note − Tuples are useful for temporary values and are not suited for complex data.

Constants refer to fixed values that a program may not alter during its execution. Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are enumeration constants as well.

Constants are treated just like regular variables except the fact that their values cannot be modified after their definition.

Constants Declaration

Before you use constants, you must declare them using let keyword as follows −

let constantName = <initial value>

Following is a simple example to show how to declare a constant in Swift 4 −

let constA = 42
print(constA)

When we run the above program using playground, we get the following result −

Type Annotations

You can provide a type annotation when you declare a constant, to be clear about the kind of values the constant can store. Following is the syntax −

var constantName:<data type> = <optional initial value>

The following example shows how to declare a constant in Swift 4 using Annotation. Here it is important to note that it is mandatory to provide an initial value while creating a constant −

let constA = 42
print(constA)

let constB:Float = 3.14159
print(constB)

When we run the above program using playground, we get the following result.

42
3.1415901184082

Naming Constants

The name of a constant can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Swift 4 is a case-sensitive programming language.

You can use simple or Unicode characters to name your variables. Following are valid examples −

let _const = "Hello, Swift 4!"
print(_const)

let 你好 = "你好世界"
print(你好)

When we run the above program using playground, we get the following result −

Hello, Swift 4!
你好世界

Printing Constants

You can print the current value of a constant or variable using print function. You can interpolate a variable value by wrapping the name in parentheses and escape it with a backslash before the opening parenthesis: Following are valid examples −

let constA = "Godzilla"
let constB = 1000.00

print("Value of \(constA) is more than \(constB) millions")

When we run the above program using playground, we get the following result −

Value of Godzilla is more than 1000.0 millions

A literal is the source code representation of a value of an integer, floating-point number, or string type. The following are examples of literals −

42                // Integer literal
3.14159           // Floating-point literal
"Hello, world!"   // String literal

Integer Literals

An integer literal can be a decimal, binary, octal, or hexadecimal constant. Binary literals begin with 0b, octal literals begin with 0o, and hexadecimal literals begin with 0x and nothing for decimal.

Here are some examples of integer literals −

let decimalInteger = 17         // 17 in decimal notation
let binaryInteger = 0b10001     // 17 in binary notation
let octalInteger = 0o21         // 17 in octal notation
let hexadecimalInteger = 0x11   // 17 in hexadecimal notation

Floating-point Literals

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or hexadecimal form.

Decimal floating-point literals consist of a sequence of decimal digits followed by either a decimal fraction, a decimal exponent, or both.

Hexadecimal floating-point literals consist of a 0x prefix, followed by an optional hexadecimal fraction, followed by a hexadecimal exponent.

Here are some examples of floating-point literals −

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

String Literals

A string literal is a sequence of characters surrounded by double quotes, with the following form −

"characters"

String literals cannot contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed. Special characters can be included in string literals using the following escape sequences −

Escape sequence	Meaning
\0	Null Character
\\	\character
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\'	Single Quote
\"	Double Quote
\000	Octal number of one to three digits
\xhh...	Hexadecimal number of one or more digits

The following example shows how to use a few string literals −

let stringL = "Hello\tWorld\n\nHello\'Swift 4\'"
print(stringL)

When we run the above program using playground, we get the following result −

Hello World

Hello'Swift 4'

Boolean Literals

There are three Boolean literals and they are part of standard Swift 4 keywords −

A value of true representing true.
A value of false representing false.
A value of nil representing no value.

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Objective-C is rich in built-in operators and provides the following types of operators −

Arithmetic Operators
Comparison Operators
Logical Operators
Bitwise Operators
Assignment Operators
Range Operators
Misc Operators

This tutorial will explain the arithmetic, relational, logical, bitwise, assignment and other operators one by one.

Arithmetic Operators

The following table shows all the arithmetic operators supported by Swift 4 language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
+	Adds two operands	A + B will give 30
−	Subtracts second operand from the first	A − B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by denominator	B / A will give 2
%	Modulus Operator and remainder of after an integer/float division	B % A will give 0

Comparison Operators

The following table shows all the relational operators supported by Swift 4 language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
==	Checks if the values of two operands are equal or not; if yes, then the condition becomes true.	(A == B) is not true.
!=	Checks if the values of two operands are equal or not; if values are not equal, then the condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand; if yes, then the condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand; if yes, then the condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand; if yes, then the condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand; if yes, then the condition becomes true.	(A <= B) is true.

Logical Operators

The following table shows all the logical operators supported by Swift 4 language. Assume variable A holds 1 and variable B holds 0, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then the condition becomes true.	(A && B) is false.
\|\|	Called Logical OR Operator. If any of the two operands is non-zero, then the condition becomes true.	(A \|\| B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then the Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

Bitwise operators work on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p&q	p\|q	p^q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume A = 60; and B = 13;

In binary format, they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

Bitwise operators supported by Swift 4 language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then 7−

Operator	Description	Example
&	Binary AND Operator copies a bit to the result, if it exists in both operands.	(A & B) will give 12, which is 0000 1100
\|	Binary OR Operator copies a bit, if it exists in either operand.	(A \| B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit, if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~A ) will give -61, which is 1100 0011 in 2's complement form.
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	(A << 2 will give 240, which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15, which is 0000 1111

Assignment Operators

SSwift 4 supports the following assignment operators −

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assigns the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assigns the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assigns the result to left operand	C = A is equivalent to C = C A
/=	Divide AND assignment operator, It divides left operand with the right operand and assigns the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assigns the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
\|=	bitwise inclusive OR and assignment operator	C \|= 2 is same as C = C \| 2

Range Operators

Swift 4 includes two range operators, which are shortcuts for expressing a range of values. The following table explains these two operators.

Operator	Description	Example
Closed Range	(a...b) defines a range that runs from a to b, and includes the values a and b.	1...5 gives 1, 2, 3, 4 and 5
Half-Open Range	(a..< b) defines a range that runs from a to b, but does not include b.	1..< 5 gives 1, 2, 3, and 4
One- sided Range	a… , defines a range that runs from a to end of elements …a , defines a range starting from start to a	1… gives 1 , 2,3… end of elements …2 gives beginning… to 1,2

Misc Operators

Swift 4 supports a few other important operators including range and ? : which are explained in the following table.

Operator	Description	Example
Unary Minus	The sign of a numeric value can be toggled using a prefixed -	-3 or -4
Unary Plus	Returns the value it operates on, without any change.	+6 gives 6
Ternary Conditional	Condition ? X : Y	If Condition is true ? Then value X : Otherwise value Y

Operators Precedence

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Operator	Description	Example
Primary Expression Operators	() [] . expr++ expr--	left-to-right
Unary Operators	* & + - ! ~ ++expr --expr * / % + - >> << < > <= >= == !=	right-to-left
Binary Operators	& ^ \| && \|\|	left-to-right
Ternary Operator	?:	right-to-left
Assignment Operators	= += -= *= /= %= >>= <<= &=^= \|=	right-to-left
Comma	,	left-to-right

Decision making structures require that the programmer specifies one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general from of a typical decision making structure found in most of the programming languages −

Swift 4 provides the following types of decision making statements. Click the following links to check their detail.

Sr.No	Statement & Description
1	if statement An if statement consists of a Boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the Boolean expression is false.
3	if...else if...else Statement An if statement can be followed by an optional else if...else statement, which is very useful to test various conditions using single if...else if statement.
4	nested if statements You can use one if or else if statement inside another if or else if statement(s).
5	switch statement A switch statement allows a variable to be tested for equality against a list of values.

The ? : Operator

We have covered conditional operator ? : in the previous chapter which can be used to replace if...else statements. It has the following general form −

Exp1 ? Exp2 : Exp3;

Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.

The value of a ? expression is determined like this: Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.

There may be a situation when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. Following is the general from of a loop statement in most of the programming languages −

Swift 4 programming language provides the following kinds of loop to handle looping requirements. Click the following links to check their detail.

Sr.No	Loop Type & Description
1	for-in This loop performs a set of statements for each item in a range, sequence, collection, or progression.
2	while loop Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
3	repeat...while loop Like a while statement, except that it tests the condition at the end of the loop body.

Loop Control Statements

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Swift 4 supports the following control statements. Click the following links to check their detail.

Sr.No	Control Statement & Description
1	continue statement This statement tells a loop to stop what it is doing and start again at the beginning of the next iteration through the loop.
2	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
3	fallthrough statement The fallthrough statement simulates the behavior of Swift 4 switch to C-style switch.

Strings in Swift 4 are an ordered collection of characters, such as "Hello, World!" and they are represented by the Swift 4 data type String, which in turn represents a collection of values of Character type.

Create a String

You can create a String either by using a string literal or creating an instance of a String class as follows −

// String creation using String literal
var stringA = "Hello, Swift 4!"
print( stringA )

// String creation using String instance
var stringB = String("Hello, Swift 4!")
print( stringB )

//Multiple line string

let stringC = """
Hey this is a
example of multiple Line
string by tutorialsPoint 

"""
print(stringC)

When the above code is compiled and executed, it produces the following result

Hello, Swift 4!
Hello, Swift 4!
Hey this is a
example of multiple Line
string by tutorialsPoint

Empty String

You can create an empty String either by using an empty string literal or creating an instance of String class as shown below. You can also check whether a string is empty or not using the Boolean property isEmpty.

// Empty string creation using String literal
var stringA = ""

if stringA.isEmpty {
   print( "stringA is empty" )
} else {
   print( "stringA is not empty" )
}

// Empty string creation using String instance
let stringB = String()

if stringB.isEmpty {
   print( "stringB is empty" )
} else {
   print( "stringB is not empty" )
}

When the above code is compiled and executed, it produces the following result −

stringA is empty
stringB is empty

String Constants

You can specify whether your String can be modified (or mutated) by assigning it to a variable, or it will be constant by assigning it to a constant using let keyword as shown below −

// stringA can be modified
var stringA = "Hello, Swift 4!"
stringA + = "--Readers--"
print( stringA )

// stringB can not be modified
let stringB = String("Hello, Swift 4!")
stringB + = "--Readers--"
print( stringB )

जब उपरोक्त कोड संकलित और निष्पादित किया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

Playground execution failed: error: <EXPR>:10:1: error: 'String' is not
convertible to '@lvalue UInt8'
stringB + = "--Readers--"

स्ट्रिंग इंटरपोल

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

प्रत्येक आइटम (चर या स्थिर) जो आप स्ट्रिंग शाब्दिक में सम्मिलित करते हैं, कोष्ठक की एक जोड़ी में लिपटे होते हैं, जो बैकस्लैश द्वारा उपसर्ग किया जाता है। यहाँ एक सरल उदाहरण है -

var varA = 20
let constA = 100
var varC:Float = 20.0

var stringA = "\(varA) times \(constA) is equal to \(varC * 100)"
print( stringA )

20 times 100 is equal to 2000.0

स्ट्रिंग कॉनटेनटेशन

आप दो स्ट्रिंग्स या एक स्ट्रिंग और एक चरित्र, या दो वर्णों को संक्षिप्त करने के लिए + ऑपरेटर का उपयोग कर सकते हैं। यहाँ एक सरल उदाहरण है -

let constA = "Hello,"
let constB = "World!"

var stringA = constA + constB
print( stringA )

Hello,World!

स्ट्रिंग लंबाई

स्विफ्ट 4 तार एक नहीं है lengthसंपत्ति, लेकिन आप स्ट्रिंग में वर्णों की संख्या की गणना करने के लिए वैश्विक गणना () फ़ंक्शन का उपयोग कर सकते हैं। यहाँ एक सरल उदाहरण है -

var varA = "Hello, Swift 4!"

print( "\(varA), length is \((varA.count))" )

Hello, Swift 4!, length is 15

स्ट्रिंग तुलना

आप दो स्ट्रिंग चर या स्थिरांक की तुलना करने के लिए == ऑपरेटर का उपयोग कर सकते हैं। यहाँ एक सरल उदाहरण है -

var varA = "Hello, Swift 4!"
var varB = "Hello, World!"

if varA == varB {
   print( "\(varA) and \(varB) are equal" )
} else {
   print( "\(varA) and \(varB) are not equal" )
}

Hello, Swift 4! and Hello, World! are not equal

स्ट्रिंग Iterating

स्ट्रिंग्स फिर से स्विफ्ट 4 में मूल्यों का एक संग्रह है, इसलिए हम छोरों का उपयोग करके स्ट्रिंग पर पुनरावृति कर सकते हैं। -

for chars in "ThisString" {
   print(chars, terminator: " ")
}

T h i s S t r i n g

यूनिकोड स्ट्रिंग्स

आप एक UTF-8 और UTF-16 को अपने utf8 और utf16 संपत्तियों पर पुनरावृत्ति करके स्ट्रिंग का प्रतिनिधित्व कर सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है -

var unicodeString = "Dog???"

print("UTF-8 Codes: ")
for code in unicodeString.utf8 {
   print("\(code) ")
}

print("\n")

print("UTF-16 Codes: ")
for code in unicodeString.utf16 {
   print("\(code) ")
}

UTF-8 Codes: 
68 
111 
103 
63 
63 
63 


UTF-16 Codes: 
68 
111 
103 
63 
63 
63

स्ट्रिंग फ़ंक्शंस और ऑपरेटर्स

स्विफ्ट 4 स्ट्रिंग्स से संबंधित तरीकों और ऑपरेटरों की एक विस्तृत श्रृंखला का समर्थन करता है -

अनु क्रमांक	कार्य / संचालक और प्रयोजन
1	isEmpty एक बूलियन मान जो यह निर्धारित करता है कि एक स्ट्रिंग खाली है या नहीं।
2	hasPrefix(prefix: String) यह जाँचने के लिए कि क्या किसी दिए गए पैरामीटर स्ट्रिंग के उपसर्ग के रूप में मौजूद है या नहीं।
3	hasSuffix(suffix: String) यह जाँचने के लिए कि क्या दिए गए पैरामीटर स्ट्रिंग स्ट्रिंग के प्रत्यय के रूप में मौजूद हैं या नहीं।
4	toInt() संख्यात्मक स्ट्रिंग मूल्य को पूर्णांक में बदलने का कार्य।
5	count() एक स्ट्रिंग में वर्णों की संख्या को गिनने का वैश्विक कार्य।
6	utf8 एक स्ट्रिंग के UTF-8 प्रतिनिधित्व को वापस करने के लिए संपत्ति।
7	utf16 एक स्ट्रिंग के UTF-16 प्रतिनिधित्व को वापस करने के लिए संपत्ति।
8	unicodeScalars एक स्ट्रिंग के यूनिकोड स्केलर प्रतिनिधित्व को वापस करने के लिए संपत्ति।
9	+ दो तारों, या एक स्ट्रिंग और एक चरित्र, या दो वर्णों को संक्षिप्त करने के लिए ऑपरेटर।
10	+= किसी स्ट्रिंग या वर्ण को मौजूदा स्ट्रिंग में जोड़ने के लिए ऑपरेटर।
1 1	== दो तारों की समानता निर्धारित करने के लिए ऑपरेटर।
12	< यह निर्धारित करने के लिए कि एक स्ट्रिंग दूसरे से कम का मूल्यांकन करती है, एक लक्सोग्राफिक तुलना करने के लिए ऑपरेटर।
13	startIndex स्ट्रिंग का सूचकांक शुरू करने पर मूल्य प्राप्त करने के लिए।
14	endIndex स्ट्रिंग के इंडेक्स को समाप्त करने के लिए मूल्य प्राप्त करना।
15	Indices एक-एक करके इंडोल को एक्सेस करने के लिए। यानी स्ट्रिंग के सभी किरदार एक-एक करके।
16	insert("Value", at: position) एक स्थिति में एक मूल्य डालने के लिए।
17	remove(at: position) removeSubrange(range) किसी स्थिति पर मान निकालने के लिए, या स्ट्रिंग से मानों की एक श्रृंखला को निकालने के लिए।
18	reversed() एक स्ट्रिंग के रिवर्स रिटर्न

ए character स्विफ्ट में एक एकल चरित्र स्ट्रिंग शाब्दिक है, जिसे डेटा प्रकार द्वारा संबोधित किया गया है Character। निम्नलिखित उदाहरण पर एक नज़र डालें। यह दो चरित्र स्थिरांक का उपयोग करता है -

let char1: Character = "A"
let char2: Character = "B"

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

Value of char1 A
Value of char2 B

यदि आप किसी वर्ण प्रकार चर या स्थिर में एक से अधिक वर्णों को संग्रहीत करने का प्रयास करते हैं, तो स्विफ्ट 4 वह अनुमति नहीं देगा। स्विफ्ट 4 प्लेग्राउंड में निम्न उदाहरण टाइप करने का प्रयास करें और संकलन से पहले ही आपको एक त्रुटि मिल जाएगी।

// Following is wrong in Swift 4
let char: Character = "AB"

print("Value of char \(char)")

खाली चरित्र चर

रिक्त वर्ण चर या स्थिरांक बनाना संभव नहीं है, जिसका खाली मान होगा। निम्नलिखित सिंटैक्स संभव नहीं है -

// Following is wrong in Swift 4
let char1: Character = ""
var char2: Character = ""

print("Value of char1 \(char1)")
print("Value of char2 \(char2)")

तार से वर्णों तक पहुँचना

जैसा कि स्विफ्ट 4 के स्ट्रिंग्स पर चर्चा करते समय समझाया गया है, स्ट्रिंग एक निर्दिष्ट क्रम में चरित्र मूल्यों के संग्रह का प्रतिनिधित्व करता है। इसलिए हम दिए गए स्ट्रिंग से उस स्ट्रिंग पर पुनरावृति करके व्यक्तिगत वर्णों तक पहुँच सकते हैंfor-in पाश -

for ch in "Hello" {
   print(ch)
}

H
e
l
l
o

अक्षरों के साथ सामंजस्य स्थापित करना

निम्न उदाहरण दर्शाता है कि स्विफ्ट 4 के चरित्र को स्विफ्ट 4 के स्ट्रिंग के साथ कैसे समेटा जा सकता है।

var varA:String = "Hello "
let varB:Character = "G"

varA.append( varB )

print("Value of varC = \(varA)")

Value of varC = Hello G

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

यदि आप किसी बनाए गए सरणी को एक चर में असाइन करते हैं, तो यह हमेशा परिवर्तनशील होता है, जिसका अर्थ है कि आप इसे अपने आइटम को जोड़कर, हटाकर या बदलकर बदल सकते हैं; लेकिन यदि आप किसी सरणी को स्थिरांक पर असाइन करते हैं, तो वह सरणी अपरिवर्तनीय है, और इसका आकार और सामग्री परिवर्तित नहीं की जा सकती है।

ऐरे बनाना

आप निम्नलिखित आरंभिक सिंटैक्स का उपयोग करके एक निश्चित प्रकार का एक खाली सरणी बना सकते हैं -

var someArray = [SomeType]()

यहाँ दिए गए आकार की एक सरणी बनाने के लिए वाक्यविन्यास है * और इसे एक मूल्य के साथ आरंभ करें -

var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)

खाली सरणी बनाने के लिए आप निम्न कथन का उपयोग कर सकते हैं Int टाइप 3 तत्व और प्रारंभिक मान शून्य के रूप में -

var someInts = [Int](count: 3, repeatedValue: 0)

निम्नलिखित तीन तत्वों की एक सरणी बनाने और उस सरणी में तीन मान निर्दिष्ट करने के लिए एक और उदाहरण है -

var someInts:[Int] = [10, 20, 30]

अभिगम

आप उपयोग करके किसी सरणी से मान प्राप्त कर सकते हैं subscript सिंटैक्स, उस मान के सूचकांक को पार करना जिसे आप वर्ग नाम के तुरंत बाद सरणी के नाम से प्राप्त करना चाहते हैं -

var someVar = someArray[index]

यहां ही index0 से शुरू होता है जिसका अर्थ है कि पहला तत्व 0 के रूप में सूचकांक का उपयोग करके पहुँचा जा सकता है, दूसरे तत्व को 1 और इसी तरह सूचकांक का उपयोग करके एक्सेस किया जा सकता है। निम्न उदाहरण दिखाता है कि एरे को कैसे बनाएं, आरंभ करें और एक्सेस करें -

var someInts = [Int](count: 3, repeatedValue: 10)

var someVar = someInts[0]
print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 10
Value of second element is 10
Value of third element is 10

Arrays को संशोधित करना

आप उपयोग कर सकते हैं append()किसी सरणी के अंत में एक नया आइटम जोड़ने के लिए विधि या इसके अलावा असाइनमेंट ऑपरेटर (+ =)। निम्नलिखित उदाहरण पर एक नज़र डालें। यहाँ, शुरू में, हम एक खाली सरणी बनाते हैं और फिर उसी सरणी में नए तत्व जोड़ते हैं -

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 20
Value of second element is 30
Value of third element is 40

आप दिए गए सूचकांक में एक नया मान निर्दिष्ट करके एक एरे के मौजूदा तत्व को संशोधित कर सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है -

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

// Modify last element
someInts[2] = 50

var someVar = someInts[0]

print( "Value of first element is \(someVar)" )
print( "Value of second element is \(someInts[1])" )
print( "Value of third element is \(someInts[2])" )

Value of first element is 20
Value of second element is 30
Value of third element is 50

ओवररेटिंग ए अर्रे

आप उपयोग कर सकते हैं for-in निम्न सरणी में दिखाए गए मानों के पूरे सेट को एक सरणी में पुन: व्यवस्थित करने के लिए लूप -

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]
for item in someStrs {
   print(item)
}

Apple
Amazon
Google

आप उपयोग कर सकते हैं enumerate() फ़ंक्शन जो निम्न उदाहरण में किसी वस्तु के सूचकांक को उसके मूल्य के साथ देता है जैसा कि नीचे दिखाया गया है -

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs += ["Google"]

for (index, item) in someStrs.enumerated() {
   print("Value at index = \(index) is \(item)")
}

Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google

दो एरर जोड़ना

आप एक ही प्रकार के दो सरणियों को जोड़ने के लिए अतिरिक्त ऑपरेटर (+) का उपयोग कर सकते हैं, जो दो सरणियों से मानों के संयोजन के साथ एक नया सरणी उत्पन्न करेगा -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB
for item in intsC {
   print(item)
}

गिनती संपत्ति

आप केवल पढ़ने के लिए उपयोग कर सकते हैं count नीचे दिखाए गए सरणी में वस्तुओं की संख्या जानने के लिए एक सरणी की संपत्ति -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB

print("Total items in intsA = \(intsA.count)")
print("Total items in intsB = \(intsB.count)")
print("Total items in intsC = \(intsC.count)")

Total items in intsA = 2
Total items in intsB = 3
Total items in intsC = 5

खाली संपत्ति

आप केवल पढ़ने के लिए उपयोग कर सकते हैं empty एक सरणी की संपत्ति यह पता लगाने के लिए कि कोई सरणी खाली है या नहीं जैसा कि नीचे दिखाया गया है -

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()

print("intsA.isEmpty = \(intsA.isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")

intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true

स्विफ्ट 4 sets एक ही प्रकार के विभिन्न मूल्यों को संग्रहीत करने के लिए उपयोग किया जाता है, लेकिन उनके पास निश्चित क्रम नहीं है जैसा कि सरणियों में है।

यदि आप तत्वों के क्रम कोई समस्या नहीं है, या यदि आप सुनिश्चित करना चाहते हैं कि डुप्लिकेट मान नहीं हैं, तो आप सरणियों के बजाय सेट का उपयोग कर सकते हैं। (सेट केवल विशिष्ट मानों की अनुमति देते हैं।)

एक प्रकार को एक सेट में धोया जाना चाहिए। हैश मान एक इंट वैल्यू है जो समान वस्तुओं के लिए समान है। उदाहरण के लिए, यदि x == y है, तोx.hashvalue == y.hashvalue।

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

सेट बनाना

आप निम्नलिखित आरंभिक सिंटैक्स का उपयोग करके एक निश्चित प्रकार का एक खाली सेट बना सकते हैं -

var someSet = Set<Character>()     //Character can be replaced by data type of set.

सेट पर पहुँचना और संशोधित करना

आप इसके तरीकों और गुणों का उपयोग करके सेट को एक्सेस या संशोधित कर सकते हैं -

"गणना" विधि का उपयोग सेट में तत्वों की संख्या दिखाने के लिए किया जा सकता है।

someSet.count        // prints the number of elements

"इन्सर्ट" विधि का उपयोग सेट में मान डालने के लिए किया जा सकता है।

someSet.insert("c")   // adds the element to Set.

इसी तरह, isEmpty का उपयोग यह जांचने के लिए किया जा सकता है कि क्या सेट खाली है।

someSet.isEmpty       // returns true or false depending on the set Elements.

"निकालें" विधि का उपयोग सेट में मान निकालने के लिए किया जा सकता है।

someSet.remove("c")     // removes a element , removeAll() can be used to remove all elements

"समाहित" विधि का उपयोग किसी सेट में मूल्य के अस्तित्व की जांच करने के लिए किया जा सकता है।

someSet.contains("c")     // to check if set contains this value.

एक सेट पर Iterating

आप लूप के लिए उपयोग कर एक सेट पर पुनरावृति कर सकते हैं -

for items in someSet {
   print(someSet)
}

//Swift sets are not in an ordered way, to iterate over a set in ordered way use

for items in someSet.sorted() {
   print(someSet)
}

सेट ऑपरेशन करना

आप स्विफ्ट सेट पर बेसिक सेट ऑपरेशन कर सकते हैं।

सेट ऑपरेशन करने के लिए निम्नलिखित तरीके हैं -

Intersection
Union
subtracting

let evens: Set = [10,12,14,16,18]
let odds: Set = [5,7,9,11,13]
let primes = [2,3,5,7]
odds.union(evens).sorted()
// [5,7,9,10,11,12,13,14,16,18]
odds.intersection(evens).sorted()
//[]
odds.subtracting(primes).sorted()
//[9, 11, 13]

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

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

एक शब्दकोश कुंजी या तो एक पूर्णांक या एक स्ट्रिंग हो सकती है बिना प्रतिबंध के, लेकिन यह एक शब्दकोश के भीतर अद्वितीय होना चाहिए।

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

शब्दकोश का निर्माण

आप निम्नलिखित आरंभिक सिंटैक्स का उपयोग करके एक निश्चित प्रकार का एक खाली शब्दकोश बना सकते हैं -

var someDict = [KeyType: ValueType]()

आप एक खाली शब्दकोश बनाने के लिए निम्नलिखित सरल वाक्यविन्यास का उपयोग कर सकते हैं, जिसकी कुंजी Int प्रकार की होगी और संबंधित मान स्ट्रिंग होंगे -

var someDict = [Int: String]()

यहाँ दिए गए मूल्यों के एक सेट से एक शब्दकोश बनाने के लिए एक उदाहरण है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

अनुक्रम आधारित प्रारंभ

स्विफ्ट 4 आपको सरणियों से शब्दकोश बनाने की अनुमति देता है (कुंजी-मूल्य जोड़े।)

var cities = [“Delhi”,”Bangalore”,”Hyderabad”]

var Distance = [2000,10, 620]

यहाँ दिए गए मूल्यों के एक सेट से एक शब्दकोश बनाने के लिए एक उदाहरण है -

let cityDistanceDict = Dictionary(uniqueKeysWithValues: zip(cities, Distance))

कोड की उपरोक्त पंक्तियाँ कुंजी के रूप में शहरों के साथ एक शब्दकोश बनाएगी और मान के रूप में दूरी -

छनन

स्विफ्ट 4 आपको एक शब्दकोश से मूल्यों को फ़िल्टर करने की अनुमति देता है।

var closeCities = cityDistanceDict.filter { $0.value < 1000 }

यदि हम उपरोक्त कोड चलाते हैं तो हमारी क्लोजिटीज़ डिक्शनरी होगी।

["Bangalore" : 10 , "Hyderabad" : 620]

शब्दकोश समूहन

स्विफ्ट 4 आपको शब्दकोश मूल्यों का समूह बनाने की अनुमति देता है।

var cities = ["Delhi","Bangalore","Hyderabad","Dehradun","Bihar"]

आप पहले वर्णमाला के अनुसार शब्दकोश के मूल्यों को समूहित करने के लिए निम्नलिखित सरल वाक्यविन्यास का उपयोग कर सकते हैं।

var GroupedCities = Dictionary(grouping: cities ) { $0.first! }

उपरोक्त कोड का परिणाम होगा

["D" :["Delhi","Dehradun"], "B" : ["Bengaluru","Bihar"], "H" : ["Hyderabad"]]

शब्दकोश तक पहुँचने

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

var someVar = someDict[key]

आइए एक शब्दकोश से मान बनाने, आरंभ करने और उन तक पहुंचने के लिए निम्नलिखित उदाहरण देखें -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someVar = someDict[1]

print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

शब्दकोश को संशोधित करना

आप उपयोग कर सकते हैं updateValue(forKey:)शब्दकोश की दी गई कुंजी के लिए एक मौजूदा मूल्य जोड़ने के लिए विधि। यह विधि शब्दकोश के मूल्य प्रकार का एक वैकल्पिक मूल्य लौटाती है। यहाँ एक सरल उदाहरण है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict.updateValue("New value of one", forKey: 1)
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

आप एक दिए गए कुंजी पर नए मान निर्दिष्ट करके शब्दकोश के मौजूदा तत्व को संशोधित कर सकते हैं जैसा कि निम्नलिखित उदाहरण में दिखाया गया है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var oldVal = someDict[1]
someDict[1] = "New value of one"
var someVar = someDict[1]

print( "Old value of key = 1 is \(oldVal)" )
print( "Value of key = 1 is \(someVar)" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

कुंजी-मूल्य जोड़े निकालें

आप उपयोग कर सकते हैं removeValueForKey()शब्दकोश से कुंजी-मूल्य जोड़ी निकालने की विधि। यह विधि की-वैल्यू पेयर को हटाती है यदि यह मौजूद है और हटाए गए मान को लौटाता है, या यदि कोई मान मौजूद नहीं है तो रिटर्न देता है। यहाँ एक सरल उदाहरण है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var removedValue = someDict.removeValue(forKey: 2)

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

आप एक मान से असाइन करके एक कुंजी-मूल्य जोड़ी को हटाने के लिए सबस्क्रिप्ट सिंटैक्स का उपयोग कर सकते हैं nilउस कुंजी के लिए। यहाँ एक सरल उदाहरण है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

someDict[2] = nil

print( "Value of key = 1 is \(someDict[1])" )
print( "Value of key = 2 is \(someDict[2])" )
print( "Value of key = 3 is \(someDict[3])" )

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

एक शब्दकोश में Iterating

आप एक का उपयोग कर सकते हैं for-in एक शब्दकोश में दिखाए गए अनुसार एक शब्दकोश में कुंजी-मूल्य जोड़े के पूरे सेट पर पुनरावृति करने के लिए लूप -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

for (index, keyValue) in someDict.enumerated() {
   print("Dictionary key \(index) - Dictionary value \(keyValue)")
}

Dictionary key 2 - Dictionary value Two
Dictionary key 3 - Dictionary value Three
Dictionary key 1 - Dictionary value One

आप उपयोग कर सकते हैं enumerate() फंक्शन जो आइटम के इंडेक्स को उसकी कुंजी (कुंजी, मूल्य) जोड़ी के साथ लौटाता है जैसा कि उदाहरण में नीचे दिखाया गया है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
for (key, value) in someDict.enumerated() {
   print("Dictionary key \(key) - Dictionary value \(value)")
}

Dictionary key 0 - Dictionary value (key: 2, value: "Two")
Dictionary key 1 - Dictionary value (key: 3, value: "Three")
Dictionary key 2 - Dictionary value (key: 1, value: "One")

Arrays में परिवर्तित करें

आप कुंजी और मान दोनों के लिए अलग-अलग सरणियों का निर्माण करने के लिए दिए गए शब्दकोश से कुंजी-मूल्य जोड़े की एक सूची निकाल सकते हैं। यहाँ एक उदाहरण है -

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

print("Print Dictionary Keys")

for (key) in dictKeys {
   print("\(key)")
}
print("Print Dictionary Values")

for (value) in dictValues {
   print("\(value)")
}

Print Dictionary Keys
2
3
1
Print Dictionary Values
Two
Three
One

गिनती संपत्ति

आप केवल पढ़ने के लिए उपयोग कर सकते हैं count एक शब्दकोश की संपत्ति का पता लगाने के लिए एक शब्दकोश में आइटम की संख्या के रूप में नीचे दिखाया गया है -

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]

print("Total items in someDict1 = \(someDict1.count)")
print("Total items in someDict2 = \(someDict2.count)")

Total items in someDict1 = 3
Total items in someDict2 = 2

खाली संपत्ति

आप केवल पढ़ने के लिए उपयोग कर सकते हैं empty एक शब्दकोश की संपत्ति यह पता लगाने के लिए कि कोई शब्दकोश खाली है या नहीं, जैसा कि नीचे दिखाया गया है -

var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
var someDict2:[Int:String] = [4:"Four", 5:"Five"]
var someDict3:[Int:String] = [Int:String]()

print("someDict1 = \(someDict1.isEmpty)")
print("someDict2 = \(someDict2.isEmpty)")
print("someDict3 = \(someDict3.isEmpty)")

someDict1 = false
someDict2 = false
someDict3 = true

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

Function Declaration - एक फंक्शन के नाम, रिटर्न टाइप और पैरामीटर्स के बारे में कंपाइलर को बताता है।
Function Definition - यह फ़ंक्शन का वास्तविक निकाय प्रदान करता है।

स्विफ्ट 4 फ़ंक्शन में पैरामीटर प्रकार और इसके वापसी प्रकार शामिल हैं।

कार्य की परिभाषा

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

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

फ़ंक्शन के तर्क हमेशा फ़ंक्शन के पैरामीटर सूची और रिटर्न मानों → के बाद उसी क्रम में प्रदान किए जाने चाहिए।

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

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

निम्नलिखित कोड पर एक नज़र डालें। छात्र के नाम को 'स्टूडेंट' फंक्शन के अंदर घोषित किए गए स्ट्रिंग डेटाटाइप के रूप में घोषित किया जाता है और जब फ़ंक्शन को कॉल किया जाता है, तो वह छात्र का नाम वापस कर देगा।

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

First Program
About Functions

एक समारोह बुला रहा है

मान लें कि हमने 'डिसप्ले' नामक फ़ंक्शन को 'डिसप्ले' के रूप में परिभाषित किया है, उदाहरण के लिए फंक्शन नंबर 'फंक्शन' डिस्प्ले के साथ एक फंक्शन को प्रदर्शित करने के लिए, पहले 'no1' के साथ आरम्भ किया जाता है, जो पूर्णांक डेटा प्रकार रखता है। फिर तर्क 'no1' को 'a' तर्क दिया जाता है, जो इसके बाद उसी डेटा प्रकार पूर्णांक को इंगित करेगा। अब तर्क 'a' फ़ंक्शन पर वापस आ जाता है। यहां प्रदर्शन () फ़ंक्शन पूर्णांक मान को रखेगा और पूर्णांक मानों को तब लौटाएगा जब हर बार फ़ंक्शन को लागू किया जाता है।

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

100
200

पैरामीटर और रिटर्न मान

स्विफ्ट 4 लचीले फ़ंक्शन पैरामीटर और इसके रिटर्न मान को सरल से जटिल मान प्रदान करता है। सी और ऑब्जेक्टिव सी के समान, स्विफ्ट 4 में कार्य भी कई रूप ले सकते हैं।

पैरामीटर के साथ कार्य

फ़ंक्शन के शरीर में इसके पैरामीटर मानों को पास करके एक फ़ंक्शन तक पहुंचा जाता है। हम फ़ंक्शन के अंदर ट्यूपल के रूप में एकल से कई पैरामीटर मान पास कर सकते हैं।

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

40
45
120

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

हमारे पास बिना किसी पैरामीटर के भी कार्य हो सकते हैं।

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

func funcname() -> datatype {
   return datatype
}

निम्नलिखित एक पैरामीटर के बिना एक समारोह होने का एक उदाहरण है -

func votersname() -> String {
   return "Alice"
}
print(votersname())

Alice

रिटर्न मान के साथ कार्य

स्ट्रिंग, पूर्णांक और फ्लोट डेटा प्रकार मानों को रिटर्न प्रकार के रूप में कार्य करने के लिए भी उपयोग किया जाता है। दिए गए ऐरे फंक्शन में सबसे बड़ी और सबसे छोटी संख्या का पता लगाने के लिए बड़े और छोटे पूर्णांक डेटा के साथ 'ls' घोषित किया जाता है।

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

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

Largest number is: 98 and smallest number is: -5

रिटर्न वैल्यू के बिना कार्य

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

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

वैकल्पिक रिटर्न प्रकार के साथ कार्य

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

वैकल्पिक कार्य दो रूप 'मूल्य' और एक 'शून्य' लेंगे। हम प्रमुख आरक्षित चरित्र के साथ 'वैकल्पिक' का उल्लेख करेंगे? ' यह जाँचने के लिए कि क्या टूपल एक मान या शून्य मान लौटा रहा है।

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

min is -6 and max is 109

'' वैकल्पिक 'का उपयोग' शून्य 'या कचरा मानों की जांच के लिए किया जाता है, जिससे डिबगिंग में बहुत समय लगता है और उपयोगकर्ता के लिए कोड को कुशल और पठनीय बनाया जा सकता है।

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

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

स्थानीय पैरामीटर नाम अकेले फ़ंक्शन के अंदर पहुंचते हैं।

func sample(number: Int) {
   print(number)
}

यहां ही funcनमूना तर्क संख्या को आंतरिक चर के रूप में घोषित किया जाता है क्योंकि यह फ़ंक्शन नमूना () द्वारा आंतरिक रूप से एक्सेस किया जाता है। यहां 'संख्या' को स्थानीय चर के रूप में घोषित किया गया है, लेकिन चर का संदर्भ निम्न कथन के साथ फ़ंक्शन के बाहर किया गया है -

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

1
2
3

बाहरी पैरामीटर नाम

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

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

वैराडिक पैरामीटर्स

जब हम फ़ंक्शन को कई तर्कों के साथ परिभाषित करना चाहते हैं, तो हम सदस्यों को 'वैरेडिक' मापदंडों के रूप में घोषित कर सकते हैं। पैरामीटर नाम के बाद पैरामीटर्स को वैरिएड के रूप में निर्दिष्ट किया जा सकता है।

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

लगातार, परिवर्तनीय और I / O पैरामीटर

डिफ़ॉल्ट रूप से कार्य मापदंडों को 'स्थिर' मानते हैं, जबकि उपयोगकर्ता कार्यों के तर्कों को भी चर के रूप में घोषित कर सकता है। हमने पहले ही चर्चा की है कि 'let' कीवर्ड का उपयोग निरंतर मापदंडों को घोषित करने के लिए किया जाता है और चर मापदंडों को 'var' कीवर्ड के साथ परिभाषित किया जाता है।

स्विफ्ट 4 में I / O पैरामीटर पैरामीटर मान को बनाए रखने के लिए कार्यक्षमता प्रदान करता है, भले ही इसके मान फ़ंक्शन कॉल के बाद संशोधित हो। फ़ंक्शन पैरामीटर परिभाषा की शुरुआत में, सदस्य मूल्यों को बनाए रखने के लिए 'इनऑउट' कीवर्ड घोषित किया जाता है।

यह कीवर्ड 'इनऑउट' को व्युत्पन्न करता है क्योंकि इसके मान 'फंक्शन' में 'पास' हो जाते हैं और इसके फंक्शन को उसके फंक्शन बॉडी द्वारा एक्सेस और संशोधित किया जाता है और मूल तर्क को संशोधित करने के लिए इसे फंक्शन के 'आउट' में लौटा दिया जाता है।

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

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

Swapped values are 10, 2

प्रकार और इसके उपयोग

प्रत्येक और प्रत्येक फ़ंक्शन इनपुट मापदंडों पर विचार करके विशिष्ट फ़ंक्शन का अनुसरण करता है और वांछित परिणाम को आउटपुट करता है।

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

निम्नलिखित एक उदाहरण है -

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

2
6

यहां फ़ंक्शन को दो तर्कों के साथ आरंभ किया गया है no1 तथा no2 पूर्णांक डेटा प्रकारों और उसके रिटर्न प्रकार को भी 'int' घोषित किया जाता है

Func inputstr(name: String) -> String {
   return name
}

यहाँ फ़ंक्शन के रूप में घोषित किया गया है string डाटा प्रकार।

कार्य भी हो सकते हैं void डेटा प्रकार और ऐसे फ़ंक्शन कुछ भी वापस नहीं करेंगे।

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

Swift 4 Functions
Types and its Usage

उपरोक्त फ़ंक्शन को बिना किसी तर्क और कोई रिटर्न मान के साथ एक शून्य फ़ंक्शन के रूप में घोषित किया गया है।

फ़ंक्शन प्रकारों का उपयोग करना

फ़ंक्शंस को पहले पूर्णांक, फ़्लोट या स्ट्रिंग प्रकार के तर्कों के साथ पारित किया जाता है और फिर इसे नीचे दिए गए फ़ंक्शन के लिए स्थिरांक या चर के रूप में पारित किया जाता है।

var addition: (Int, Int) -> Int = sum

यहाँ योग एक फ़ंक्शन नाम है, जिसमें 'a' और 'b' पूर्णांक चर होते हैं, जिसे अब फ़ंक्शन नाम परिवर्धन के रूप में घोषित किया जाता है। इसके बाद दोनों जोड़ और योग फ़ंक्शन के दोनों ही पूर्णांक डेटाटाइप के रूप में घोषित तर्कों की संख्या होती है और पूर्णांक मान को संदर्भ के रूप में भी वापस करते हैं।

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

Result: 129

पैरामीटर प्रकार और वापसी प्रकार के रूप में फ़ंक्शन

हम फ़ंक्शन को दूसरे फ़ंक्शन के पैरामीटर प्रकार के रूप में भी पास कर सकते हैं।

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

Result: 129
Result: 30

नेस्टेड कार्य

एक नेस्टेड फ़ंक्शन बाहरी फ़ंक्शन को कॉल करने की सुविधा प्रदान करता है।

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

-30

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

वैश्विक कार्य	नेस्टेड कार्य	क्लोजर एक्सप्रेशन
एक नाम है। किसी भी मूल्य पर कब्जा न करें	एक नाम है। फ़ंक्शन को संलग्न करने से मान कैप्चर करें	बेनाम: आसन्न ब्लॉक से मूल्यों पर कब्जा कब्जा

स्विफ्ट 4 भाषा में बंद अभिव्यक्ति कुरकुरा, अनुकूलन और हल्के वाक्यविन्यास शैलियों का पालन करती है जिसमें शामिल हैं।

संदर्भ से संदर्भ पैरामीटर और वापसी मान प्रकार।
एकल-अभिव्यक्ति क्लोजर से निहित रिटर्न।
आशुलिपि तर्क नाम और
ट्रेलिंग क्लोजर सिंटैक्स

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

क्लोजर को परिभाषित करने के लिए जेनेरिक सिंटैक्स निम्नलिखित है जो मापदंडों को स्वीकार करता है और एक डेटा प्रकार देता है -

{
   (parameters) −> return type in
   statements
}

निम्नलिखित एक सरल उदाहरण है -

let studname = { print("Welcome to Swift Closures") }
studname()

Welcome to Swift Closures

निम्नलिखित क्लोजर दो मापदंडों को स्वीकार करता है और एक बूल मान लौटाता है -

{     
   (Int, Int) −> Bool in
   Statement1
   Statement 2
   ---
   Statement n
}

निम्नलिखित एक सरल उदाहरण है -

let divide = {
   (val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}

let result = divide(200, 20)
print (result)

क्लोजर में अभिव्यक्तियाँ

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

आरोही क्रम कार्यक्रम

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

दो तर्कों को हल किए गए फ़ंक्शन के अंदर दर्शाया गया है -

ज्ञात प्रकार के मान सरणियों के रूप में दर्शाए जाते हैं।
सरणी सामग्री (इंट, इंट) और एक बूलियन मान (बूल) लौटाता है यदि सरणी को ठीक से सॉर्ट किया जाता है तो यह सही मान लौटाएगा अन्यथा यह गलत वापस आ जाएगा।

इनपुट स्ट्रिंग के साथ एक सामान्य फ़ंक्शन को लिखा गया है और नए सरणी में छंटे हुए तार को प्राप्त करने के लिए सॉर्ट किए गए फ़ंक्शन को पास किया गया है जो नीचे दिखाया गया है -

func ascend(s1: String, s2: String) -> Bool {
   return s1 > s2
}

let stringcmp = ascend(s1: "Swift 4", s2: "great")
print (stringcmp)

true

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

बंद अभिव्यक्ति सिंटैक्स का उपयोग करता है -

निरंतर पैरामीटर,
चर मापदंडों, और
inout पैरामीटर।

क्लोजर एक्सप्रेशन ने डिफ़ॉल्ट मानों का समर्थन नहीं किया। वैरिएडिक पैरामीटर और ट्यूपल्स को पैरामीटर प्रकार और रिटर्न प्रकार के रूप में भी इस्तेमाल किया जा सकता है।

let sum = {
   (no1: Int, no2: Int) -> Int in 
   return no1 + no2 
}

let digits = sum(10, 20)
print(digits)

फ़ंक्शन स्टेटमेंट में उल्लिखित पैरामीटर और रिटर्न प्रकार की घोषणाएं इनलाइन क्लोजर एक्सप्रेशन फ़ंक्शन के साथ 'कीवर्ड' में भी दर्शाई जा सकती हैं। एक बार 'कीवर्ड' में 'पैरामीटर और रिटर्न टाइप्स' घोषित करने के लिए क्लोजर के शरीर को दर्शाने के लिए उपयोग किया जाता है।

एकल अभिव्यक्ति निहित रिटर्न

यहां, सॉर्ट किए गए फ़ंक्शन के दूसरे तर्क का फ़ंक्शन प्रकार यह स्पष्ट करता है कि एक बूल मान को बंद करके वापस किया जाना चाहिए। क्योंकि क्लोजर के शरीर में एक एकल अभिव्यक्ति (s1> s2) होती है जो बूल मान लौटाता है, कोई अस्पष्टता नहीं है, और वापसी कीवर्ड छोड़ा जा सकता है।

अभिव्यक्ति में एकल अभिव्यक्ति विवरण वापस करने के लिए 'वापसी' कीवर्ड इसके घोषणा भाग में छोड़ा गया है।

var count:[Int] = [5, 10, -6, 75, 20]
let descending = count.sorted(by: { n1, n2 in n1 > n2 })
let ascending = count.sorted(by: { n1, n2 in n1 < n2 })

print(descending)
print(ascending)

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

यह कथन स्वयं स्पष्ट रूप से परिभाषित करता है कि जब string1 string 2 से अधिक है तो सही है अन्यथा असत्य है इसलिए रिटर्न स्टेटमेंट को यहाँ छोड़ दिया गया है।

ज्ञात प्रकार क्लोजर

दो संख्याओं को जोड़ने पर विचार करें। हम जानते हैं कि इसके अलावा पूर्णांक डेटाटाइप वापस आ जाएगा। इसलिए ज्ञात प्रकार के बंदों को घोषित किया जाता है -

let sub = {
   (no1: Int, no2: Int) -> Int in 
   return no1 - no2 
}

let digits = sub(10, 20)
print(digits)

-10

क्लोजर के रूप में शॉर्टहैंड तर्क नामों की घोषणा

स्विफ्ट 4 स्वचालित रूप से इनलाइन क्लोजर के लिए शॉर्टहैंड तर्क नाम प्रदान करता है, जिसका उपयोग $ 0 नाम से क्लोजर के तर्कों के मूल्यों को संदर्भित करने के लिए किया जा सकता है। $1, $2, और इतने पर।

var shorthand: (String, String) -> String
shorthand = { $1 }
print(shorthand("100", "200"))

यहां, $ 0 और $ 1 क्लोजर के पहले और दूसरे स्ट्रिंग तर्क का उल्लेख करते हैं।

स्विफ्ट 4 उपयोगकर्ता को $ 0 का प्रतिनिधित्व करके इनहैंड क्लोजर को शॉर्टहैंड तर्क नामों के रूप में प्रस्तुत करने की सुविधा देता है, $1, $2 --- $ n।

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

संचालक कार्य के रूप में क्लोजर

स्विफ्ट 4 बस के रूप में ऑपरेटर कार्यों को प्रदान करके सदस्यों तक पहुंचने का एक आसान तरीका प्रदान करता है। पिछले उदाहरणों में 'बूल' शब्द का प्रयोग या तो 'सही' लौटने के लिए किया जाता है जब तार बराबर होते हैं अन्यथा यह 'असत्य' देता है।

अभिव्यक्ति को क्लोजर में ऑपरेटर फ़ंक्शन द्वारा और भी सरल बनाया गया है -

let numb = [98, -20, -30, 42, 18, 35]
var sortedNumbers = numb.sorted ({
   (left: Int, right: Int) -> Bool in
   return left < right
})

let asc = numb.sorted(<)
print(asc)

[-30, -20, 18, 35, 42, 98]

ट्रेलरों के रूप में क्लोजर

फ़ंक्शन के अंतिम तर्क को एक बंद अभिव्यक्ति में पास करना 'ट्रेलिंग क्लोज़र' की मदद से घोषित किया जाता है। यह फ़ंक्शन के बाहर लिखा है () {} के साथ। इसके उपयोग की आवश्यकता तब होती है जब फ़ंक्शन को एक पंक्ति में इनलाइन लिखना संभव नहीं होता है।

reversed = sorted(names) { $0 > $1}

जहां {$ 0> $ 1} को बाहर (नाम) घोषित किए गए अनुगामी क्लोजर के रूप में दर्शाया जाता है।

import Foundation
var letters = ["North", "East", "West", "South"]

let twoletters = letters.map({ 
   (state: String) -> String in
   return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString
})

let stletters = letters.map() { 
   $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString 
}
print(stletters)

[NO, EA, WE, SO]

मान और संदर्भ प्रकार कैप्चर करना

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

अन्य फ़ंक्शन के शरीर में फ़ंक्शन के साथ नेस्टेड फ़ंक्शन का उपयोग करके निरंतर और चर मान कैप्चर करना प्राप्त किया जाता है।

एक नेस्टेड फ़ंक्शन कैप्चर करता है -

बाहरी कार्य तर्क।
बाहरी फ़ंक्शन के भीतर परिभाषित स्थिरांक और चर कैप्चर करें।

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

let decrem = calcDecrement(forDecrement: 18)
decrem()

यहाँ oneDecrement और घटते चर दोनों क्लोजर संदर्भ के रूप में एक ही मेमोरी ब्लॉक को इंगित करेंगे।

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 100
   func decrementer() -> Int {
      overallDecrement -= total
      print(overallDecrement)
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 18)
decrem()
decrem()
decrem()

82
64
46

जब हर बार बाहरी फ़ंक्शन कैल्सेड्रेमेंट कहलाता है, तो यह डिक्रिशनर () फ़ंक्शन को इनवॉइस करता है और 18 से मान को घटाता है और बाहरी फ़ंक्शन कैल्सेडरमेंट की मदद से परिणाम देता है। यहाँ कैल्केड्रेमेंट एक क्लोजर के रूप में कार्य करता है।

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

एन्यूमरेशन एक उपयोगकर्ता-परिभाषित डेटा प्रकार है जिसमें संबंधित मूल्यों के सेट होते हैं। कीवर्डenum का उपयोग एन्यूमरेटेड डेटा प्रकार को परिभाषित करने के लिए किया जाता है।

गणना कार्यशीलता

स्विफ्ट 4 में गणना सी और ऑब्जेक्टिव सी की संरचना से भी मिलती है।

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

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

Enumerations को enum कीवर्ड के साथ पेश किया जाता है और उनकी पूरी परिभाषा को ब्रेसिज़ की एक जोड़ी के भीतर रखा जाता है -

enum enumname {
   // enumeration values are described here
}

उदाहरण के लिए, आप सप्ताह के दिनों के लिए एक गणना को परिभाषित कर सकते हैं -

enum DaysofaWeek {
   case Sunday
   case Monday
   ---
   case Saturday
}

उदाहरण

enum names {
   case Swift
   case Closures
}

var lang = names.Closures
lang = .Closures

switch lang {
   case .Swift:
      print("Welcome to Swift")
   case .Closures:
      print("Welcome to Closures")
   default:
      print("Introduction")
}

Welcome to Closures

स्विफ्ट 4 एन्यूमरेशन अपने सदस्यों को सी और ऑब्जेक्टिव सी की तरह डिफॉल्ट मान नहीं देता है। इसके बजाय सदस्यों को उनके एन्यूमरेशन नामों से स्पष्ट रूप से परिभाषित किया जाता है। गणना नाम को एक बड़े अक्षर से शुरू करना चाहिए (Ex: enum DaysofaWeek)।

var weekDay = DaysofaWeek.Sunday

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

स्विच स्टेटमेंट के साथ गणना

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

enum Climate {
   case India
   case America
   case Africa
   case Australia
}

var season = Climate.America
season = .America
switch season {
   case .India:
      print("Climate is Hot")
   case .America:
      print("Climate is Cold")
   case .Africa:
      print("Climate is Moderate")
   case .Australia:
      print("Climate is Rainy")
   
}

Climate is Cold

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

गणना को संबद्ध मूल्यों और कच्चे मूल्यों में आगे वर्गीकृत किया जा सकता है।

एसोसिएटेड वैल्यूज़ और रॉ वैल्यूज़ के बीच अंतर

संबद्ध मान	कच्चा मान
विभिन्न डाटापाइप्स	वही डेटाटाइप्स
Ex: enum {10,0.8, "हैलो"}	Ex: enum {10,35,50}
मान निरंतर या परिवर्तनशील के आधार पर बनाए जाते हैं	पूर्वनिर्मित मूल्य
हर बार घोषित होने पर बदलता है	सदस्य के लिए मूल्य समान है

एसोसिएटेड वैल्यूज़ के साथ एनम

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.

उदाहरण के लिए विचार करें कि छात्रों के नाम और तीन विषयों में प्राप्त अंकों तक पहुँचने के लिए गणना नाम को छात्र के रूप में घोषित किया गया है और एनुम वर्ग में उपस्थित सदस्यों का नाम है जो स्ट्रिंग डेटाटाइप के हैं, अंक 1, मार्क 2 और डेटैट इंटेगर के मार्क 3 के रूप में दर्शाए जाते हैं। छात्र के नाम या अंकों तक पहुँचने के लिए उन्होंने स्कोर किया है

var studDetails = Student.Name("Swift")
var studMarks = Student.Mark(98,97,95)

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

कच्चे मूल्यों के साथ Enum

कच्चे मान तार, वर्ण या पूर्णांक या फ्लोटिंग-पॉइंट संख्या प्रकारों में से कोई भी हो सकते हैं। प्रत्येक कच्चे मूल्य को अपनी गणना घोषणा के भीतर अद्वितीय होना चाहिए। जब पूर्णांक कच्चे मान के लिए उपयोग किए जाते हैं, तो वे कुछ गणन सदस्यों के लिए कोई मूल्य निर्दिष्ट नहीं होने पर ऑटो-इंक्रीमेंट करते हैं।

enum Month: Int {
   case January = 1, February, March, April, May, June, July, August,
      September, October, November, December
}

let yearMonth = Month.May.rawValue
print("Value of the Month is: \(yearMonth).")

Value of the Month is: 5.

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

सी और ऑब्जेक्टिव सी के विपरीत

संरचना को कार्यान्वयन फ़ाइलों और इंटरफ़ेस की आवश्यकता नहीं है।
संरचना हमें एक एकल फ़ाइल बनाने और अपने इंटरफेस को अन्य ब्लॉकों में स्वचालित रूप से विस्तारित करने की अनुमति देती है।

संरचना में चर मानों की प्रतिलिपि बनाई जाती है और बाद के कोडों में पुराने मूल्यों की एक प्रति लौटा दी जाती है ताकि मानों को परिवर्तित न किया जा सके।

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

Structures are defined with a 'Struct' Keyword.
struct nameStruct {
   Definition 1
   Definition 2
   ---
   Definition N
}

एक संरचना की परिभाषा

उदाहरण के लिए, मान लें कि हमें छात्रों के रिकॉर्ड को तीन विषयों तक पहुँचना है और कुल तीन विषयों का पता लगाना है। यहाँ markStruct का उपयोग एक संरचना को तीन अंकों के साथ आरंभ करने के लिए किया जाता है जैसे कि datatype 'Int'।

struct MarkStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
}

संरचना और उसके गुणों तक पहुँचना

संरचना के सदस्यों को इसके संरचना नाम से पहुँचा जाता है। संरचना के उदाहरणों को 'लेट' कीवर्ड द्वारा आरंभ किया जाता है।

struct studentMarks {
   var mark1 = 100
   var mark2 = 200
   var mark3 = 300
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Mark1 is 100
Mark2 is 200
Mark3 is 300

छात्रों के अंक संरचना नाम 'StudentMarks' द्वारा एक्सेस किए जाते हैं। संरचना के सदस्यों को अंक 1, mark2, mark3 के साथ पूर्णांक प्रकार मानों के रूप में आरंभीकृत किया जाता है। तब संरचना studentMarks () 'लेट' कीवर्ड के साथ 'निशान' पर जाती है। इसके बाद 'निशान' में संरचना सदस्य मान शामिल होंगे। अब '' '' से स्ट्रक्चर मेंबर वैल्यूज़ को एक्सेस करके वैल्यूज़ प्रिंट की जाती हैं। इसके आरंभिक नामों के साथ।

struct MarksStruct {
   var mark: Int

   init(mark: Int) {
      self.mark = mark
   }
}

var aStruct = MarksStruct(mark: 98)
var bStruct = aStruct     // aStruct and bStruct are two structs with the same value!
bStruct.mark = 97

print(aStruct.mark)      // 98
print(bStruct.mark)      // 97

98
97

संरचनाओं का सर्वश्रेष्ठ उपयोग अभ्यास

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

संरचनाएं होने की आवश्यकता

सरल डेटा मानों को अलग करने के लिए।
एन्कैप्सुलेटेड डेटा और इसके संबंधित गुणों को 'संदर्भ' के बजाय 'मान' द्वारा कॉपी करना।
To कॉपी ’और 'संदर्भ’ की संरचना।

स्विफ्ट 4 में संरचनाएं अपने सदस्यों को उनके संदर्भों के बजाय उनके मूल्यों के साथ पारित करती हैं।

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int

   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var marks = markStruct(mark1: 98, mark2: 96, mark3:100)
print(marks.mark1)
print(marks.mark2)
print(marks.mark3)

98
96
100

एक और उदाहरण

struct markStruct {
   var mark1: Int
   var mark2: Int
   var mark3: Int
   
   init(mark1: Int, mark2: Int, mark3: Int) {
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

var fail = markStruct(mark1: 34, mark2: 42, mark3: 13)

print(fail.mark1)
print(fail.mark2)
print(fail.mark3)

34
42
13

संरचना 'markStruct' को पहले उसके सदस्यों mark1, mark2 और mark3 के साथ परिभाषित किया गया है। अब सदस्य वर्गों के चर को पूर्णांक मान रखने के लिए प्रारंभ किया जाता है। तब संरचना सदस्यों की प्रतिलिपि 'स्व' कीवर्ड के साथ बनाई जाती है। एक बार जब संरचना सदस्यों की प्रतिलिपि संरचना ब्लॉक बनाई जाती है, तो इसके पैरामीटर निशान को 'निशान' चर पर भेज दिया जाता है, जो अब छात्रों के अंकों को धारण करेगा। फिर अंक 98, 96, 100 के रूप में मुद्रित होते हैं। एक ही संरचना के सदस्यों के लिए अगला कदम 'असफल' नामक एक अन्य उदाहरण का उपयोग एक ही संरचना के सदस्यों को अलग-अलग अंकों के साथ इंगित करने के लिए किया जाता है। फिर परिणाम अब 34, 42, 13. के रूप में मुद्रित होते हैं। यह स्पष्ट रूप से बताता है कि संरचनाओं में सदस्य चर की एक प्रति होगी फिर सदस्यों को उनके आगामी फ़ंक्शन ब्लॉकों में पास करें।

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

वर्ग होने के लाभ

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

वर्गों और संरचनाओं के सामान्य लक्षण

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

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

Class classname {
   Definition 1
   Definition 2
   --- 
   Definition N
}

कक्षा की परिभाषा

class student {
   var studname: String
   var mark: Int 
   var mark2: Int 
}

उदाहरण बनाने के लिए वाक्य रचना

let studrecord = student()

उदाहरण

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark = 300
}

let marks = studentMarks()
print("Mark is \(marks.mark)")

Mark is 300

संदर्भ प्रकार के रूप में कक्षा के गुणों तक पहुँच

वर्ग गुण 'द्वारा पहुँचा जा सकता है।' वाक्य - विन्यास। प्रॉपर्टी के नाम को 'से अलग किया जाता है।' उदाहरण के नाम के बाद।

class MarksStruct {
   var mark: Int
   init(mark: Int) {
      self.mark = mark
   }
}

class studentMarks {
   var mark1 = 300
   var mark2 = 400
   var mark3 = 900
}

let marks = studentMarks()
print("Mark1 is \(marks.mark1)")
print("Mark2 is \(marks.mark2)")
print("Mark3 is \(marks.mark3)")

Mark1 is 300
Mark2 is 400
Mark3 is 900

क्लास आइडेंटिटी ऑपरेटर्स

स्विफ्ट 4 में कक्षाएं एक ही उदाहरण की ओर इशारा करते हुए कई स्थिरांक और चर को संदर्भित करती हैं। किसी विशेष श्रेणी के उदाहरण की ओर इशारा करने वाले स्थिरांक और चर के बारे में जानने के लिए, ऑपरेटर का उपयोग किया जाता है। कक्षा उदाहरण हमेशा संदर्भ द्वारा पारित किए जाते हैं। कक्षाओं में NSString, NSArray, और NSDictionary उदाहरण हमेशा एक कॉपी के बजाय मौजूदा उदाहरण के संदर्भ के रूप में दिए और पास किए जाते हैं।

ऑपरेटर्स को पहचान	ऑपरेटर्स को पहचान नहीं
ऑपरेटर का उपयोग किया जाता है (===)	इस्तेमाल किया ऑपरेटर है (= =)
जब दो कांस्टेंट या वैरिएबल एक ही उदाहरण की ओर इशारा करते हैं, तो सच होता है	जब दो कांस्टेंट या वैरिएबल एक अलग उदाहरण की ओर इशारा करते हैं तो यह सच हो जाता है

class SampleClass: Equatable {
   let myProperty: String
   init(s: String) {
      myProperty = s
   }
}

func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {
   return lhs.myProperty == rhs.myProperty
}

let spClass1 = SampleClass(s: "Hello")
let spClass2 = SampleClass(s: "Hello")

spClass1 === spClass2 // false
print("\(spClass1)")

spClass1 !== spClass2 // true
print("\(spClass2)")

main.SampleClass
main.SampleClass

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

संग्रहीत गुणों और कम्प्यूटेड गुणों के बीच अंतर

संग्रहित संपत्ति	गणना की गई संपत्ति
उदाहरण के रूप में स्थिर और चर मानों को संग्रहीत करें	मान को संग्रहीत करने के बजाय एक मान की गणना करें
वर्गों और संरचनाओं द्वारा प्रदान किया गया	कक्षाएं, गणना और संरचनाओं द्वारा प्रदान की जाती हैं

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

संग्रहीत गुणों के मूल्य का निरीक्षण करना
सुपरक्लास से प्राप्त विरासत वाले उपवर्ग की संपत्ति का निरीक्षण करना

संग्रहित गुण

स्विफ्ट 4 ने स्थिरांक और चर के उदाहरणों को संग्रहीत करने के लिए संग्रहीत संपत्ति अवधारणा का परिचय दिया। स्थिरांक के स्थिर गुणों को 'लेट' कीवर्ड द्वारा परिभाषित किया जाता है और चर के स्थिर गुणों को 'वेर' कीवर्ड द्वारा परिभाषित किया जाता है।

परिभाषा के दौरान संग्रहीत संपत्ति 'डिफ़ॉल्ट मान' प्रदान करती है
प्रारंभ के दौरान उपयोगकर्ता प्रारंभिक मानों को आरंभ और संशोधित कर सकता है

struct Number {
   var digits: Int
   let pi = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.pi)")

67
3.1415

उपरोक्त कोड में निम्नलिखित पंक्ति पर विचार करें -

let pi = 3.1415

यहां, चर पीआई को उदाहरण पीआई = 3.1415 के साथ संग्रहीत संपत्ति मूल्य के रूप में आरंभीकृत किया गया है। इसलिए, जब भी उदाहरण को संदर्भित किया जाता है, तो यह अकेले 3.1415 का मान रखेगा।

एक और तरीका है कि संग्रहित संपत्ति को स्थिर संरचनाओं के रूप में रखना है। इसलिए संरचनाओं के पूरे उदाहरण को 'स्थिर गुणों की स्थिरांक' माना जाएगा।

struct Number {
   var digits: Int
   let numbers = 3.1415
}

var n = Number(digits: 12345)
n.digits = 67

print("\(n.digits)")
print("\(n.numbers)")
n.numbers = 8.7

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

'संख्या ’को the. the तक पुष्ट करने के बजाय यह एक त्रुटि संदेश लौटाएगा जो यह दर्शाता है कि itial संख्या’ को स्थिर घोषित किया गया है।

आलसी संग्रहीत संपत्ति

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

आलसी गुण का उपयोग किया जाता है -

वस्तु निर्माण में देरी करना।
जब संपत्ति एक वर्ग के अन्य हिस्सों पर निर्भर होती है, तो अभी तक ज्ञात नहीं है

class sample {
   lazy var no = number()    // `var` declaration is required.
}

class number {
   var name = "Swift 4"
}

var firstsample = sample()
print(firstsample.no.name)

Swift 4

आवृत्ति के चर

ऑब्जेक्टिव सी में, संग्रहीत संपत्तियों में स्टोर किए गए मूल्यों को संग्रहीत करने के लिए बैक अप उद्देश्यों के लिए संग्रहित चर भी हैं।

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

संगणित गुण

गणना किए गए मूल्यों को संग्रहीत करने के बजाय अप्रत्यक्ष रूप से अन्य गुणों और मूल्यों को पुनः प्राप्त करने और सेट करने के लिए एक गेट्टर और एक वैकल्पिक सेटर प्रदान करते हैं।

class sample {
   var no1 = 0.0, no2 = 0.0
   var length = 300.0, breadth = 150.0

   var middle: (Double, Double) {
      get {
         return (length / 2, breadth / 2)
      }
      
      set(axis){
         no1 = axis.0 - (length / 2)
         no2 = axis.1 - (breadth / 2)
      }
   }
}

var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)

print(result.no1)
print(result.no2)

(150.0, 75.0)
-150.0
-65.0

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

गणना गुण केवल पढ़ने के लिए गुण के रूप में

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

class film {
   var head = ""
   var duration = 0.0
   var metaInfo: [String:String] {
      return [
         "head": self.head,
         "duration":"\(self.duration)"
      ]
   }
}

var movie = film()
movie.head = "Swift 4 Properties"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

Swift 4 Properties
3.09

संपत्ति पर्यवेक्षकों के रूप में गणना किए गए गुण

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

संपत्ति पर्यवेक्षकों को या तो परिभाषित किया जा सकता है

मान संग्रहीत करने से पहले - विलसेट
नया मान संग्रहीत करने के बाद - शुरू किया
जब किसी गुण को इनिशियलाइज़र विसेट में सेट किया जाता है और डिडसेट प्रेक्षकों को नहीं बुलाया जा सकता है।

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

स्थानीय और वैश्विक चर

संपत्तियों की गणना और अवलोकन के लिए स्थानीय और वैश्विक चर घोषित किए जाते हैं।

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

प्रकार के गुण

गुण घुंघराले ब्रेस {} के साथ प्रकार परिभाषा अनुभाग में परिभाषित किए गए हैं और चर का दायरा भी पहले से परिभाषित किया गया है। मूल्य प्रकारों के प्रकारों को परिभाषित करने के लिए 'स्थिर' कीवर्ड का उपयोग किया जाता है और वर्ग प्रकारों के लिए 'क्लास' कीवर्ड का उपयोग किया जाता है।

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

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // return an Int value here
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // return an Int value here
   }
}

गुण की स्थापना और स्थापना

उदाहरण के गुणों की तरह ही प्रकार की संपत्तियां क्वियर होती हैं और 'के साथ सेट होती हैं।' उदाहरण की ओर इशारा करने के बजाय केवल अकेले टाइप पर सिंटैक्स।

struct StudMarks {
   static let markCount = 97
   static var totalCount = 0
   
   var InternalMarks: Int = 0 {
      didSet {
         if InternalMarks > StudMarks.markCount {
            InternalMarks = StudMarks.markCount
         }
         if InternalMarks > StudMarks.totalCount {
            StudMarks.totalCount = InternalMarks
         }
      }
   }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()

stud1Mark1.InternalMarks = 98
print(stud1Mark1.InternalMarks)

stud1Mark2.InternalMarks = 87
print(stud1Mark2.InternalMarks)

97
87

स्विफ्ट 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)

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

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

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

कक्षाओं में एक संग्रह, अनुक्रम और एक सूची के तत्व सदस्यों तक पहुँचने, संरचना और गणना सदस्यता की मदद से किया जाता है। इन सबस्क्राइब का उपयोग इंडेक्स की मदद से वैल्यूज को स्टोर और रिकवर करने के लिए किया जाता है। ऐरे तत्वों को कुछ ऐरे [इंडेक्स] की मदद से एक्सेस किया जाता है और इसके बाद के एलीमेंट में एक एलिमेंट इंस्ट्रूमेंट को कुछ डेडिकोनरी [की] के रूप में एक्सेस किया जा सकता है।

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

सदस्यता घोषणा सिंटेक्स और इसके उपयोग

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

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

subscript(index: Int) −> Int {
   get {
      // used for subscript value declarations
   }
   set(newValue) {
      // definitions are written here
   }
}

उदाहरण 1

struct subexample {
   let decrementer: Int
   subscript(index: Int) -> Int {
      return decrementer / index
   }
}
let division = subexample(decrementer: 100)

print("The number is divisible by \(division[9]) times")
print("The number is divisible by \(division[2]) times")
print("The number is divisible by \(division[3]) times")
print("The number is divisible by \(division[5]) times")
print("The number is divisible by \(division[7]) times")

The number is divisible by 11 times
The number is divisible by 50 times
The number is divisible by 33 times
The number is divisible by 20 times
The number is divisible by 14 times

example2

class daysofaweek {
   private var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
      "Thursday", "Friday", "saturday"]
   subscript(index: Int) -> String {
      get {
         return days[index]
      }
      set(newValue) {
         self.days[index] = newValue
      }
   }
}
var p = daysofaweek()

print(p[0])
print(p[1])
print(p[2])
print(p[3])

Sunday
Monday
Tuesday
Wednesday

सबस्क्रिप्ट में विकल्प

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

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

struct Matrix {
   let rows: Int, columns: Int
   var print: [Double]
   init(rows: Int, columns: Int) {
      self.rows = rows
      self.columns = columns
      print = Array(count: rows * columns, repeatedValue: 0.0)
   }
   subscript(row: Int, column: Int) -> Double {
      get {
         return print[(row * columns) + column]
      }
      set {
         print[(row * columns) + column] = newValue
      }
   }
}
var mat = Matrix(rows: 3, columns: 3)

mat[0,0] = 1.0
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0

print("\(mat[0,0])")

1.0

स्विफ्ट 4 सबस्क्रिप्ट उपयुक्त डेटा प्रकारों के लिए कई पैरामीटर घोषणाओं के लिए एकल पैरामीटर का समर्थन करता है। कार्यक्रम 'मैट्रिक्स' संरचना को 'डबल' डेटा प्रकारों को संग्रहीत करने के लिए 2 * 2 आयामी सरणी मैट्रिक्स के रूप में घोषित करता है। मैट्रिक्स पैरामीटर को पंक्तियों और स्तंभों की घोषणा के लिए इंटेगर डेटा प्रकारों के साथ इनपुट किया गया है।

मैट्रिक्स के लिए नया उदाहरण पंक्ति और स्तंभ गणना को प्रारंभ में दिखाने के लिए पास करके बनाया गया है।

var mat = Matrix(rows: 3, columns: 3)

मैट्रिक्स मानों को उप-पंक्ति में पंक्ति और स्तंभ मानों को पास करके परिभाषित किया जा सकता है, जो नीचे दिखाए गए अल्पविराम द्वारा अलग किया गया है।

mat[0,0] = 1.0  
mat[0,1] = 2.0
mat[1,0] = 3.0
mat[1,1] = 5.0

अधिक रूप से लेने की क्षमता को इनहेरिटेंस के रूप में परिभाषित किया गया है। आम तौर पर एक वर्ग दूसरे वर्ग से तरीकों, गुणों और कार्यक्षमता का वारिस कर सकता है। कक्षाओं को उप-वर्ग और सुपर क्लास में वर्गीकृत किया जा सकता है।

Sub Class - जब एक वर्ग दूसरे वर्ग से गुण, तरीके और कार्य प्राप्त करता है तो उसे उप-वर्ग कहा जाता है
Super Class - स्वयं से अन्य वर्गों को विरासत में देने वाले गुणों, विधियों और कार्यों वाले वर्ग को सुपर क्लास कहा जाता है

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

बेस क्लास

एक वर्ग जो किसी अन्य वर्ग के तरीकों, गुणों या कार्यों को विरासत में नहीं देता है, उसे 'बेस क्लास' कहा जाता है।

class StudDetails {
   var stname: String!
   var mark1: Int!
   var mark2: Int!
   var mark3: Int!
   
   init(stname: String, mark1: Int, mark2: Int, mark3: Int) {
      self.stname = stname
      self.mark1 = mark1
      self.mark2 = mark2
      self.mark3 = mark3
   }
}

let stname = "Swift 4"
let mark1 = 98
let mark2 = 89
let mark3 = 76

print(stname)
print(mark1)
print(mark2)
print(mark3)

Swift 4
98
89
76

Classname के साथ क्लास StudDetails को एक आधार वर्ग के रूप में परिभाषित किया गया है जिसका उपयोग छात्रों के नाम, और तीन विषयों mark1, mark2 और mark3 के रूप में किया जाता है। 'let' कीवर्ड का उपयोग बेस क्लास के लिए मूल्य को इनिशियलाइज़ करने के लिए किया जाता है और बेस क्लास वैल्यू को 'प्रिंट' फंक्शन की मदद से खेल के मैदान में प्रदर्शित किया जाता है।

उपवर्ग

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

class StudDetails {
   var mark1: Int;
   var mark2: Int;
   
   init(stm1:Int, results stm2:Int) {
      mark1 = stm1;
      mark2 = stm2;
   }
   func print() {
      print("Mark1:\(mark1), Mark2:\(mark2)")
   }
}

class display : StudDetails {
   init() {
      super.init(stm1: 93, results: 89)
   }
}

let marksobtained = display()
marksobtained.print()

Mark1:93, Mark2:89

क्लास 'StudDetails' को सुपर क्लास के रूप में परिभाषित किया जाता है जहाँ छात्र अंक घोषित किए जाते हैं और उप-वर्ग 'डिस्प्ले' का उपयोग इसके सुपर क्लास से अंक प्राप्त करने के लिए किया जाता है। सब क्लास छात्रों के अंकों को परिभाषित करता है और छात्रों के चिह्न को प्रदर्शित करने के लिए प्रिंट () विधि को कॉल करता है।

अधिभावी

सुपर क्लास उदाहरण, प्रकार के तरीकों, उदाहरण, प्रकार के गुणों और सबस्क्राइब को एक्सेस करने से ओवरराइडिंग की अवधारणा मिलती है। सुपरक्लास में घोषित विधियों को ओवरराइड करने के लिए 'ओवरराइड' कीवर्ड का उपयोग किया जाता है।

सुपर क्लास मेथड्स, प्रॉपर्टीज और सब्सक्राइबर्स तक पहुंच

सुपर क्लास में घोषित तरीकों, गुणों और सदस्यता तक पहुंचने के लिए 'सुपर' कीवर्ड का इस्तेमाल उपसर्ग के रूप में किया जाता है

अधिभावी	विधियों, गुणों और सदस्यता तक पहुंच
तरीकों	super.somemethod ()
गुण	super.someProperty ()
सबस्क्रिप्ट	सुपर [someIndex]

तरीके ओवरराइडिंग

अंतर्निहित उदाहरण और प्रकार के तरीकों को हमारे उपवर्ग में परिभाषित हमारे तरीकों के लिए 'ओवरराइड' कीवर्ड द्वारा ओवरराइड किया जा सकता है। सुपर क्लास प्रिंट () में उल्लिखित प्रकार की संपत्ति तक पहुँचने के लिए उपवर्ग में प्रिंट () ओवरराइड किया गया है। साथ ही क्रिकेट का नया उदाहरण () सुपर क्लास 'क्रिकेंस्टेंस' के रूप में बनाया गया है।

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

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

let cricinstance = cricket()
cricinstance.print()

let tennisinstance = tennis()
tennisinstance.print()

Welcome to Swift Super Class
Welcome to Swift Sub Class

संपत्ति अधिभोग

आप उस संपत्ति के लिए अपने स्वयं के कस्टम गेट्टर और सेटर प्रदान करने के लिए एक अंतर्निहित उदाहरण या वर्ग की संपत्ति को ओवरराइड कर सकते हैं, या अंतर्निहित संपत्ति के मूल्य में परिवर्तन होने पर ओवरराइडिंग संपत्ति को देखने के लिए सक्षम करने के लिए संपत्ति पर्यवेक्षकों को जोड़ने के लिए।

ओवरराइडिंग प्रॉपर्टी गेटर्स एंड सेटर्स

स्विफ्ट 4 उपयोगकर्ता को विरासत में मिली संपत्ति को ओवरराइड करने के लिए कस्टम गेट्टर और सेटर प्रदान करने की अनुमति देता है चाहे वह संग्रहित या गणना की गई संपत्ति हो। उपवर्ग विरासत में मिली संपत्ति के नाम और प्रकार को नहीं जानता है। इसलिए यह आवश्यक है कि उपयोगकर्ता को उपवर्ग में, सुपर क्लास में निर्दिष्ट ओवरराइडिंग संपत्ति का नाम और प्रकार निर्दिष्ट करना होगा।

इसे दो तरीकों से किया जा सकता है -

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

class Circle {
   var radius = 12.5
   var area: String {
      return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

Radius of rectangle for 25.0  is now overridden as 3

ओवरराइडिंग प्रॉपर्टी ऑब्जर्वर

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

class Circle {
   var radius = 12.5
   var area: String {
     return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

class Square: Rectangle {
   override var radius: Double {
      didSet {
         print = Int(radius/5.0)+1
      }
   }
}

let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")

Radius of rectangle for 25.0  is now overridden as 3
Radius of rectangle for 100.0  is now overridden as 21

ओवरराइडिंग को रोकने के लिए अंतिम संपत्ति

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

final class Circle {
   final var radius = 12.5
   var area: String {
      return "of rectangle for \(radius) "
   }
}

class Rectangle: Circle {
   var print = 7
   override var area: String {
      return super.area + " is now overridden as \(print)"
   }
}

let rect = Rectangle()
rect.radius = 25.0
rect.print = 3
print("Radius \(rect.area)")

class Square: Rectangle {
   override var radius: Double {
      didSet {
         print = Int(radius/5.0)+1
      }
   }
}

let sq = Square()
sq.radius = 100.0
print("Radius \(sq.area)")

<stdin>:14:18: error: var overrides a 'final' var
override var area: String {
^
<stdin>:7:9: note: overridden declaration is here
var area: String {
^
<stdin>:12:11: error: inheritance from a final class 'Circle'
class Rectangle: Circle {
^
<stdin>:25:14: error: var overrides a 'final' var
override var radius: Double {
^
<stdin>:6:14: note: overridden declaration is here
final var radius = 12.5

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

कक्षा 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 भाषा संग्रहीत संपत्ति मूल्यों को आरंभ करने के लिए इनिट () फ़ंक्शन प्रदान करती है। साथ ही, उपयोगकर्ता के पास वर्ग या संरचना के सदस्यों की घोषणा करते समय संपत्ति के मूल्यों को डिफ़ॉल्ट रूप से शुरू करने का प्रावधान है। जब संपत्ति पूरे कार्यक्रम में अकेले समान मूल्य लेती है तो हम इसे इनिट () में इनिशियलाइज़ करने के बजाय अकेले घोषणा खंड में घोषित कर सकते हैं। डिफ़ॉल्ट रूप से गुण मान सेट करना उपयोगकर्ता को तब सक्षम बनाता है जब वंशानुक्रम को वर्गों या संरचनाओं के लिए परिभाषित किया जाता है।

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 प्रत्येक और प्रत्येक पैरामीटर init () के लिए एक स्वचालित बाहरी नाम प्रस्तुत करता है। यह स्वचालित बाहरी नाम हर इनिशियलाइज़ेशन पैरामीटर से पहले लिखे गए स्थानीय नाम के बराबर है।

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

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?' एक वैकल्पिक उदाहरण को परिभाषित करने के लिए प्रारंभिक आरम्भक। विशिष्ट प्रकार 'अंतर्निहित' के एक स्पष्ट रूप से अपरिवर्तित वैकल्पिक उदाहरण को परिभाषित करने के लिए! ' अधिकृत है।

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

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

मेमोरी स्पेस को डीलेक्ट करने के लिए डीनेन्ट्रीलाइजेशन

स्विफ्ट 4 संसाधनों को खाली करने के लिए स्वचालित रूप से आपके उदाहरणों को स्वचालित रूप से प्रस्तुत करता है, जिनकी अब आवश्यकता नहीं है। स्विफ्ट 4 ऑटोमैटिक रेफरेंस काउंटिंग में बताए गए ऑटोमैटिक रेफरेंस काउंटिंग (ARC) के जरिए इंस्टेंस की मेमोरी मैनेजमेंट को हैंडल करता है। आमतौर पर आपको मैन्युअल रूप से क्लीन-अप करने की आवश्यकता नहीं होती है जब आपके उदाहरणों का निपटारा किया जाता है। हालाँकि, जब आप अपने स्वयं के संसाधनों के साथ काम कर रहे होते हैं, तो आपको कुछ अतिरिक्त सफाई करने की आवश्यकता हो सकती है। उदाहरण के लिए, यदि आप किसी फ़ाइल को खोलने के लिए एक कस्टम क्लास बनाते हैं और उसमें कुछ डेटा लिखते हैं, तो आपको क्लास के उदाहरण से पहले फ़ाइल को बंद करने की आवश्यकता हो सकती है।

var counter = 0; // for reference counting
class baseclass {
   init() {
      counter++;
   }
   deinit {
      counter--;
   }
}
var print: baseclass? = baseclass()

print(counter)
print = nil
print(counter)

1
0

जब प्रिंट = एनआईएल स्टेटमेंट को छोड़ दिया जाता है, तो काउंटर का मान उसी तरह से बरकरार रहता है, क्योंकि यह डीइनिविटलाइज्ड नहीं है।

var counter = 0; // for reference counting

class baseclass {
   init() {
      counter++;
   }
   deinit {
      counter--;
   }
}
var print: baseclass? = baseclass()
print(counter)
print(counter)

1
1

मेमोरी प्रबंधन कार्यों और इसके उपयोग को स्विफ्ट 4 भाषा में स्वचालित संदर्भ गणना (एआरसी) के माध्यम से नियंत्रित किया जाता है। एआरसी का उपयोग सिस्टम संसाधनों को आरंभीकृत करने और विघटित करने के लिए किया जाता है, जिससे वर्ग उदाहरणों द्वारा उपयोग किए जाने वाले मेमोरी स्पेस को जारी किया जाता है जब इंस्टेंसेस की आवश्यकता नहीं होती है। एआरसी मेमोरी कोड को प्रभावी ढंग से प्रबंधित करने के लिए हमारे कोड इंस्टेंस के बीच संबंधों के बारे में जानकारी का ट्रैक रखता है।

एआरसी के कार्य

एआरसी सूचनाओं को संग्रहीत करने के लिए स्मृति का एक हिस्सा आवंटित करता है जब हर बार एक नई श्रेणी का उदाहरण init () द्वारा बनाया जाता है।
उदाहरण प्रकार और उसके मूल्यों के बारे में जानकारी स्मृति में संग्रहीत की जाती है।
जब वर्ग उदाहरण की आवश्यकता नहीं होती है, तो यह स्वचालित रूप से आगे की श्रेणी के भंडारण और पुनर्प्राप्ति के लिए deinit () द्वारा मेमोरी स्पेस को मुक्त करता है।
एआरसी वर्तमान में क्लास इंस्टेंस प्रॉपर्टीज, कॉन्स्टेंट और वैरिएबल का जिक्र करता रहता है ताकि डीइनिट () उन अप्रयुक्त इंस्टेंस पर ही लागू हो।
एआरसी उन वर्ग उदाहरण संपत्ति, स्थिरांक और चर को 'मजबूत संदर्भ' बनाए रखता है, जब वर्ग उदाहरण वर्तमान में उपयोग में है।

एआरसी कार्यक्रम

class StudDetails {
   var stname: String!
   var mark: Int!
   
   init(stname: String, mark: Int) {
      self.stname = stname
      self.mark = mark
   }
   deinit {
      print("Deinitialized \(self.stname)")
      print("Deinitialized \(self.mark)")
   }
}

let stname = "Swift 4"
let mark = 98

print(stname)
print(mark)

Swift 4
98

एआरसी मजबूत संदर्भ चक्र वर्ग उदाहरण

class studmarks {
   let name: String
   var stud: student?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

class student {
   let name: String
   var strname: studmarks?
   
   init (name: String) {
      print("Initializing: \(name)")
      self.name = name
   }
   deinit {
      print("Deallocating: \(self.name)")
   }
}

var shiba: studmarks?
var mari: student?

shiba = studmarks(name: "Swift 4")
mari = student(name: "ARC")

shiba!.stud = mari
mari!.strname = shiba

Initializing: Swift 4
Initializing: ARC

एआरसी कमजोर और प्रसिद्ध संदर्भ

कक्षा प्रकार की संपत्तियों के मजबूत संदर्भ चक्र को हल करने के दो तरीके हैं -

कमजोर संदर्भ
प्रख्यात संदर्भ

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

कमजोर संदर्भ कार्यक्रम

class module {
   let name: String
   init(name: String) { self.name = name }
   var sub: submodule?
   deinit { print("\(name) Is The Main Module") }
}

class submodule {
   let number: Int
   init(number: Int) { self.number = number }
   weak var topic: module?

   deinit { print("Sub Module with its topic number is \(number)") }
}

var toc: module?
var list: submodule?
toc = module(name: "ARC")
list = submodule(number: 4)
toc!.sub = list
list!.topic = toc

toc = nil
list = nil

ARC Is The Main Module
Sub Module with its topic number is 4

प्रसिद्ध संदर्भ कार्यक्रम

class student {
   let name: String
   var section: marks?
   init(name: String) {
      self.name = name
   }
   deinit { print("\(name)") }
}

class marks {
   let marks: Int
   unowned let stname: student
   
   init(marks: Int, stname: student) {
      self.marks = marks
      self.stname = stname
   }
   deinit { print("Marks Obtained by the student is \(marks)") }
}

var module: student?
module = student(name: "ARC")
module!.section = marks(marks: 98, stname: module!)
module = nil

ARC
Marks Obtained by the student is 98

क्लोजर के लिए मजबूत संदर्भ चक्र

जब हम क्लास इंस्टेंस प्रॉपर्टी और क्लोजर बॉडी को क्लोजर देते हैं तो विशेष इंस्टेंस को कैप्चर करने के लिए मजबूत रेफरेंस साइकिल हो सकती है। बंद करने के लिए मजबूत संदर्भ 'self.someProperty' या 'self.someMethod ()' द्वारा परिभाषित किया गया है। मजबूत संदर्भ चक्र को क्लोजर के लिए संदर्भ प्रकार के रूप में उपयोग किया जाता है।

class HTMLElement {
   let samplename: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      if let text = self.text {
         return "<\(self.samplename)>\(text)</\(self.samplename)>"
      } else {
         return "<\(self.samplename) />"
      }
   }
   init(samplename: String, text: String? = nil) {
      self.samplename = samplename
      self.text = text
   }
   deinit {
      print("\(samplename) is being deinitialized")
   }
}

var paragraph: HTMLElement? = HTMLElement(samplename: "p", text: "Welcome to Closure SRC")
print(paragraph!.asHTML())

<p>Welcome to Closure SRC</p>

कमजोर और अज्ञात संदर्भ

जब क्लोजर और इंस्टेंस एक-दूसरे को संदर्भित करते हैं, तो उपयोगकर्ता एक क्लोजर में कैप्चर को एक अज्ञात संदर्भ के रूप में परिभाषित कर सकता है। तब यह उपयोगकर्ता को एक ही समय में उदाहरण से निपटने की अनुमति नहीं देगा। जब उदाहरण कभी-कभी 'शून्य' मान लौटाता है, तो कमजोर उदाहरण के साथ बंद को परिभाषित करें।

class HTMLElement {
   let module: String
   let text: String?
   
   lazy var asHTML: () -> String = {
      [unowned self] in
      if let text = self.text {
         return "<\(self.module)>\(text)</\(self.module)>"
      } else {
         return "<\(self.module) />"
      }
   }
   init(module: String, text: String? = nil) {
      self.module = module
      self.text = text
   }
   deinit {
      print("\(module) the deinit()")
   }
}

var paragraph: HTMLElement? = HTMLElement(module: "Inside", text: "ARC Weak References")
print(paragraph!.asHTML())
paragraph = nil

<Inside>ARC Weak References</Inside>
Inside the deinit()

वैकल्पिक, 'nil' हो सकने वाले गुणों पर क्वेरीज़, कॉलिंग प्रॉपर्टीज़, सब्सक्रिप्शन और विधियों की प्रक्रिया को वैकल्पिक रूप से परिभाषित किया जाता है। वैकल्पिक चैनिंग दो मान लौटाते हैं -

यदि वैकल्पिक में 'मान' है, तो संबंधित संपत्ति, विधियों और सदस्यता रिटर्न मानों को कॉल करना
यदि वैकल्पिक में 'एनआईएल' मूल्य है, तो इसकी संबंधित संपत्ति, विधियां और सदस्यताएं शून्य हो जाती हैं

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

वैकल्पिक चेनिंग के लिए एक विकल्प के रूप में मजबूर जबरन

वैकल्पिक मूल्य निर्धारण 'के साथ वैकल्पिक मूल्य के बाद निर्दिष्ट किया गया है?' जब कोई मूल्य कुछ मान लौटाता है, तो किसी प्रॉपर्टी, मेथड या सबस्क्रिप्ट को कॉल करने के लिए।

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

'के साथ वैकल्पिक चेनिंग के लिए कार्यक्रम!'

class ElectionPoll {
   var candidate: Pollbooth?
}

lass Pollbooth {
   var name = "MP"
}

let cand = ElectionPoll()
let candname = cand.candidate!.name

fatal error: unexpectedly found nil while unwrapping an Optional value
0 Swift 4 0x0000000103410b68
llvm::sys::PrintStackTrace(__sFILE*) + 40
1 Swift 4 0x0000000103411054 SignalHandler(int) + 452
2 libsystem_platform.dylib 0x00007fff9176af1a _sigtramp + 26
3 libsystem_platform.dylib 0x000000000000000b _sigtramp + 1854492939
4 libsystem_platform.dylib 0x00000001074a0214 _sigtramp + 1976783636
5 Swift 4 0x0000000102a85c39
llvm::JIT::runFunction(llvm::Function*, std::__1::vector > const&) + 329
6 Swift 4 0x0000000102d320b3
llvm::ExecutionEngine::runFunctionAsMain(llvm::Function*,
std::__1::vector<std::__1::basic_string, std::__1::allocator >,
std::__1::allocator<std::__1::basic_string, std::__1::allocator > > > const&,
char const* const*) + 1523
7 Swift 4 0x000000010296e6ba Swift 4::RunImmediately(Swift
4::CompilerInstance&, std::__1::vector<std::__1::basic_string,
std::__1::allocator >, std::__1::allocator<std::__1::basic_string,
std::__1::allocator > > > const&, Swift 4::IRGenOptions&, Swift 4::SILOptions
const&) + 1066
8 Swift 4 0x000000010275764b frontend_main(llvm::ArrayRef,
char const*, void*) + 5275
9 Swift 4 0x0000000102754a6d main + 1677
10 libdyld.dylib 0x00007fff8bb9e5c9 start + 1
11 libdyld.dylib 0x000000000000000c start + 1950751300
Stack dump:
0. Program arguments:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/
usr/bin/Swift 4 -frontend -interpret - -target x86_64-apple-darwin14.0.0 -
target-cpu core2 -sdk
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/
SDKs/MacOSX10.10.sdk -module-name main
/bin/sh: line 47: 15672 Done cat <<'SWIFT 4'
import Foundation
</std::__1::basic_string</std::__1::basic_string</std::__1::basic_string</std::
__1::basic_string

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

वैकल्पिक चैनिंग के लिए कार्यक्रम '?'

class ElectionPoll {
   var candidate: Pollbooth?
}

class Pollbooth {
   var name = "MP"
}
let cand = ElectionPoll()

if let candname = cand.candidate?.name {
   print("Candidate name is \(candname)")
} else {
   print("Candidate name cannot be retreived")
}

Candidate name cannot be retreived

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

वैकल्पिक चेनिंग और एक्सेसिंग गुणों के लिए मॉडल कक्षाएं परिभाषित करना

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

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var street: String?

   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let rectname = rectangle()
if let rectarea = rectname.print?.cprint {
   print("Area of rectangle is \(rectarea)")
} else {
   print("Rectangle Area is not specified")
}

Rectangle Area is not specified

वैकल्पिक चैनिंग के माध्यम से कॉलिंग के तरीके

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }

   func circleprint() {
      print("Area of Circle is: \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if circname.print?.circleprint() != nil {
   print("Area of circle is specified)")
} else {
   print("Area of circle is not specified")
}

Area of circle is not specified

सर्कल के अंदर घोषित फंक्शन सर्कलप्रिंट () सब क्लास को 'सर्कनामे' नाम से एक इंस्टेंस बनाकर बुलाया जाता है। फ़ंक्शन एक मान लौटाएगा यदि इसमें कुछ मान शामिल है अन्यथा यह कुछ उपयोगकर्ता परिभाषित प्रिंट संदेश को '' अगर circ.print.print? .Circleprint ()! = Nil '' स्टेटमेंट की जाँच करके लौटाएगा।

वैकल्पिक चैनिंग के माध्यम से सहायक अभिगम

वैकल्पिक चाइनिंग का उपयोग यह निर्धारित करने के लिए एक सबस्क्रिप्ट मान को प्राप्त करने के लिए किया जाता है कि क्या उस सबस्क्रिप्ट पर कॉल करने से मान वापस आता है। '?' किसी विशेष सबस्क्रिप्ट पर वैकल्पिक मान तक पहुँचने के लिए सबस्क्रिप्ट ब्रेज़ से पहले रखा जाता है।

कार्यक्रम 1

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname =  radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if let radiusName = circname.print?[0].radiusname {
   print("The first room name is \(radiusName).")
} else {
   print("Radius is not specified.")
}

Radius is not specified.

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

कार्यक्रम 2

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")
let printing = circle()

printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

if let radiusName = circname.print?[0].radiusname {
   print("Radius is measured in \(radiusName).")
} else {
   print("Radius is not specified.")
}

Radius is measured in Units.

उपरोक्त कार्यक्रम में, सदस्यता फ़ंक्शन 'त्रिज्यानाम' के लिए उदाहरण मान निर्दिष्ट है। इसलिए फ़ंक्शन को प्रोग्राम कॉल अब मान लौटाएगा।

वैकल्पिक प्रकार की सदस्यता तक पहुँचने

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }

   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")

let printing = circle()
printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

var area = ["Radius": [35, 45, 78, 101], "Circle": [90, 45, 56]]
area["Radius"]?[1] = 78
area["Circle"]?[1]--

print(area["Radius"]?[0])
print(area["Radius"]?[1])
print(area["Radius"]?[2])
print(area["Radius"]?[3])

print(area["Circle"]?[0])
print(area["Circle"]?[1])
print(area["Circle"]?[2])

Optional(35)
Optional(78)
Optional(78)
Optional(101)
Optional(90)
Optional(44)
Optional(56)

सदस्यता के लिए वैकल्पिक मानों को उनके सबस्क्रिप्ट मानों को संदर्भित करके एक्सेस किया जा सकता है। इसे सबस्क्रिप्ट [0], सबस्क्रिप्ट [1] आदि के रूप में एक्सेस किया जा सकता है। 'त्रिज्या' के लिए डिफ़ॉल्ट सबस्क्रिप्ट मानों को पहले [35, 45, 78, 101] और 'सर्कल' [90, 45, 56]] के रूप में सौंपा गया है। । फिर सबस्क्रिप्ट मानों को रेडियस [0] से 78 और सर्कल [1] से 45 में बदल दिया जाता है।

चेनिंग के कई स्तरों को जोड़ना

मल्टीपल सब क्लास को इसके सुपर क्लास के तरीकों, प्रॉपर्टीज और सब्सक्राइबर्स के साथ वैकल्पिक चैनिंग द्वारा भी जोड़ा जा सकता है।

वैकल्पिक के कई चेनिंग को जोड़ा जा सकता है -

यदि पुनर्प्राप्त करने का प्रकार वैकल्पिक नहीं है, तो वैकल्पिक चैनिंग एक वैकल्पिक मान लौटाएगा। उदाहरण के लिए यदि स्ट्रिंग स्ट्रिंग वैकल्पिक के माध्यम से यह स्ट्रिंग वापस आ जाएगी? मूल्य

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?

   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if let radiusName = circname.print?[0].radiusname {
   print("The first room name is \(radiusName).")
} else {
   print("Radius is not specified.")
}

Radius is not specified.

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

यदि पुनर्प्राप्ति प्रकार पहले से ही वैकल्पिक है, तो वैकल्पिक श्रृंखलन भी एक वैकल्पिक मान लौटाएगा। उदाहरण के लिए अगर स्ट्रिंग? वैकल्पिक चैनिंग के माध्यम से पहुँचा है यह स्ट्रिंग वापस आ जाएगी? मूल्य ..

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("The number of rooms is \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()
circname.print?[0] = radius(radiusname: "Diameter")
let printing = circle()

printing.area.append(radius(radiusname: "Units"))
printing.area.append(radius(radiusname: "Meter"))
circname.print = printing

if let radiusName = circname.print?[0].radiusname {
   print("Radius is measured in \(radiusName).")
} else {
   print("Radius is not specified.")
}

Radius is measured in Units.

उपरोक्त कार्यक्रम में, सदस्यता फ़ंक्शन 'त्रिज्यानाम' के लिए उदाहरण मान निर्दिष्ट है। इसलिए, फ़ंक्शन को प्रोग्राम कॉल अब मान लौटाएगा।

वैकल्पिक रिटर्न मान के साथ तरीकों पर जंजीर

वैकल्पिक चाइनिंग का उपयोग उपवर्ग परिभाषित विधियों तक पहुँचने के लिए भी किया जाता है।

class rectangle {
   var print: circle?
}

class circle {
   var area = [radius]()
   var cprint: Int {
      return area.count
   }
   subscript(i: Int) -> radius {
      get {
         return area[i]
      }
      set {
         area[i] = newValue
      }
   }
   func circleprint() {
      print("Area of Circle is: \(cprint)")
   }
   var rectarea: circumference?
}

class radius {
   let radiusname: String
   init(radiusname: String) { self.radiusname = radiusname }
}

class circumference {
   var circumName: String?
   var circumNumber: String?
   var circumarea: String?
   
   func buildingIdentifier() -> String? {
      if circumName != nil {
         return circumName
      } else if circumNumber != nil {
         return circumNumber
      } else {
         return nil
      }
   }
}

let circname = rectangle()

if circname.print?.circleprint() != nil {
   print("Area of circle is specified)")
} else {
   print("Area of circle is not specified")
}

Area of circle is not specified

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

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

एक वर्ग पदानुक्रम को परिभाषित करना

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

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz

चेकिंग टाइप करें

प्रकार की जाँच 'ऑपरेटर' के साथ की जाती है। '' प्रकार का चेक संचालक जांचता है कि क्या उदाहरण विशेष उपवर्ग प्रकार का है और 'सही' है यदि यह उस उदाहरण से संबंधित है तो यह 'गलत' वापस आ जाएगा।

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0
for item in sa {
   if item is Chemistry {
      ++chemCount
   } else if item is Maths {
      ++mathsCount
   }
}

print("Subjects in chemistry contains \(chemCount) topics and maths contains \(mathsCount) topics")

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Subjects in chemistry contains 2 topics and maths contains 3 topics

downcasting

उपवर्ग टाइप डाउनकास्टिंग दो ऑपरेटरों (के रूप में? और के रूप में) के साथ किया जा सकता है। 'के रूप में?' वैकल्पिक मान लौटाता है जब मान शून्य देता है। इसका उपयोग सफल डाउनकास्ट की जांच करने के लिए किया जाता है।

'जैसा!' जब रिटर्न डाउनिंग शून्य मान देता है, तो वैकल्पिक चेंजिंग में चर्चा के रूप में रिटर्न को खोलना बल देता है। यह डाउनकास्ट विफलता के मामले में रनटाइम त्रुटि को ट्रिगर करने के लिए उपयोग किया जाता है

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in sa {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series

टाइपकास्टिंग: कोई भी और कोई भी वस्तु

कीवर्ड 'Any' का उपयोग एक ऐसे उदाहरण को दर्शाने के लिए किया जाता है, जो फ़ंक्शन प्रकारों सहित किसी भी प्रकार का है।

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let sa = [
   Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in sa {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

var exampleany = [Any]()

exampleany.append(12)
exampleany.append(3.14159)
exampleany.append("Example for Any")
exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz"))

for print in exampleany {
   switch print {
      case let someInt as Int:
         print("Integer value is \(someInt)")
      case let someDouble as Double where someDouble > 0:
         print("Pi value is \(someDouble)")
      case let someString as String:
         print("\(someString)")
      case let phy as Chemistry:   
         print("Topics '\(phy.physics)', \(phy.equations)")
      default:
         print("None")
   }
}

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

AnyObject

किसी भी वर्ग प्रकार के उदाहरण का प्रतिनिधित्व करने के लिए, 'AnyObject' कीवर्ड का उपयोग किया जाता है।

class Subjects {
   var physics: String
   init(physics: String) {
      self.physics = physics
   }
}

class Chemistry: Subjects {
   var equations: String
   init(physics: String, equations: String) {
      self.equations = equations
      super.init(physics: physics)
   }
}

class Maths: Subjects {
   var formulae: String
   init(physics: String, formulae: String) {
      self.formulae = formulae
      super.init(physics: physics)
   }
}

let saprint: [AnyObject] = [Chemistry(physics: "solid physics", equations: "Hertz"),
   Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"),
   Chemistry(physics: "Thermo physics", equations: "Decibels"),
   Maths(physics: "Astro Physics", formulae: "MegaHertz"),
   Maths(physics: "Differential Equations", formulae: "Cosine Series")]

let samplechem = Chemistry(physics: "solid physics", equations: "Hertz")
print("Instance physics is: \(samplechem.physics)")
print("Instance equation is: \(samplechem.equations)")

let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")
print("Instance physics is: \(samplemaths.physics)")
print("Instance formulae is: \(samplemaths.formulae)")

var chemCount = 0
var mathsCount = 0

for item in saprint {
   if let print = item as? Chemistry {
      print("Chemistry topics are: '\(print.physics)', \(print.equations)")
   } else if let example = item as? Maths {
      print("Maths topics are: '\(example.physics)', \(example.formulae)")
   }
}

var exampleany = [Any]()
exampleany.append(12)
exampleany.append(3.14159)
exampleany.append("Example for Any")
exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz"))

for print in exampleany {
   switch print {
      case let someInt as Int:
         print("Integer value is \(someInt)")
      case let someDouble as Double where someDouble > 0:
         print("Pi value is \(someDouble)")
      case let someString as String:
         print("\(someString)")
      case let phy as Chemistry:
         print("Topics '\(phy.physics)', \(phy.equations)")
      default:
         print("None")
   }
}

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

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

Swift Extension Functionalities -

संगणित गुण और संगणित प्रकार के गुण जोड़ना
उदाहरण और प्रकार के तरीकों को परिभाषित करना।
नए इनिशियलाइज़र उपलब्ध कराना।
सदस्यता को परिभाषित करना
नए नेस्टेड प्रकारों को परिभाषित करना और उनका उपयोग करना
एक मौजूदा प्रकार एक प्रोटोकॉल के अनुरूप बनाना

एक्सटेंशन 'कीवर्ड' के साथ घोषित किए जाते हैं

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

extension SomeType {
   // new functionality can be added here
}

मौजूदा प्रकार को एक्सटेंशन के साथ जोड़ा जा सकता है ताकि इसे एक प्रोटोकॉल मानक के रूप में बनाया जा सके और इसका सिंटैक्स कक्षाओं या संरचनाओं के समान हो।

extension SomeType: SomeProtocol, AnotherProtocol {
   // protocol requirements is described here
}

संगणित गुण

एक्सटेंडेड 'उदाहरण' और 'टाइप' प्रॉपर्टीज को एक्सटेंशन की मदद से भी बढ़ाया जा सकता है।

extension Int {
   var add: Int {return self + 100 }
   var sub: Int { return self - 10 }
   var mul: Int { return self * 10 }
   var div: Int { return self / 5 }
}

let addition = 3.add
print("Addition is \(addition)")

let subtraction = 120.sub
print("Subtraction is \(subtraction)")

let multiplication = 39.mul
print("Multiplication is \(multiplication)")

let division = 55.div
print("Division is \(division)")

let mix = 30.add + 34.sub
print("Mixed Type is \(mix)")

Addition is 103
Subtraction is 110
Multiplication is 390
Division is 11
Mixed Type is 154

initializers

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

struct sum {
   var num1 = 100, num2 = 200
}

struct diff {
   var no1 = 200, no2 = 100
}

struct mult {
   var a = sum()
   var b = diff()
}

let calc = mult()
print ("Inside mult block \(calc.a.num1, calc.a.num2)")
print("Inside mult block \(calc.b.no1, calc.b.no2)")

let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
print("Inside mult block \(memcalc.a.num1, memcalc.a.num2)")
print("Inside mult block \(memcalc.b.no1, memcalc.b.no2)")

extension mult {
   init(x: sum, y: diff) {
      let X = x.num1 + x.num2
      let Y = y.no1 + y.no2
   }
}

let a = sum(num1: 100, num2: 200)
print("Inside Sum Block:\( a.num1, a.num2)")

let b = diff(no1: 200, no2: 100)
print("Inside Diff Block: \(b.no1, b.no2)")

Inside mult block (100, 200)
Inside mult block (200, 100)
Inside mult block (300, 500)
Inside mult block (300, 100)
Inside Sum Block:(100, 200)
Inside Diff Block: (200, 100)

तरीकों

नए उदाहरण के तरीके और प्रकार के तरीकों को एक्सटेंशन की मदद से उपवर्ग में और जोड़ा जा सकता है।

extension Int {
   func topics(summation: () -> ()) {
      for _ in 0..<self {
         summation()
      }
   }
}

4.topics(summation: {
   print("Inside Extensions Block")
})

3.topics(summation: {
   print("Inside Type Casting Block")
})

Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Type Casting Block
Inside Type Casting Block
Inside Type Casting Block

विषय () फ़ंक्शन तर्क का प्रकार लेता है '(सारांश: () → ()) फ़ंक्शन को इंगित करने के लिए कोई तर्क नहीं लेता है और यह किसी भी मान को वापस नहीं करेगा। उस फ़ंक्शन को कई बार कॉल करने के लिए, ब्लॉक के लिए आरंभीकृत किया जाता है और विषय () के साथ विधि पर कॉल किया जाता है।

उत्परिवर्तन के तरीके

एक्सटेंशन के रूप में घोषित किए जाने पर इंस्टेंस के तरीकों को भी म्यूट किया जा सकता है।

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

extension Double {
   mutating func square() {
      let pi = 3.1415
      self = pi * self * self
   }
}

var Trial1 = 3.3
Trial1.square()
print("Area of circle is: \(Trial1)")

var Trial2 = 5.8
Trial2.square()
print("Area of circle is: \(Trial2)")

var Trial3 = 120.3
Trial3.square()
print("Area of circle is: \(Trial3)")

Area of circle is: 34.210935
Area of circle is: 105.68006
Area of circle is: 45464.070735

सबस्क्रिप्ट

एक्सटेंशन के साथ पहले से घोषित उदाहरणों के लिए नई सदस्यता जोड़ना भी संभव हो सकता है।

extension Int {
   subscript(var multtable: Int) -> Int {
      var no1 = 1
      while multtable > 0 {
         no1 *= 10
         --multtable
      }
      return (self / no1) % 10
   }
}

print(12[0])
print(7869[1])
print(786543[2])

2
6
5

नेस्टेड प्रकार

वर्ग, संरचना और गणना उदाहरणों के लिए नस्टेड प्रकारों को एक्सटेंशन की मदद से भी बढ़ाया जा सकता है।

extension Int {
   enum calc {
      case add
      case sub
      case mult
      case div
      case anything
   }
   var print: calc {
      switch self {
         case 0:
            return .add
         case 1:
            return .sub
         case 2:
            return .mult
         case 3:
            return .div
         default:
            return .anything
      }
   }
}

func result(numb: [Int]) {
   for i in numb {
      switch i.print {
         case .add:
            print(" 10 ")
         case .sub:
            print(" 20 ")
         case .mult:
            print(" 30 ")
         case .div:
            print(" 40 ")
         default:
            print(" 50 ")
      }
   }
}
result(numb: [0, 1, 2, 3, 4, 7])

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

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

प्रोटोकॉल भी वर्गों, संरचनाओं और गणना के समान सिंटैक्स का पालन करते हैं -

protocol SomeProtocol {
   // protocol definition 
}

प्रोटोकॉल वर्ग, संरचना या गणना प्रकार नामों के बाद घोषित किए जाते हैं। एकल और एकाधिक प्रोटोकॉल घोषणाएं भी संभव हैं। यदि कई प्रोटोकॉल परिभाषित हैं, तो उन्हें अल्पविराम द्वारा अलग किया जाना है।

struct SomeStructure: Protocol1, Protocol2 {
   // structure definition 
}

जब किसी प्रोटोकॉल को सुपर क्लास के लिए परिभाषित किया जाना है, तो प्रोटोकॉल नाम सुपर क्लास के नाम को अल्पविराम के साथ पालन करना चाहिए।

class SomeClass: SomeSuperclass, Protocol1, Protocol2 {
   // class definition 
}

संपत्ति और विधि आवश्यकताएँ

प्रोटोकॉल का उपयोग विशेष वर्ग प्रकार की संपत्ति या उदाहरण संपत्ति को निर्दिष्ट करने के लिए किया जाता है। यह निर्दिष्ट या संकलित संपत्ति के बजाय अकेले प्रकार या उदाहरण संपत्ति निर्दिष्ट करता है चाहे वह एक संग्रहीत या संगणित संपत्ति हो। इसके अलावा, यह निर्दिष्ट करने के लिए उपयोग किया जाता है कि संपत्ति 'गेटेबल' है या 'सेटलेबल' है।

संपत्ति आवश्यकताओं को 'चर' कीवर्ड द्वारा संपत्ति चर के रूप में घोषित किया जाता है। {get set} का उपयोग उनके प्रकार की घोषणा के बाद गेटेबल और सेटल होने योग्य गुणों की घोषणा करने के लिए किया जाता है। गेटटेबल का उल्लेख उनके प्रकार की घोषणा के बाद {get} संपत्ति द्वारा किया जाता है।

protocol classa {
   var marks: Int { get set }
   var result: Bool { get }
   
   func attendance() -> String
   func markssecured() -> String
}

protocol classb: classa {
   var present: Bool { get set }
   var subject: String { get set }
   var stname: String { get set }
}

class classc: classb {
   var marks = 96
   let result = true
   var present = false
   var subject = "Swift 4 Protocols"
   var stname = "Protocols"

   func attendance() -> String {
      return "The \(stname) has secured 99% attendance"
   }
   func markssecured() -> String {
      return "\(stname) has scored \(marks)"
   }
}

let studdet = classc()
studdet.stname = "Swift 4"
studdet.marks = 98
studdet.markssecured()

print(studdet.marks)
print(studdet.result)
print(studdet.present)
print(studdet.subject)
print(studdet.stname)

98
true
false
Swift 4 Protocols
Swift 4

म्यूटिंग मेथड रिक्वायरमेंट्स

protocol daysofaweek {
   mutating func print()
}

enum days: daysofaweek {
   case sun, mon, tue, wed, thurs, fri, sat 
   mutating func print() {
      switch self {
         case sun:
            self = sun
            print("Sunday")
         case mon:
            self = mon
            print("Monday")
         case tue:
            self = tue
            print("Tuesday")
         case wed:
            self = wed
            print("Wednesday")
         case mon:
            self = thurs
            print("Thursday")
         case tue:
            self = fri
            print("Friday")
         case sat:
            self = sat
            print("Saturday")
         default:
            print("NO Such Day")
      }
   }
}

var res = days.wed
res.print()

Wednesday

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

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

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

protocol SomeProtocol {
   init(someParameter: Int)
}

उदाहरण के लिए

protocol tcpprotocol {
   init(aprot: Int)
}

प्रोटोकॉल प्रारंभिक आवश्यकताओं के वर्ग कार्यान्वयन

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

class SomeClass: SomeProtocol {
   required init(someParameter: Int) {
      // initializer implementation statements
   }
}

protocol tcpprotocol {
   init(aprot: Int)
}

class tcpClass: tcpprotocol {
   required init(aprot: Int) {
   }
}

प्रोटोकॉल की पुष्टि 'आवश्यक' संशोधक द्वारा स्पष्ट या विरासत में दिए गए कार्यान्वयन के लिए सभी उपवर्गों पर सुनिश्चित की जाती है।

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

protocol tcpprotocol {
   init(no1: Int)
}

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

प्रकार के रूप में प्रोटोकॉल

एक प्रोटोकॉल में कार्यक्षमताओं को लागू करने के बजाय उनका उपयोग कार्यों, वर्गों, विधियों आदि के लिए किया जाता है।

प्रोटोकॉल को निम्न प्रकार से एक्सेस किया जा सकता है -

फ़ंक्शन, विधि या पैरामीटर या रिटर्न प्रकार के रूप में आरंभ करें
लगातार, चर या संपत्ति
आइटम के रूप में ऐरे, शब्दकोश या अन्य कंटेनर

protocol Generator {
   typealias members
   func next() -> members?
}

var items = [10,20,30].generate()
while let x = items.next() {
   print(x)
}

for lists in map([1,2,3], {i in i*5}) {
   print(lists)
}

print([100,200,300])
print(map([1,2,3], {i in i*10}))

10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]

एक एक्सटेंशन के साथ प्रोटोकॉल अनुरूपता जोड़ना

एक्सटेंशन का उपयोग करके मौजूदा प्रकार को अपनाया जा सकता है और नए प्रोटोकॉल के अनुरूप बनाया जा सकता है। नई संपत्तियों, विधियों और सदस्यता को एक्सटेंशन की मदद से मौजूदा प्रकारों में जोड़ा जा सकता है।

protocol AgeClasificationProtocol {
   var age: Int { get }
   func agetype() -> String
}
class Person {
   let firstname: String
   let lastname: String
   var age: Int
   
   init(firstname: String, lastname: String) {
      self.firstname = firstname
      self.lastname = lastname
      self.age = 10
   }
}

extension Person : AgeClasificationProtocol {
   func fullname() -> String {
      var c: String
      c = firstname + " " + lastname
      return c
   }
   func agetype() -> String {
      switch age {
         case 0...2:
            return "Baby"
         case 2...12:
            return "Child"
         case 13...19:
            return "Teenager"
         case let x where x > 65:
            return "Elderly"
         default:
            return "Normal"
      }
   }
}

प्रोटोकॉल वंशानुक्रम

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

protocol classa {
   var no1: Int { get set }
   func calc(sum: Int)
}
protocol result {
   func print(target: classa)
}
class student2: result {
   func print(target: classa) {
      target.calc(sum: 1)
   }
}
class classb: result {
   func print(target: classa) {
      target.calc(sum: 5)
   }
}

class student: classa {
   var no1: Int = 10
   
   func calc(sum: Int) {
      no1 -= sum
      print("Student attempted \(sum) times to pass")
         
      if no1 <= 0 {
         print("Student is absent for exam")
      }
   }
}

class Player {
   var stmark: result!

   init(stmark: result) {
      self.stmark = stmark
   }
   func print(target: classa) {
      stmark.print(target: target)
   }
}

var marks = Player(stmark: student2())
var marksec = student()

marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)
marks.stmark = classb()
marks.print(target: marksec)
marks.print(target: marksec)
marks.print(target: marksec)

Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 5 times to pass
Student attempted 5 times to pass
Student is absent for exam
Student attempted 5 times to pass
Student is absent for exam

केवल कक्षा प्रोटोकॉल

जब प्रोटोकॉल परिभाषित किए जाते हैं और उपयोगकर्ता प्रोटोकॉल को परिभाषित करना चाहता है, तो इसे प्रोटोकॉल की विरासत सूची के बाद वर्ग को परिभाषित करके जोड़ा जाना चाहिए।

protocol tcpprotocol {
   init(no1: Int)
}
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 कई प्रोटोकॉल प्रोटोकॉल संरचना की मदद से एक बार में कॉल करने की अनुमति देता है।

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

protocol<SomeProtocol, AnotherProtocol>

उदाहरण

protocol stname {
   var name: String { get }
}
protocol stage {
   var age: Int { get }
}
struct Person: stname, stage {
   var name: String
   var age: Int
}
func print(celebrator: stname & stage) {
   print("\(celebrator.name) is \(celebrator.age) years old")
}
let studname = Person(name: "Priya", age: 21)
print(studname)

let stud = Person(name: "Rehan", age: 29)
print(stud)

let student = Person(name: "Roshan", age: 19)
print(student)

Person(name: "Priya", age: 21)
Person(name: "Rehan", age: 29)
Person(name: "Roshan", age: 19)

प्रोटोकॉल अनुरूपता के लिए जाँच

प्रोटोकॉल अनुरूपता का परीक्षण 'के रूप में' और 'प्रकार के कास्टिंग के समान' ऑपरेटरों के रूप में किया जाता है।

यदि कोई उदाहरण प्रोटोकॉल मानक के अनुरूप है और विफल होने पर वापस लौटता है तो ऑपरेटर सही है।
as? डाउनकास्ट ऑपरेटर का संस्करण प्रोटोकॉल के प्रकार का एक वैकल्पिक मान लौटाता है, और यह मान शून्य है यदि उदाहरण उस प्रोटोकॉल के अनुरूप नहीं है।
डाउनकास्ट ऑपरेटर के संस्करण के रूप में डाउनकास्ट प्रोटोकॉल प्रकार के लिए मजबूर करता है और डाउनटाइम सफल नहीं होने पर रनटाइम त्रुटि को ट्रिगर करता है।

import Foundation

@objc protocol rectangle {
   var area: Double { get }
}
@objc class Circle: rectangle {
   let pi = 3.1415927
   var radius: Double
   var area: Double { return pi * radius * radius }
   init(radius: Double) { self.radius = radius }
}
@objc class result: rectangle {
   var area: Double
   init(area: Double) { self.area = area }
}
class sides {
   var rectsides: Int
   init(rectsides: Int) { self.rectsides = rectsides }
}
let objects: [AnyObject] = [Circle(radius: 2.0),result(area:198),sides(rectsides: 4)]

for object in objects {
   if let objectWithArea = object as? rectangle {
      print("Area is \(objectWithArea.area)")
   } else {
      print("Rectangle area is not defined")
   }
}

Area is 12.5663708
Area is 198.0
Rectangle area is not defined

स्विफ्ट 4 भाषा लचीली और पुन: प्रयोज्य कार्यों और प्रकारों को लिखने के लिए 'जेनेरिक' सुविधाएँ प्रदान करती है। नकल से बचने और अमूर्तता प्रदान करने के लिए जेनरिक का उपयोग किया जाता है। स्विफ्ट 4 मानक पुस्तकालय जेनरिक कोड के साथ बनाए गए हैं। स्विफ्ट 4s 'Arrays' और 'Dictionary' प्रकार जेनेरिक संग्रह से संबंधित हैं। सरणियों और शब्दकोशों की सहायता से सरणियों को 'इंट' मान और 'स्ट्रिंग' मान या किसी अन्य प्रकार के धारण करने के लिए परिभाषित किया गया है।

func exchange(a: inout Int, b: inout Int) {
   let temp = a
   a = b
   b = temp
}

var numb1 = 100
var numb2 = 200

print("Before Swapping values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping values are: \(numb1) and \(numb2)")

Before Swapping values are: 100 and 200
After Swapping values are: 200 and 100

सामान्य कार्य: प्रकार पैरामीटर

जेनेरिक फ़ंक्शंस का उपयोग किसी भी डेटा प्रकार जैसे 'इंट' या 'स्ट्रिंग' तक पहुंचने के लिए किया जा सकता है।

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

फ़ंक्शन एक्सचेंज () का उपयोग उन मूल्यों को स्वैप करने के लिए किया जाता है जो उपरोक्त कार्यक्रम में वर्णित हैं और <T> का उपयोग एक प्रकार के पैरामीटर के रूप में किया जाता है। पहली बार, फ़ंक्शन एक्सचेंज () को 'Int' मानों को वापस करने के लिए कहा जाता है और फ़ंक्शन एक्सचेंज को दूसरी कॉल () मानों को 'String' लौटाएगा। अल्पविराम द्वारा अलग किए गए कोण कोष्ठक के अंदर कई पैरामीटर प्रकार शामिल किए जा सकते हैं।

टाइप पैरामीटर को उस प्रकार के पैरामीटर के उद्देश्य को जानने के लिए परिभाषित उपयोगकर्ता के रूप में नामित किया जाता है। स्विफ्ट 4 सामान्य प्रकार के पैरामीटर नाम के रूप में <T> प्रदान करता है। हालाँकि, Arrays और D शब्दकोशों जैसे प्रकार के मापदंडों को भी कुंजी के रूप में नामित किया जा सकता है, यह पहचानने के लिए कि वे 'Dictionary' टाइप के हैं।

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]

एक सामान्य प्रकार का विस्तार

आइटम के शीर्ष को जानने के लिए स्टैक गुण का विस्तार करना 'एक्सटेंशन' कीवर्ड के साथ शामिल है।

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)

extension TOS {
   var first: T? {
      return items.isEmpty ? nil : items[items.count - 1]
   }
}
if let first = tos.first {
   print("The top item on the stack is \(first).")
}

["Swift 4"]
["Swift 4", "Generics"]
["Swift 4", "Generics", "Type Parameters"]
["Swift 4", "Generics", "Type Parameters", "Naming Type Parameters"]
The top item on the stack is Naming Type Parameters.

अड़चनें टाइप करें

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

func exchange<T>(a: inout T, b: inout T) {
   let temp = a
   a = b
   b = temp
}
var numb1 = 100
var numb2 = 200

print("Before Swapping Int values are: \(numb1) and \(numb2)")
exchange(a: &numb1, b: &numb2)
print("After Swapping Int values are: \(numb1) and \(numb2)")

var str1 = "Generics"
var str2 = "Functions"

print("Before Swapping String values are: \(str1) and \(str2)")
exchange(a: &str1, b: &str2)
print("After Swapping String values are: \(str1) and \(str2)")

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

संबद्ध प्रकार

स्विफ्ट 4 संबंधित प्रकारों को 'संबद्धता' कीवर्ड द्वारा प्रोटोकॉल परिभाषा के अंदर घोषित करने की अनुमति देता है।

protocol Container {
   associatedtype ItemType
   mutating func append(item: ItemType)
   var count: Int { get }
   subscript(i: Int) -> ItemType { get }
}
struct TOS<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]
   }
}
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)

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

जहां क्लॉस है

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

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 भाषा द्वारा तीन अलग-अलग पहुंच स्तर प्रदान किए जाते हैं। वे सार्वजनिक, आंतरिक और निजी पहुंच वाले हैं।

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 भाषा में गणना स्वचालित रूप से एक एन्यूमरेशन के अलग-अलग मामलों के लिए समान पहुंच स्तर प्राप्त करती है। उदाहरण के लिए विचार करें कि छात्रों के नाम और तीन विषयों में प्राप्त अंकों तक पहुँचने के लिए गणना नाम को छात्र के रूप में घोषित किया गया है और एनुम वर्ग में उपस्थित सदस्यों का नाम है जो स्ट्रिंग डेटाटाइप के हैं, अंक 1, मार्क 2 और डेटैट इंटेगर के मार्क 3 के रूप में दर्शाए जाते हैं। छात्र के नाम या अंकों तक पहुँचने के लिए उन्होंने स्कोर किया है। अब, स्विच केस छात्र के नाम को प्रिंट करेगा यदि उस मामले को निष्पादित किया जाता है अन्यथा यह छात्र द्वारा सुरक्षित किए गए अंकों को प्रिंट करेगा। यदि दोनों स्थिति विफल होती है, तो डिफ़ॉल्ट ब्लॉक निष्पादित किया जाएगा।

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 के पास कस्टमाइज़ करने के लिए बहुत सारे विकल्प हैं कि वे कैसे काम करते हैं।