Swift Language
Arrays

परिचय

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

• सरणी <तत्व> // प्रकार के तत्वों के साथ एक सरणी का प्रकार
• [तत्व] // टाइप एलीमेंट के तत्वों के साथ एक सरणी के प्रकार के लिए सिंथेटिक चीनी
• [element0, element1, element2, ... elementN] // एक सरणी शाब्दिक
• [तत्व] () // प्रकार का एक नया खाली सरणी बनाता है [तत्व]
• सरणी (गिनती: repeatedValue :) // की एक सरणी बनाता है count तत्वों, प्रत्येक के लिए शुरू repeatedValue
• सरणी (_ :) // एक मनमाना अनुक्रम से एक सरणी बनाता है

टिप्पणियों

मूल्य शब्दार्थ

एक सरणी की प्रतिलिपि बनाना मूल सरणी के अंदर सभी आइटम की प्रतिलिपि बनाएगा।

नए सरणी को बदलने से मूल सरणी नहीं बदलेगी ।

var originalArray = ["Swift", "is", "great!"]
var newArray = originalArray
newArray[2] = "awesome!"
//originalArray = ["Swift", "is", "great!"]
//newArray = ["Swift", "is", "awesome!"]

कॉपी किए गए सरणियों को स्मृति में उसी स्थान को साझा किया जाएगा जब तक कि वे बदले नहीं जाते। इसके परिणामस्वरूप एक प्रदर्शन हिट होता है जब कॉपी की गई सरणी को मेमोरी में अपना स्थान दिया जाता है क्योंकि यह पहली बार बदल जाता है।

मूल बातें

Array स्विफ्ट मानक लाइब्रेरी में एक ऑर्डर किया गया संग्रह प्रकार है। यह O (1) रैंडम एक्सेस और डायनेमिक रीअलोकेशन प्रदान करता है। ऐरे एक सामान्य प्रकार है , इसलिए इसमें जिस प्रकार के मूल्य होते हैं उन्हें संकलन समय पर जाना जाता है।

जैसा कि Array एक मूल्य प्रकार है , इसकी उत्परिवर्तन को परिभाषित किया जाता है कि क्या इसे एक var (म्यूटेबल) या let (अपरिवर्तनीय) के रूप में एनोटेट किया गया है।

प्रकार [Int] (अर्थ: Int एस युक्त एक सरणी) Array<T> लिए सिंथेटिक चीनी है ।

द स्विफ्ट प्रोग्रामिंग लैंग्वेज में सरणियों के बारे में और पढ़ें।

खाली एरे

निम्नलिखित तीन घोषणाएँ बराबर हैं:

// A mutable array of Strings, initially empty.

var arrayOfStrings: [String] = []      // type annotation + array literal
var arrayOfStrings = [String]()        // invoking the [String] initializer
var arrayOfStrings = Array<String>()   // without syntactic sugar

एरे शाब्दिक

एक सरणी शाब्दिक अल्पविराम से अलग तत्वों के साथ चौकोर कोष्ठक के साथ लिखा गया है:

// Create an immutable array of type [Int] containing 2, 4, and 7
let arrayOfInts = [2, 4, 7]

कंपाइलर आमतौर पर शाब्दिक रूप से तत्वों के आधार पर एक सरणी के प्रकार का अनुमान लगा सकता है, लेकिन स्पष्ट प्रकार के एनोटेशन डिफ़ॉल्ट को ओवरराइड कर सकते हैं:

let arrayOfUInt8s: [UInt8] = [2, 4, 7]   // type annotation on the variable
let arrayOfUInt8s = [2, 4, 7] as [UInt8] // type annotation on the initializer expression
let arrayOfUInt8s = [2 as UInt8, 4, 7]   // explicit for one element, inferred for the others

दोहराया मूल्यों के साथ आता है

// An immutable array of type [String], containing ["Example", "Example", "Example"]
let arrayOfStrings = Array(repeating: "Example",count: 3)

अन्य दृश्यों से सरणियाँ बनाना

let dictionary = ["foo" : 4, "bar" : 6]

// An immutable array of type [(String, Int)], containing [("bar", 6), ("foo", 4)]
let arrayOfKeyValuePairs = Array(dictionary)

बहुआयामी सरणियाँ

स्विफ्ट में, नेस्टिंग एरेज़ द्वारा एक बहुआयामी सरणी बनाई जाती है: Int का 2-आयामी सरणी है [[Int]] (या Array<Array<Int>> )।

let array2x3 = [
    [1, 2, 3],
    [4, 5, 6]
]
// array2x3[0][1] is 2, and array2x3[1][2] is 6.

दोहराया मूल्यों के बहुआयामी सरणी बनाने के लिए, सरणी आरंभीकरण की नेस्टेड कॉल का उपयोग करें:

var array3x4x5 = Array(repeating: Array(repeating: Array(repeating: 0,count: 5),count: 4),count: 3)

पहुँच ऐरे मान

निम्न उदाहरण इस सरणी का उपयोग एक्सेस मूल्यों को प्रदर्शित करने के लिए करेंगे

var exampleArray:[Int] = [1,2,3,4,5]
//exampleArray = [1, 2, 3, 4, 5]

किसी ज्ञात इंडेक्स पर एक मान तक पहुँचने के लिए निम्नलिखित सिंटैक्स का उपयोग करें:

let exampleOne = exampleArray[2]
//exampleOne = 3

नोट: इंडेक्स दो का मान Array में तीसरा मान है। Array s एक शून्य आधारित सूचकांक का उपयोग करता है जिसका अर्थ है कि Array में पहला तत्व 0 पर है।

let value0 = exampleArray[0]
let value1 = exampleArray[1]
let value2 = exampleArray[2]
let value3 = exampleArray[3]
let value4 = exampleArray[4]
//value0 = 1
//value1 = 2 
//value2 = 3
//value3 = 4
//value4 = 5

फ़िल्टर का उपयोग करके एक Array सबसेट तक पहुँचें:

var filteredArray = exampleArray.filter({ $0 < 4 })
//filteredArray = [1, 2, 3]

फ़िल्टर में जटिल परिस्थितियाँ हो सकती हैं जैसे केवल संख्याएँ फ़िल्टर करना:

var evenArray = exampleArray.filter({ $0 % 2 == 0 })
//evenArray = [2, 4]

किसी दिए गए मान के सूचकांक को वापस करना भी संभव है, यदि मूल्य नहीं मिला तो nil लौटाता है।

exampleArray.indexOf(3) // Optional(2)

एक Array में पहले, अंतिम, अधिकतम या न्यूनतम मूल्य के लिए विधियां हैं। यदि Array खाली है, तो ये विधियां nil हो जाएंगी।

exampleArray.first // Optional(1)
exampleArray.last // Optional(5)
exampleArray.maxElement() // Optional(5)
exampleArray.minElement() // Optional(1)

उपयोगी तरीके

निर्धारित करें कि क्या कोई सरणी खाली है या उसका आकार लौटाता है

var exampleArray = [1,2,3,4,5]
exampleArray.isEmpty //false
exampleArray.count //5

रिवर्स एरे नोट: परिणाम उस सरणी पर नहीं किया जाता है जिस पर विधि को कॉल किया जाता है और इसे अपने स्वयं के चर में डाल दिया जाना चाहिए।

exampleArray = exampleArray.reverse()
//exampleArray = [9, 8, 7, 6, 5, 3, 2]

किसी सरणी में मानों को संशोधित करना

किसी सरणी पर मानों को जोड़ने के कई तरीके हैं

var exampleArray = [1,2,3,4,5]
exampleArray.append(6)
//exampleArray = [1, 2, 3, 4, 5, 6]
var sixOnwards = [7,8,9,10]
exampleArray += sixOnwards
//exampleArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

और किसी ऐरे से मान निकालें

exampleArray.removeAtIndex(3)
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9, 10]
exampleArray.removeLast()
//exampleArray = [1, 2, 3, 5, 6, 7, 8, 9]
exampleArray.removeFirst()
//exampleArray = [2, 3, 5, 6, 7, 8, 9]

एक छँटाई

var array = [3, 2, 1]

एक नया क्रमबद्ध सरणी बनाना

जैसा कि Array SequenceType अनुरूप है, हम बिल्ट सॉर्ट विधि का उपयोग करके सॉर्ट किए गए तत्वों की एक नई सरणी उत्पन्न कर सकते हैं।

let sorted = array.sort()  // [1, 2, 3]

let sorted = array.sorted()  // [1, 2, 3]

मौजूदा सरणी को जगह में क्रमबद्ध करना

जैसा कि Array MutableCollectionType अनुरूप है, हम इसके तत्वों को जगह में सॉर्ट कर सकते हैं।

array.sortInPlace() // [1, 2, 3]

array.sort() // [1, 2, 3]

नोट: उपरोक्त विधियों का उपयोग करने के लिए, तत्वों को Comparable प्रोटोकॉल के अनुरूप होना चाहिए।

कस्टम क्रम के साथ एक सरणी को क्रमबद्ध करना

तुम भी एक का उपयोग कर एक सरणी सॉर्ट कर सकते हैं बंद जो सरणियों जहां तत्वों होना चाहिए करने के लिए ही सीमित नहीं है - परिभाषित करने के लिए है कि क्या एक तत्व एक और पहले आदेश दिया जाना चाहिए Comparable । उदाहरण के लिए, किसी Landmark लिए Comparable होने का कोई मतलब नहीं है - लेकिन आप अभी भी ऊंचाई या नाम से स्थलों की एक सरणी को सॉर्ट कर सकते हैं।

struct Landmark {
    let name : String
    let metersTall : Int
}

var landmarks = [Landmark(name: "Empire State Building", metersTall: 443),
                 Landmark(name: "Eifell Tower", metersTall: 300),
                 Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sortInPlace {$0.metersTall < $1.metersTall}

print(landmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "The Shard", metersTall: 310), Landmark(name: "Empire State Building", metersTall: 443)]

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sort {$0.name < $1.name}

print(alphabeticalLandmarks) // [Landmark(name: "Eifell Tower", metersTall: 300), Landmark(name: "Empire State Building", metersTall: 443), Landmark(name: "The Shard", metersTall: 310)]

// sort landmarks by height (ascending)
landmarks.sort {$0.metersTall < $1.metersTall}

// create new array of landmarks sorted by name
let alphabeticalLandmarks = landmarks.sorted {$0.name < $1.name}

नोट: स्ट्रिंग तुलना अप्रत्याशित परिणाम दे सकती है यदि तार असंगत हैं, तो स्ट्रिंग्स के एक सरणी को सॉर्ट करना देखें।

नक्शे के साथ एक सरणी के तत्वों को बदलना (_ :)

Array SequenceType अनुरूप होने के कारण, हम (A) throws -> B क्लोजर का उपयोग करके A सरणी को B में बदलने के लिए map(_:) का उपयोग कर सकते हैं।

उदाहरण के लिए, हम इसका उपयोग Int s के एक सरणी को String s के एक सरणी में बदलने के लिए कर सकते हैं, जैसे:

let numbers = [1, 2, 3, 4, 5]
let words = numbers.map { String($0) }
print(words) // ["1", "2", "3", "4", "5"]

map(_:) सरणी के माध्यम से पुनरावृत्ति करेगा, प्रत्येक तत्व को दिए गए बंद को लागू करेगा। उस क्लोजर के परिणाम का उपयोग रूपांतरित तत्वों के साथ एक नई सरणी को पॉप्युलेट करने के लिए किया जाएगा।

चूँकि String में एक आरंभिक होता है जो एक Int प्राप्त करता है हम इस स्पष्ट सिंटैक्स का भी उपयोग कर सकते हैं:

let words = numbers.map(String.init)

एक map(_:) रूपांतर को सरणी के प्रकार को बदलने की आवश्यकता नहीं है - उदाहरण के लिए, इसे Int सरणी दो से गुणा करने के लिए भी इस्तेमाल किया जा सकता है:

let numbers = [1, 2, 3, 4, 5]
let numbersTimes2 = numbers.map {$0 * 2}
print(numbersTimes2) // [2, 4, 6, 8, 10]

फ्लैटपाइप के साथ एक सरणी से दिए गए प्रकार के मानों को निकालना (_ :)

एरे things में Any प्रकार के मूल्य शामिल हैं।

let things: [Any] = [1, "Hello", 2, true, false, "World", 3]

हम किसी दिए गए प्रकार के मान निकाल सकते हैं और उस विशिष्ट प्रकार का एक नया ऐरे बना सकते हैं। मान लें कि हम सभी Int(s) को निकालना चाहते हैं और उन्हें एक सुरक्षित तरीके से Int Array में डालते हैं।

let numbers = things.flatMap { $0 as? Int }

अब numbers को [Int] रूप में परिभाषित किया गया है। flatMap फ़ंक्शन सभी nil तत्वों को छोड़ देता है और इस प्रकार परिणाम में केवल निम्न मान होते हैं:

[1, 2, 3]

एक ऐरे को छानना

आप SequenceType के तत्वों से युक्त एक नया सरणी बनाने के लिए SequenceType पर filter(_:) विधि का उपयोग कर सकते हैं जो किसी दिए गए विधेय को संतुष्ट करते हैं, जिसे एक बंद के रूप में प्रदान किया जा सकता है।

उदाहरण के लिए, [Int] से भी संख्याओं को फ़िल्टर करना:

let numbers = [22, 41, 23, 30]

let evenNumbers = numbers.filter { $0 % 2 == 0 }

print(evenNumbers)  // [22, 30]

एक [Person] छानना, जहाँ उनकी उम्र 30 से कम है:

struct Person {
    var age : Int
}

let people = [Person(age: 22), Person(age: 41), Person(age: 23), Person(age: 30)]

let peopleYoungerThan30 = people.filter { $0.age < 30 }

print(peopleYoungerThan30) // [Person(age: 22), Person(age: 23)]

फ्लैटपाइप के साथ एक सरणी परिवर्तन से शून्य को छानना (_ :)

आप अनुक्रम के तत्वों में एक परिवर्तन लागू करके एक सरणी बनाने के लिए map(_:) लिए एक समान तरीके से flatMap(_:) उपयोग कर सकते हैं।

extension SequenceType {
    public func flatMap<T>(@noescape transform: (Self.Generator.Element) throws -> T?) rethrows -> [T]
}

flatMap(_:) इस संस्करण के साथ अंतर यह है कि यह वैकल्पिक मूल्य T? को वापस करने के लिए ट्रांसफॉर्मेशन क्लोजर की उम्मीद करता है T? प्रत्येक तत्व के लिए। यह तब इन वैकल्पिक मूल्यों में से प्रत्येक को सुरक्षित रूप से खोल देगा, nil छानकर - जिसके परिणामस्वरूप [T] की एक सरणी होगी।

उदाहरण के लिए, अगर आप इस आदेश में बदलने के लिए कर सकते हैं एक [String] में एक [Int] का उपयोग कर Int के failable String प्रारंभकर्ता , जिन तत्वों को नहीं बदला जा सकता को छान:

let strings = ["1", "foo", "3", "4", "bar", "6"]

let numbersThatCanBeConverted = strings.flatMap { Int($0) }

print(numbersThatCanBeConverted) // [1, 3, 4, 6]

आप वैकल्पिक रूप से गैर-वैकल्पिक के एक सरणी में परिवर्तित करने के लिए, flatMap(_:) की क्षमता को nil से फ़िल्टर करने के लिए भी उपयोग कर सकते हैं:

let optionalNumbers : [Int?] = [nil, 1, nil, 2, nil, 3]

let numbers = optionalNumbers.flatMap { $0 }

print(numbers) // [1, 2, 3]

एक श्रेणी के साथ एक सरणी सदस्यता

एक श्रेणी का उपयोग करके एक सरणी से लगातार तत्वों की एक श्रृंखला निकाल सकते हैं।

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let range = 2...4
let slice = words[range] // ["Bonjour", "Welcome", "Hi"]

एक श्रेणी के साथ एक सरणी की सदस्यता एक ArraySlice देता है। यह ऐरे की एक परिकल्पना है।

हमारे उदाहरण में, हमारे पास स्ट्रिंग्स का एक सरणी है, इसलिए हमें ArraySlice<String> वापस मिलता है।

यद्यपि एक ArraySlice CollectionType अनुरूप है और इसे sort , filter आदि के साथ उपयोग किया जा सकता है, लेकिन इसका उद्देश्य दीर्घकालिक भंडारण के लिए नहीं है, बल्कि क्षणिक संगणना के लिए है: जैसे ही आपने इसके साथ काम करना समाप्त कर लिया है, इसे Array में परिवर्तित कर दिया जाना चाहिए।

इसके लिए, Array() इनिशियलाइज़र का उपयोग करें:

let result = Array(slice)

मध्यस्थ चरणों के बिना एक सरल उदाहरण में योग करने के लिए:

let words = ["Hey", "Hello", "Bonjour", "Welcome", "Hi", "Hola"]
let selectedWords = Array(words[2...4]) // ["Bonjour", "Welcome", "Hi"]

ऐरे मूल्यों का समूह

यदि हमारे पास इस तरह की एक संरचना है

struct Box {
    let name: String
    let thingsInside: Int
}

और Box(es) की एक सरणी Box(es)

let boxes = [
    Box(name: "Box 0", thingsInside: 1),
    Box(name: "Box 1", thingsInside: 2),
    Box(name: "Box 2", thingsInside: 3),
    Box(name: "Box 3", thingsInside: 1),
    Box(name: "Box 4", thingsInside: 2),
    Box(name: "Box 5", thingsInside: 3),
    Box(name: "Box 6", thingsInside: 1)
]

हम कर सकते हैं समूह द्वारा बक्से thingsInside आदेश में एक पाने के लिए संपत्ति Dictionary जहां key चीजों की संख्या है और मूल्य बक्से की एक सरणी है।

let grouped = boxes.reduce([Int:[Box]]()) { (res, box) -> [Int:[Box]] in
    var res = res
    res[box.thingsInside] = (res[box.thingsInside] ?? []) + [box]
    return res
}

अब समूहीकृत एक [Int:[Box]] और इसमें निम्नलिखित सामग्री है

[
    2: [Box(name: "Box 1", thingsInside: 2), Box(name: "Box 4", thingsInside: 2)], 
    3: [Box(name: "Box 2", thingsInside: 3), Box(name: "Box 5", thingsInside: 3)],
    1: [Box(name: "Box 0", thingsInside: 1), Box(name: "Box 3", thingsInside: 1), Box(name: "Box 6", thingsInside: 1)]
]

फ्लैटपाइप के साथ एक सरणी परिवर्तन के परिणाम को समतल करना (_ :)

अनुक्रम के रूपांतरित तत्वों से nil को फ़िल्टर करके एक सरणी बनाने में सक्षम होने के साथ-साथ, flatMap(_:) का एक संस्करण भी है flatMap(_:) जो अनुक्रम S को वापस करने के लिए परिवर्तन बंद होने की उम्मीद करता है।

extension SequenceType {
    public func flatMap<S : SequenceType>(transform: (Self.Generator.Element) throws -> S) rethrows -> [S.Generator.Element]
}

परिवर्तन से प्रत्येक क्रम को समाप्‍त किया जाएगा, जिसके परिणामस्वरूप एक सरणी में प्रत्येक अनुक्रम के संयुक्त तत्व होंगे - [S.Generator.Element] ।

तार की एक सरणी में वर्णों का मेल

उदाहरण के लिए, हम इसका उपयोग प्रधान स्ट्रिंग्स की एक सरणी लेने और उनके पात्रों को एक एकल सरणी में संयोजित करने के लिए कर सकते हैं:

let primes = ["2", "3", "5", "7", "11", "13", "17", "19"]
let allCharacters = primes.flatMap { $0.characters }
// => "["2", "3", "5", "7", "1", "1", "1", "3", "1", "7", "1", "9"]"

उपरोक्त उदाहरण को तोड़ना:

1. primes एक [String] (जैसा कि एक सरणी एक अनुक्रम है, हम flatMap(_:) को उस पर कॉल कर सकते हैं)।
2. परिवर्तन बंद के तत्वों में से एक में ले जाता है primes , एक String ( Array<String>.Generator.Element )।
3. बंद करने के बाद String.CharacterView प्रकार का एक क्रम देता है।
4. फिर परिणाम एक सरणी है जिसमें परिवर्तन क्लोजर कॉल में से प्रत्येक से सभी अनुक्रमों के संयुक्त तत्व होते हैं - [String.CharacterView.Generator.Element] ।

एक बहुआयामी सरणी को समतल करना

जैसा कि flatMap(_:) रूपांतरण क्लोजर कॉल से लौटे दृश्यों को समाप्‍त कर देगा, इसका उपयोग बहुआयामी सरणी को समतल करने के लिए किया जा सकता है - जैसे कि 2 डी सरणी 1 डी सरणी में, 3 डी सरणी 2 डी सरणी में आदि।

यह बस दिए गए तत्व को $0 (एक नेस्टेड एरे) को बंद करके वापस किया जा सकता है:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A 1D array of type [Int]
let flattenedArray = array2D.flatMap { $0 }

print(flattenedArray) // [1, 3, 4, 6, 8, 10, 11]

स्ट्रिंग्स की एक सरणी छँटाई

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted()
print(sortedWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

var mutableWords = ["Hello", "Bonjour", "Salute", "Ahola"]
mutableWords.sort()
print(mutableWords) // ["Ahola", "Bonjour", "Hello", "Salute"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted(isOrderedBefore: { $0 > $1 })
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "Bonjour", "Salute", "Ahola"]
let sortedWords = words.sorted() { $0 > $1 }
print(sortedWords) // ["Salute", "Hello", "Bonjour", "Ahola"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let unexpected = words.sorted()
print(unexpected) // ["Hello", "Salute", "ahola", "bonjour"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.lowercased() < $1.lowercased() }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let words = ["Hello", "bonjour", "Salute", "ahola"]
let sortedWords = words.sorted { $0.caseInsensitiveCompare($1) == .orderedAscending }
print(sortedWords) // ["ahola", "bonjour", "Hello", "Salute"]

let files = ["File-42.txt", "File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt"]
let sortedFiles = files.sorted() { $0.compare($1, options: .numeric) == .orderedAscending }
print(sortedFiles) // ["File-01.txt", "File-5.txt", "File-007.txt", "File-10.txt", "File-42.txt"]

आलसी के साथ एक बहुआयामी ऐरे को स्पष्ट रूप से समतल करना ()

हम एक बहु-आयामी अनुक्रम के घोंसले को कम करने के लिए चपटे flatten() उपयोग कर सकते हैं।

उदाहरण के लिए, आलसी एक 2D सरणी को 1D सरणी में समतल करता है:

// A 2D array of type [[Int]]
let array2D = [[1, 3], [4], [6, 8, 10], [11]]

// A FlattenBidirectionalCollection<[[Int]]>
let lazilyFlattenedArray = array2D.flatten()

print(lazilyFlattenedArray.contains(4)) // true

ऊपर के उदाहरण में, flatten() एक FlattenBidirectionalCollection , जो कि सरणी के FlattenBidirectionalCollection को आलसी रूप से लागू करेगा। इसलिए contains(_:) केवल array2D के पहले दो नेस्टेड सरणियों को array2D करने की आवश्यकता होगी - जैसा कि वांछित तत्व खोजने पर शॉर्ट-सर्किट होगा।

कम करने के साथ एक सरणी के तत्वों का संयोजन (_: गठबंधन :)

reduce(_:combine:) का उपयोग किसी अनुक्रम के तत्वों को एक मान में संयोजित करने के लिए किया जा सकता है। यह परिणाम के लिए एक प्रारंभिक मूल्य लेता है, साथ ही साथ प्रत्येक तत्व पर लागू करने के लिए एक बंद होता है - जो नए संचित मूल्य को वापस कर देगा।

उदाहरण के लिए, हम इसका उपयोग संख्याओं की एक संख्या को योग करने के लिए कर सकते हैं:

let numbers = [2, 5, 7, 8, 10, 4]

let sum = numbers.reduce(0) {accumulator, element in
    return accumulator + element
}

print(sum) // 36

हम प्रारंभिक मूल्य में 0 से गुजर रहे हैं, क्योंकि यह एक योग के लिए तार्किक प्रारंभिक मूल्य है। यदि हम N मान से गुजरते हैं, तो परिणामी sum N + 36 । reduce करने के reduce पारित बंद reduce के दो तर्क हैं। accumulator वर्तमान संचित मूल्य है, जिसे वह मान असाइन किया जाता है जो प्रत्येक पुनरावृत्ति पर बंद होता है। element पुनरावृत्ति में वर्तमान तत्व है।

इस उदाहरण के अनुसार, हम एक (Int, Int) -> Int को reduce करने के लिए पास reduce , जो कि केवल दो इनपुट के अतिरिक्त आउटपुट कर रहा है - हम वास्तव में + ऑपरेटर से सीधे गुजर सकते हैं, क्योंकि ऑपरेटर स्विफ्ट में कार्य कर रहे हैं:

let sum = numbers.reduce(0, combine: +)

बिना इंडेक्स को जाने एरे से एलीमेंट को हटाना

आमतौर पर, अगर हम किसी एलीमेंट से एलीमेंट को हटाना चाहते हैं, तो हमें यह पता होना चाहिए कि यह इंडेक्स है ताकि हम इसे remove(at:) फंक्शन remove(at:) आसानी से हटा सकें।

लेकिन क्या होगा अगर हम इंडेक्स को नहीं जानते हैं लेकिन हम जानते हैं कि निकाले जाने वाले तत्व का मूल्य क्या है!

तो यहाँ एक सरणी के लिए सरल विस्तार है जो हमें सूचकांक को जाने बिना आसानी से एक तत्व को निकालने की अनुमति देगा:

Swift3

extension Array where Element: Equatable {

    mutating func remove(_ element: Element) {
        _ = index(of: element).flatMap {
            self.remove(at: $0)
        }
    }
}

जैसे

    var array = ["abc", "lmn", "pqr", "stu", "xyz"]
    array.remove("lmn")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    
    array.remove("nonexistent")
    print("\(array)")    //["abc", "pqr", "stu", "xyz"]
    //if provided element value is not present, then it will do nothing!

इसके अलावा, अगर गलती से, हमने कुछ ऐसा किया है: array.remove(25) यानी हमने अलग-अलग डेटा प्रकार के साथ मूल्य प्रदान किया, संकलक त्रुटि का उल्लेख array.remove(25)
cannot convert value to expected argument type

एक ऐरे का न्यूनतम या अधिकतम तत्व खोजना

let numbers = [2, 6, 1, 25, 13, 7, 9]

let minimumNumber = numbers.minElement() // Optional(1)
let maximumNumber = numbers.maxElement() // Optional(25)

let minimumNumber = numbers.min() // Optional(1)
let maximumNumber = numbers.max() // Optional(25)

इन विधियों से लौटाया गया मान इस तथ्य को प्रतिबिंबित करने के लिए वैकल्पिक है कि सरणी खाली हो सकती है - यदि यह है, तो nil वापस कर दिया जाएगा।

नोट: उपरोक्त विधियों में Comparable प्रोटोकॉल के अनुरूप तत्वों की आवश्यकता होती है।

कस्टम ऑर्डर के साथ न्यूनतम या अधिकतम तत्व खोजना

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

उदाहरण के लिए, वैक्टर की एक सरणी के साथ:

struct Vector2 {
    let dx : Double
    let dy : Double
    
    var magnitude : Double {return sqrt(dx*dx+dy*dy)}
}

let vectors = [Vector2(dx: 3, dy: 2), Vector2(dx: 1, dy: 1), Vector2(dx: 2, dy: 2)]

// Vector2(dx: 1.0, dy: 1.0)
let lowestMagnitudeVec2 = vectors.minElement { $0.magnitude < $1.magnitude } 

// Vector2(dx: 3.0, dy: 2.0)
let highestMagnitudeVec2 = vectors.maxElement { $0.magnitude < $1.magnitude } 

let lowestMagnitudeVec2 = vectors.min { $0.magnitude < $1.magnitude }
let highestMagnitudeVec2 = vectors.max { $0.magnitude < $1.magnitude }

सुरक्षित रूप से सूचकांकों तक पहुंच

निम्नलिखित सूचक जोड़कर सरणी सूचकांकों को यह जानने के बिना एक्सेस किया जा सकता है कि क्या सूचकांक सीमा के अंदर है।

extension Array {
    subscript (safe index: Int) -> Element? {
        return indices ~= index ? self[index] : nil
    }
}

उदाहरण:

if let thirdValue = array[safe: 2] {
    print(thirdValue)
}

2 एर की तुलना ज़िप से करें

zip फ़ंक्शन SequenceType 2 मापदंडों को स्वीकार करता है और एक Zip2Sequence लौटाता है, जहां प्रत्येक तत्व में पहले अनुक्रम से एक मान होता है और दूसरे क्रम से एक होता है।

उदाहरण

let nums = [1, 2, 3]
let animals = ["Dog", "Cat", "Tiger"]
let numsAndAnimals = zip(nums, animals)

nomsAndAnimals में अब निम्न मान हैं

यह तब उपयोगी है जब आप प्रत्येक ऐरे के n-वें तत्व के बीच किसी प्रकार की तुलना करना चाहते हैं।

उदाहरण

Int(s) 2 एरे दिए गए

let list0 = [0, 2, 4]
let list1 = [0, 4, 8]

आप यह जांचना चाहते हैं कि list1 में प्रत्येक मान list1 में संबंधित मूल्य का list0 ।

let list1HasDoubleOfList0 = !zip(list0, list1).filter { $0 != (2 * $1)}.isEmpty