ऐरे Swift के तीन मुख्य कलेक्शन टाइप में से एक हैं। ऐरे एलिमेंट की एक क्रमबद्ध सूची होता है। ऐरे किसी भी टाइप के एलिमेंट रख सकते हैं, लेकिन एक ऐरे के सारे एलिमेंट एक ही टाइप के होने चाहिए। जब किसी ऐरे को किसी वेरिएबल को असाइन किया जाता है, तो वह परिवर्तनशील होता है। इसका मतलब है कि ऐरे बनाने के बाद आप उसमें एलिमेंट जोड़ सकते हैं, हटा सकते हैं या बदल सकते हैं। जब किसी ऐरे को किसी कॉन्स्टेंट को असाइन किया जाता है, तो वह अपरिवर्तनीय हो जाता है, यानी उसके अंदर के एलिमेंट बदले नहीं जा सकते।
ऐरे लिटरल को चौकोर ब्रैकेट ([...]) के अंदर अल्पविराम से अलग किए गए एलिमेंट की सूची के रूप में लिखा जाता है।
Swift लिटरल के अंदर मौजूद एलिमेंट से ऐरे का टाइप खुद ही अनुमान लगा लेता है।
let evenInts = [2, 4, 6, 8, 10, 12]
var oddInts = [1, 3, 5, 7, 9, 11, 13]
let greetings = ["Hello!", "Hi!", "¡Hola!"]
आप टाइप को स्पष्ट रूप से भी लिख सकते हैं।
ऐरे के टाइप दो तरह से लिखे जा सकते हैं: Array<T> या संक्षिप्त सिंटैक्स [T]। यहाँ T उस टाइप को दर्शाता है जिसके वैल्यू ऐरे में होते हैं।
let evenInts: Array<Int> = [2, 4, 6, 8, 10, 12]
var oddInts: [Int] = [1, 3, 5, 7, 9, 11, 13]
let greetings: [String] = ["Hello!", "Hi!", "¡Hola!"]
आप ऐरे के count प्रॉपर्टी की मदद से उसमें मौजूद एलिमेंट की संख्या पता कर सकते हैं:
evenInts.count
// returns 6
खाली ऐरे बनाने के लिए आपको उसका टाइप बताना होगा। यह आप ऐरे इनिशियलाइज़र सिंटैक्स या स्पष्ट टाइप एनोटेशन की मदद से कर सकते हैं:
let emptyArray = [Int]()
let emptyArray2 = Array<Int>()
let emptyArray3: [Int] = []
ऐरे को नेस्ट करके मल्टी-डाइमेंशनल ऐरे बनाए जा सकते हैं।
नेस्टेड ऐरे का टाइप स्पष्ट रूप से बताते समय एलिमेंट के टाइप को नेस्टेड ब्रैकेट में लपेटिए, जैसे [[Int]] या Array<Array<Int>>:
let multiDimArray = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
let multiDimArray2: [[Int]] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
आप append(_:) मेथड की मदद से किसी परिवर्तनशील ऐरे के अंत में एक एलिमेंट जोड़ सकते हैं:
var oddInts = [1, 3, 5, 7, 9, 11, 13]
oddInts.append(15)
// oddInts is now [1, 3, 5, 7, 9, 11, 13, 15]
आप insert(_:at:) मेथड की मदद से किसी खास इंडेक्स पर एक एलिमेंट डाल सकते हैं।
यह मेथड दो आर्गुमेंट लेता है: डाला जाने वाला एलिमेंट, और वह इंडेक्स जहाँ उसे डालना है।
var oddInts = [1, 3, 5, 7, 9, 11, 13]
oddInts.insert(0, at: 0)
// oddInts is now [0, 1, 3, 5, 7, 9, 11, 13]
आप + ऑपरेटर की मदद से दो ऐरे को मिलाकर एक ऐरे बना सकते हैं।
+ ऑपरेटर एक नया ऐरे बनाकर लौटाता है; यह मूल ऐरे को नहीं बदलता।
var oddInts = [1, 3, 5, 7, 9, 11, 13]
let combined = oddInts + [15, 17, 19]
// combined is [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
print(oddInts)
// prints [1, 3, 5, 7, 9, 11, 13]
ऐरे के नाम के बाद चौकोर ब्रैकेट ([]) में उसका इंडेक्स रखकर आप ऐरे के किसी एक एलिमेंट को एक्सेस कर सकते हैं।
ऐरे के इंडेक्स Int वैल्यू होती हैं जो शून्य से गिनी जाती हैं, यानी पहले एलिमेंट का इंडेक्स 0 होता है।
मान्य सीमा से बाहर का इंडेक्स एक्सेस करने पर रनटाइम एरर मिलती है और प्रोग्राम क्रैश हो जाता है।
let evenInts = [2, 4, 6, 8, 10, 12]
let oddInts = [1, 3, 5, 7, 9, 11, 13]
evenInts[2]
// returns 6
oddInts[7]
// Fatal error: Index out of range
किसी खास इंडेक्स पर नई वैल्यू असाइन करके आप परिवर्तनशील ऐरे के किसी एलिमेंट को बदल सकते हैं। एलिमेंट पढ़ने की तरह ही, मान्य सीमा से बाहर का इंडेक्स इस्तेमाल करने पर रनटाइम एरर मिलती है।
var evenInts = [2, 4, 6, 8, 10, 12]
evenInts[2] = 0
// evenInts is now [2, 4, 0, 8, 10, 12]
आप joined(separator:) मेथड की मदद से स्ट्रिंग के ऐरे को जोड़कर एक स्ट्रिंग बना सकते हैं। यह मेथड एक सिपरेटर स्ट्रिंग लेता है:
let evenInts = ["2", "4", "6", "8", "10", "12"]
let evenIntsString = evenInts.joined(separator: ", ")
// returns "2, 4, 6, 8, 10, 12"
आप split(separator:) मेथड की मदद से एक स्ट्रिंग को सबस्ट्रिंग के ऐरे में तोड़ सकते हैं। इसमें आप डेलिमिटर अक्षर देते हैं:
let evenIntsString = "2, 4, 6, 8, 10, 12"
let evenInts = evenIntsString.split(separator: ",")
// returns ["2", " 4", " 6", " 8", " 10", " 12"]
आप remove(at:) मेथड की मदद से किसी दिए गए इंडेक्स पर मौजूद एलिमेंट हटा सकते हैं।
इंडेक्स ऐरे की मान्य सीमा के अंदर ही होना चाहिए; वरना रनटाइम एरर मिलती है।
var oddInts = [1, 3, 5, 7, 9, 11, 13]
oddInts.remove(at: 3)
// oddInts is now [1, 3, 5, 9, 11, 13]
ऐरे का अंतिम एलिमेंट हटाने के लिए removeLast() मेथड इस्तेमाल कीजिए।
खाली ऐरे पर removeLast() कॉल करने से रनटाइम एरर मिलती है।
var oddInts = [1, 3, 5, 7, 9, 11, 13]
oddInts.removeLast()
// oddInts is now [1, 3, 5, 7, 9, 11]
जादूगर बनने की तैयारी कर रही Elyse को कुछ बुनियादी बातों का अभ्यास करना है। उसके पास कार्डों का एक ढेर है, जिसे वह अपने तरीके से बदलना चाहती है।
चीज़ें थोड़ी आसान बनाने के लिए वह सिर्फ 1 से 10 तक के कार्ड इस्तेमाल करती है, ताकि उसके कार्डों के ढेर को संख्याओं के एक ऐरे से दर्शाया जा सके। किसी कार्ड की जगह ऐरे के इंडेक्स से मेल खाती है। यानी जगह 0 पहले कार्ड को दिखाती है, जगह 1 दूसरे कार्ड को, और इसी तरह आगे भी।
सभी फंक्शन को कार्डों के ऐरे को अपडेट करना चाहिए और फिर बदले हुए ऐरे को लौटाना चाहिए। यह काम करने का एक आम तरीका है, जिसे बिल्डर पैटर्न कहते हैं, और इससे आप फंक्शनों को एक के बाद एक अच्छे से जोड़ सकते हैं।
कार्ड उठाने के लिए दिए गए ढेर में position इंडेक्स पर मौजूद कार्ड लौटाइए।
फंक्शन getCard(at:from:) बनाइए, जो दो आर्गुमेंट लेता है: at, यानी ढेर में कार्ड की जगह, और from, यानी कार्डों का ढेर।
फंक्शन को दिए गए ढेर में index जगह पर मौजूद कार्ड लौटाना चाहिए।
let index = 2
getCard(at: index, from: [1, 2, 4, 1])
// returns 4
थोड़ा जादू दिखाइए और दिए गए नए कार्ड से position इंडेक्स पर रखे कार्ड को बदल दीजिए।
फंक्शन setCard(at:in:to) बनाइए, जो तीन आर्गुमेंट लेता है: at, यानी ढेर में कार्ड की जगह; in, यानी कार्डों का ढेर; और to, यानी वह नया कार्ड जो index जगह वाले कार्ड की जगह लेगा।
फंक्शन को ढेर की एक कॉपी लौटानी चाहिए, जिसमें index जगह वाला कार्ड नए कार्ड से बदला हुआ हो।
अगर दिया गया index ढेर में मान्य इंडेक्स नहीं है, तो मूल ढेर बिना बदले लौटाया जाना चाहिए।
let index = 2
let newCard = 6
setCard(at: index, in: [1, 2, 4, 1], to: newCard)
// returns [1, 2, 6, 1]
ढेर के सबसे ऊपर एक नया कार्ड डालकर एक कार्ड प्रकट कीजिए।
फंक्शन insert(_:atTopOf:) बनाइए, जो दो आर्गुमेंट लेता है: नया कार्ड जिसे डालना है, और कार्डों का ढेर।
फंक्शन को ढेर की एक कॉपी लौटानी चाहिए, जिसमें दिया गया नया कार्ड ढेर के सबसे ऊपर जोड़ा हुआ हो।
let newCard = 8
insert(newCard, atTopOf: [5, 9, 7, 1])
// returns [5, 9, 7, 1, 8]
दिए गए position पर मौजूद कार्ड को ढेर से हटाकर एक कार्ड गायब कीजिए।
फंक्शन removeCard(at:from:) बनाइए, जो दो आर्गुमेंट लेता है: at, यानी ढेर में कार्ड की जगह, और from, यानी कार्डों का ढेर।
फंक्शन को ढेर की एक कॉपी लौटानी चाहिए, जिसमें से index जगह वाला कार्ड हटा हुआ हो।
अगर दिया गया index ढेर में मान्य इंडेक्स नहीं है, तो मूल ढेर बिना बदले लौटाया जाना चाहिए।
let index = 2
removeCard(at: index, from: [3, 2, 6, 4, 8])
// returns [3, 2, 4, 8]
ढेर में दी गई position जगह पर नया कार्ड डालकर एक कार्ड प्रकट कीजिए।
फंक्शन insert(_:at:from:) बनाइए, जो तीन आर्गुमेंट लेता है: नया कार्ड जिसे डालना है, वह जगह जहाँ नया कार्ड डालना है, और कार्डों का ढेर।
फंक्शन को ढेर की एक कॉपी लौटानी चाहिए, जिसमें दिया गया नया कार्ड दी गई जगह पर जोड़ा हुआ हो।
अगर दिया गया index ढेर में मान्य इंडेक्स नहीं है, तो मूल ढेर बिना बदले लौटाया जाना चाहिए।
let newCard = 8
insert(newCard, at: 2, from: [5, 9, 7, 1])
// returns [5, 9, 8, 7, 1]
जाँचिए कि ढेर का आकार stackSize के बराबर है या नहीं।
फंक्शन checkSizeOfStack(_:_:) बनाइए, जो दो आर्गुमेंट लेता है: stack, यानी कार्डों का ढेर, और stackSize, यानी ढेर का आकार।
फंक्शन को true लौटाना चाहिए अगर ढेर का आकार stackSize के बराबर है, और बाकी मामलों में false लौटाना चाहिए।
let stackSize = 4
checkSizeOfStack([3, 2, 6, 4, 8], stackSize)
// returns false
Exercism पर साइन अप कीजिए और Swift को 35 कॉन्सेप्ट116 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।