मैं स्विफ्ट में सरणियों को कैसे व्यवस्थित या विलय कर सकता हूं?

Question

यदि इस तरह से स्विफ्ट में दो एरे बनाए जाते हैं:

var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]

उनका विलय कैसे किया जा सकता है [1, 2, 3, 4, 5, 6]?

Comments

यह stackoverflow.com/q/24465281/78336 का

— neoneye

Answer 1

आप +एक नई व्यूह रचना के साथ सरणियों को संक्षिप्त कर सकते हैं

let c = a + b
print(c) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

या एक सरणी को दूसरे के साथ जोड़ें +=(या append):

a += b

// Or:
a.append(contentsOf: b)  // Swift 3
a.appendContentsOf(b)    // Swift 2
a.extend(b)              // Swift 1.2

print(a) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]

Comments

[AnyObect]? CGFloat के समान नहीं है। जबकि AnyObject सरणियों के लिए सहमति।

— खुनशान

खुनशान: AnyObjectएक वस्तु को इंगित करता है, जिसे मैं समझता हूं कि इसका मतलब कुछ ऐसा है जो एक वर्ग प्रकार से तात्कालिक है। CGFloatकोई वस्तु नहीं है, यह एक अदिश मान है। जब तक मैं इसे समझता हूं, सरणियों में स्केलर हो सकते हैं, जब तक कि इसे युक्त के रूप में परिभाषित नहीं किया जाता है AnyObjectया आगे परिष्कृत नहीं किया जाता है। हालांकि, मुझे संदेह है कि समस्या यह है कि सरणी एक वैकल्पिक में लपेटी गई है, इसलिए आपको इसे पहले !या ?पहले से खोलना होगा ।

— ओवेन गॉडफ्रे

हम जानते हैं कि क्या स्विफ्ट 2 की कॉपी-ऑन-राइट खुफिया निर्धारित करता है कि तक फैली हुई है bके भाग के aसंशोधित किया गया है (इसलिए संभवतः की एक प्रति eliding bदौरान a.appendContentsOf(b))?

— एपेमेरा

@OwenGodfrey धन्यवाद मैं appendContentsOf और InsertContentsOf पर भ्रम की स्थिति है।

— खुनशान १५'१६ को

मैं दो सरणियों को कैसे जोड़ सकता हूं जिनमें प्रत्येक अलग-अलग प्रकार की वस्तुएं हैं ?

— इसुरु

Answer 2

स्विफ्ट 5 के साथ, अपनी आवश्यकताओं के अनुसार, आप दो सरणियों को मिलाने / विलय करने के लिए निम्नलिखित छह तरीकों में से एक चुन सकते हैं ।

---

# 1। के साथ एक नई सरणी में दो सरणियों मर्ज Arrayकी +(_:_:)सामान्य ऑपरेटर

Arrayएक +(_:_:)सामान्य ऑपरेटर है। +(_:_:)निम्नलिखित घोषणा है :

एक संग्रह और एक अनुक्रम के तत्वों को संक्षिप्त करके एक नया संग्रह बनाता है।

static func + <Other>(lhs: Array<Element>, rhs: Other) -> Array<Element> where Other : Sequence, Self.Element == Other.Element

निम्न खेल का मैदान नमूना कोड दिखाता है कि जेनेरिक ऑपरेटर [Int]का उपयोग करके टाइप के दो सरणियों को एक नए सरणी में कैसे +(_:_:)मिलाया जाए:

let array1 = [1, 2, 3]
let array2 = [4, 5, 6]

let flattenArray = array1 + array2
print(flattenArray) // prints [1, 2, 3, 4, 5, 6]

---

# 2। के साथ किसी मौजूदा सरणी में एक सरणी के तत्वों संलग्न Arrayकी +=(_:_:)सामान्य ऑपरेटर

Arrayएक +=(_:_:)सामान्य ऑपरेटर है। +=(_:_:)निम्नलिखित घोषणा है :

एक अनुक्रम के तत्वों को एक रेंज-बदली संग्रह में जोड़ता है।

static func += <Other>(lhs: inout Array<Element>, rhs: Other) where Other : Sequence, Self.Element == Other.Element

निम्नलिखित खेल का मैदान नमूना कोड दिखाता है कि जेनेरिक ऑपरेटर [Int]का उपयोग करके किसी मौजूदा सरणी के प्रकार के तत्वों को कैसे जोड़ा जाए +=(_:_:):

var array1 = [1, 2, 3]
let array2 = [4, 5, 6]

array1 += array2
print(array1) // prints [1, 2, 3, 4, 5, 6]

---

# 3। के साथ एक और सरणी के लिए एक सरणी संलग्न Arrayकी append(contentsOf:)विधि

स्विफ्ट Arrayमें एक append(contentsOf:)विधि है। append(contentsOf:)निम्नलिखित घोषणा है :

किसी अनुक्रम या संग्रह के तत्वों को इस संग्रह के अंत में जोड़ता है।

mutating func append<S>(contentsOf newElements: S) where S : Sequence, Self.Element == S.Element

निम्न खेल का मैदान नमूना कोड दिखाता है कि विधि [Int]का उपयोग करके किसी अन्य प्रकार की सरणी में किसी सरणी को कैसे जोड़ा जाए append(contentsOf:):

var array1 = [1, 2, 3]
let array2 = [4, 5, 6]

array1.append(contentsOf: array2)
print(array1) // prints [1, 2, 3, 4, 5, 6]

---

# 4। के साथ एक नई सरणी में दो सरणियों मर्ज Sequenceकी flatMap(_:)विधि

स्विफ्ट flatMap(_:)सभी प्रकार के लिए एक विधि प्रदान करता है जो Sequenceप्रोटोकॉल के अनुरूप है (सहित Array)। flatMap(_:)निम्नलिखित घोषणा है :

इस क्रम के प्रत्येक तत्व के साथ दिए गए परिवर्तन को कॉल करने के संक्षिप्त परिणामों वाले एक सरणी देता है।

func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence

निम्न खेल का मैदान नमूना कोड दिखाता है कि विधि [Int]का उपयोग करके एक नई सरणी में टाइप के दो सरणियों को कैसे मर्ज किया जाए flatMap(_:):

let array1 = [1, 2, 3]
let array2 = [4, 5, 6]

let flattenArray = [array1, array2].flatMap({ (element: [Int]) -> [Int] in
    return element
})
print(flattenArray) // prints [1, 2, 3, 4, 5, 6]

---

# 5। के साथ एक नई सरणी में दो सरणियों मर्ज Sequenceकी joined()विधि और Arrayके init(_:)प्रारंभकर्ता

स्विफ्ट joined()सभी प्रकार के लिए एक विधि प्रदान करता है जो Sequenceप्रोटोकॉल के अनुरूप है (सहित Array)। joined()निम्नलिखित घोषणा है :

अनुक्रम के इस क्रम के तत्वों को लौटाता है।

func joined() -> FlattenSequence<Self>

इसके अलावा, स्विफ्ट Arrayमें एक init(_:)इनिलाइज़र है। init(_:)निम्नलिखित घोषणा है :

एक अनुक्रम के तत्वों से युक्त एक सरणी बनाता है।

init<S>(_ s: S) where Element == S.Element, S : Sequence

इसलिए, निम्न खेल का मैदान नमूना कोड दिखाता है कि विधि और इनिशियलाइज़र [Int]का उपयोग करके टाइप के दो सरणियों को एक नए सरणी में कैसे मर्ज किया जाए:joined()init(_:)

let array1 = [1, 2, 3]
let array2 = [4, 5, 6]

let flattenCollection = [array1, array2].joined() // type: FlattenBidirectionalCollection<[Array<Int>]>
let flattenArray = Array(flattenCollection)
print(flattenArray) // prints [1, 2, 3, 4, 5, 6]

---

# 6। के साथ एक नई सरणी में दो सरणियों मर्ज Arrayकी reduce(_:_:)विधि

स्विफ्ट Arrayमें एक reduce(_:_:)विधि है। reduce(_:_:)निम्नलिखित घोषणा है :

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

func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result

निम्न खेल का मैदान कोड दिखाता है कि विधि [Int]का उपयोग करके एक नई सरणी में टाइप के दो सरणियों को कैसे मर्ज किया जाए reduce(_:_:):

let array1 = [1, 2, 3]
let array2 = [4, 5, 6]

let flattenArray = [array1, array2].reduce([], { (result: [Int], element: [Int]) -> [Int] in
    return result + element
})
print(flattenArray) // prints [1, 2, 3, 4, 5, 6]

Comments

इस कोड को साझा करने के लिए धन्यवाद, अच्छी व्याख्या, आपके उत्तर के लिए बस प्रशंसा, यह सबसे अच्छा होगा, अगर आप कहते हैं कि प्रदर्शन से कौन अधिक कुशल है?

— कोकेमोमुके

मुझे +2 सरणियाँ और सारणियों की joined()एक सरणी के लिए पसंद है।

— कोयूर

यदि आप 2 से अधिक सरणियों (या स्ट्रिंग्स या जो कुछ भी) को मर्ज कर रहे हैं +, तो ऑपरेटर का उपयोग करने से खुद को रोकें , यह बिल्कुल पागल संकलन समय उत्पन्न करता है।

— लॉसिको

@lawicko आप किस विधि की सिफारिश करेंगे?

— साइबरएम

@CyberMew कुछ भी जो अतिभारित ऑपरेटरों का उपयोग नहीं करता है, मुझे पद्धति # 3 पसंद है क्योंकि मुझे लगता है कि यह सबसे पठनीय है, लेकिन मुझे फ्लैट मानचित्र के साथ विधि # 4 भी पसंद है। स्ट्रिंग्स के लिए मुझे मेथड # 5 पसंद है क्योंकि अंत में आपको सीधे जुड़े हुए स्ट्रिंग मिलते हैं।

— Lawicko

Answer 3

यदि आप ऑपरेटर ओवरलोडिंग के एक बड़े प्रशंसक नहीं हैं, या सिर्फ एक कार्यात्मक प्रकार के अधिक:

// use flatMap
let result = [
    ["merge", "me"], 
    ["We", "shall", "unite"],
    ["magic"]
].flatMap { $0 }
// Output: ["merge", "me", "We", "shall", "unite", "magic"]

// ... or reduce
[[1],[2],[3]].reduce([], +)
// Output: [1, 2, 3]

Answer 4

स्विफ्ट 2.0 के बाद से मेरा पसंदीदा तरीका समतल है

var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]

let c = [a, b].flatten()

यह वापस आ जाएगा FlattenBidirectionalCollectionयदि आप बस चाहते हैं कि CollectionTypeयह पर्याप्त होगा और आपके पास मुफ्त के लिए आलसी मूल्यांकन होगा। यदि आपको वास्तव में ऐरे की जरूरत है तो आप यह कर सकते हैं:

let c = Array([a, b].flatten())

Comments

flatten()लगता है आजकल नहीं है। लेकिन आप विचार कर सकते हैं joined()।

— कोयूर

Answer 5

संभव विकल्पों की सूची को पूरा करने के लिए, समतलreduce के व्यवहार को लागू करने के लिए इस्तेमाल किया जा सकता है :

var a = ["a", "b", "c"] 
var b = ["d", "e", "f"]

let res = [a, b].reduce([],combine:+)

प्रस्तुत किए गए लोगों के बीच सबसे अच्छा विकल्प (प्रदर्शन / स्मृति-वार) बस है flatten, कि एक नई सरणी संरचना बनाए बिना केवल मूल सरणियों को आलसी लपेटें।

लेकिन ध्यान दें कि चपटा एक वापस नहीं करता है LazyCollection, ताकि आलसी व्यवहार को अगले ऑपरेशन के साथ श्रृंखला (मानचित्र, फ्लैटपाइप, फिल्टर, आदि ...) में प्रचारित न किया जाए।

यदि आलसीपन आपके विशेष मामले में समझ में आता .lazyहै flatten(), तो उदाहरण के लिए, इस तरह से टॉमाज़ नमूने को संशोधित करने या करने के लिए याद रखें।

let c = [a, b].lazy.flatten()

Comments

2019 में स्विफ्ट 5.1 के साथ यह जवाब अभी भी कितना अच्छा है?

— --battel ’

समतल () किसी भी अधिक मौजूद नहीं है। शामिल () को समतल करने के बजाय इस्तेमाल किया जा सकता है ()

— प्रणव प्रवर

Answer 6

यदि आप चाहते हैं कि किसी विशेष इंडेक्स के बाद दूसरा एरे डाला जाए तो आप ऐसा कर सकते हैं (स्विफ्ट 2.2 के अनुसार):

let index = 1
if 0 ... a.count ~= index {
     a[index..<index] = b[0..<b.count]
}
print(a) // [1.0, 4.0, 5.0, 6.0, 2.0, 3.0] 

Answer 7

स्विफ्ट 3.0

आप अतिरिक्त ऑपरेटर के साथ संगत प्रकारों के साथ दो मौजूदा सरणियों को जोड़कर एक नई सरणी बना सकते हैं +। नए सरणी का प्रकार आपके द्वारा जोड़े गए दो सरणी के प्रकार से अनुमानित है,

let arr0 = Array(repeating: 1, count: 3) // [1, 1, 1]
let arr1 = Array(repeating: 2, count: 6)//[2, 2, 2, 2, 2, 2]
let arr2 = arr0 + arr1 //[1, 1, 1, 2, 2, 2, 2, 2, 2]

यह उपरोक्त कोड के सही परिणाम हैं।

Answer 8

var arrayOne = [1,2,3]
var arrayTwo = [4,5,6]

अगर आप परिणाम चाहते हैं: [1,2,3, [4,5,6]]

arrayOne.append(arrayTwo)

उपरोक्त कोड एक एकल तत्व के रूप में arrayOne को परिवर्तित करेगा और इसे arrayTwo के अंत में जोड़ देगा।

यदि आप परिणाम चाहते हैं: [१, २, ३, ४, ५, ६] तब,

arrayOne.append(contentsOf: arrayTwo)

उपरोक्त कोड arrayTwo के अंत में arrayOne के सभी तत्वों को जोड़ देगा।

धन्यवाद।

Answer 9

स्विफ्ट 4.X

सबसे आसान तरीका मुझे पता है कि सिर्फ + चिन्ह का उपयोग करना है

var Array1 = ["Item 1", "Item 2"]
var Array2 = ["Thing 1", "Thing 2"]

var Array3 = Array1 + Array2

// Array 3 will just be them combined :)

Answer 10

यहां दो सरणियों को मर्ज करने का सबसे छोटा तरीका है।

 var array1 = [1,2,3]
 let array2 = [4,5,6]

उन्हें समाप्‍त / मर्ज करें

array1 += array2
New value of array1 is [1,2,3,4,5,6]

Answer 11

इसी तरह, सरणियों के शब्दकोशों के साथ एक कर सकते हैं:

var dict1 = [String:[Int]]()
var dict2 = [String:[Int]]()
dict1["key"] = [1,2,3]
dict2["key"] = [4,5,6]
dict1["key"] = dict1["key"]! + dict2["key"]!
print(dict1["key"]!)

और यदि आप "कुंजी" से मेल खाते हैं, तो आप तानाशाही 1 पर पुनरावृत्ति कर सकते हैं और तानाशाही को जोड़ सकते हैं

Answer 12

विभिन्न प्रकार के डेटा प्रकार हैं:

var arrayInt = [Int]()
arrayInt.append(6)
var testArray = ["a",true,3,"b"] as [Any]
testArray.append(someInt)

आउटपुट:

["a", true, 3, "b", "hi", 3, [6]]