значение типа '[CChar]' не имеет члена 'extend' [duplicate]

Marge-массив, который представляет собой разные типы данных:

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

Выход:

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

Если вы не являетесь большим поклонником перегрузки оператора или просто более функционального типа:

// 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]

С Swift 3, в соответствии с вашими потребностями и вкусами, вы можете выбрать один из пяти следующих способов слияния / слияния двух массивов.

1. Объединение двух массивов в новый массив с помощью Swift standard library [Int] универсального оператора [Int]

Стандартная библиотека Swift определяет универсальный оператор +(_:_:). +(_:_:) имеет следующее объявление :

func +<RRC1 : RangeReplaceableCollection, RRC2 : RangeReplaceableCollection where RRC1.Iterator.Element == RRC2.Iterator.Element>(lhs: RRC1, rhs: RRC2) -> RRC1

Создает новую коллекцию, объединяя элементы двух коллекций.

] Следующий код игровой площадки показывает, как объединить два массива типа [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 append(contentsOf:)

Swift Array имеет метод append(contentsOf:). append(contentsOf:) имеет следующее объявление :

public mutating func append<S>(contentsOf newElements: S) where S : Sequence, S.Iterator.Element == 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]

---

3. Слияние двух массивов в новый массив с помощью метода Sequence flatMap(_:)

Swift предоставляет метод flatMap(_:) для всех типов, соответствующих протоколу Sequence (включая Array). flatMap(_:) имеет следующее объявление :

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

Возвращает массив, содержащий конкатенированные результаты вызова данного преобразования с каждым элементом этой последовательности.

Следующий код игровой площадки показывает, как объединить два массива типа [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]

---

4. Объедините два массива в новый массив с помощью метода Sequence Sequence Sequence и Array init(_:) инициализатор

. Swift предоставляет метод joined() для всех типов, соответствующих Sequence протокол (включая Array). joined() имеет следующее объявление :

func joined() -> FlattenSequence<Self>

Возвращает элементы этой последовательности последовательностей, конкатенированные.

Кроме того, Swift Array имеет инициализатор init(_:). init(_:) имеет следующее объявление :

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

Создает массив, содержащий элементы последовательности.

Поэтому , следующий код игровой площадки показывает, как объединить два массива типа [Int] в новый массив с использованием метода joined() и init(_:) initializer:

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]

---

5. Слияние двух массивов в новый массив с помощью метода Array reduce(_:_:)

Swift 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]

Аналогично, со словарями массивов можно:

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"]!)

, и вы можете перебирать dict1 и добавлять dict2, если «ключ» соответствует

Вот кратчайший способ слияния двух массивов.

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

Объединить / объединить их

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

Swift 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]

. Это правильные результаты вышеприведенных кодов.

Мой любимый метод, так как Swift 2.0 is flatten

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())

Чтобы завершить список возможных альтернатив, reduce можно использовать для реализации поведения flatten :

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

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

Лучшая альтернатива (производительность / память ) среди представленных - просто flatten, которые лениво завершают оригинальные массивы, не создавая новую структуру массива.

Но обратите внимание, что flatten не возвращает LazyColletion , так что ленивое поведение не будет распространяться на следующую операцию вдоль цепочки (карта, плоская карта, фильтр и т. д.).

Если ленивость имеет смысл в вашем конкретном случае, просто запомните, чтобы добавить или добавить .lazy в flatten(), например, модифицируя образец Томаша следующим образом:

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

Если вы хотите, чтобы второй массив был вставлен после определенного индекса, вы можете сделать это (начиная с Swift 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]