Comment concaténer ou fusionner des tableaux dans Swift?
S'il existe deux tableaux créés dans Swift, comme ceci:
var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]
Comment peuvent-ils être fusionnés avec [1, 2, 3, 4, 5, 6]?
Vous pouvez concaténer les tableaux avec +, créant ainsi un nouveau tableau
let c = a + b
print(c) // [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
ou ajoutez un tableau à l'autre avec += (ou 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]
Avec Swift 5, en fonction de vos besoins, vous pouvez choisir l’une des méthodes (== --- ==) suivantes pour concaténer/fusionner deux tableaux.
#1. Fusionner deux tableaux dans un nouveau tableau avec l'opérateur générique Array+(_:_:)
Array a un opérateur +(_:_:) générique. +(_:_:) a ce qui suit déclaration :
Crée une nouvelle collection en concaténant les éléments d’une collection et d’une séquence.
static func + <Other>(lhs: Array<Element>, rhs: Other) -> Array<Element> where Other : Sequence, Self.Element == Other.Element
L'exemple de code Playground suivant montre comment fusionner deux tableaux de type [Int] dans un nouveau tableau à l'aide de +(_:_:) opérateur générique:
let array1 = [1, 2, 3]
let array2 = [4, 5, 6]
let flattenArray = array1 + array2
print(flattenArray) // prints [1, 2, 3, 4, 5, 6]
# 2. Ajoute les éléments d'un tableau à un tableau existant avec l'opérateur Array '+=(_:_:) générique
Array a un opérateur +=(_:_:) générique. +=(_:_:) a ce qui suit déclaration :
Ajoute les éléments d'une séquence à une collection remplaçable par plage.
static func += <Other>(lhs: inout Array<Element>, rhs: Other) where Other : Sequence, Self.Element == Other.Element
L'exemple de code Playground suivant montre comment ajouter les éléments d'un tableau de type [Int] à un tableau existant à l'aide de l'opérateur +=(_:_:) generic:
var array1 = [1, 2, 3]
let array2 = [4, 5, 6]
array1 += array2
print(array1) // prints [1, 2, 3, 4, 5, 6]
# 3. Ajouter un tableau à un autre tableau avec la méthode Array's append(contentsOf:)
Swift Array a une méthode append(contentsOf:). append(contentsOf:) a ce qui suit déclaration :
Ajoute les éléments d'une séquence ou d'une collection à la fin de cette collection.
mutating func append<S>(contentsOf newElements: S) where S : Sequence, Self.Element == S.Element
L'exemple de code Playground suivant montre comment ajouter un tableau à un autre tableau de type [Int] à l'aide de la méthode 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. Fusionner deux tableaux dans un nouveau tableau avec la méthode Sequence's flatMap(_:)
Swift fournit une méthode flatMap(_:) pour tous les types conformes au protocole Sequence (y compris Array). flatMap(_:) a ce qui suit déclaration :
Retourne un tableau contenant les résultats concaténés de l'appel de la transformation donnée avec chaque élément de cette séquence.
func flatMap<SegmentOfResult>(_ transform: (Self.Element) throws -> SegmentOfResult) rethrows -> [SegmentOfResult.Element] where SegmentOfResult : Sequence
L'exemple de code Playground suivant montre comment fusionner deux tableaux de type [Int] dans un nouveau tableau à l'aide de la méthode 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. Fusionner deux tableaux en un nouveau tableau avec la méthode joined() de Sequence et l'initialisateur Array de init(_:)
Swift fournit une méthode joined() pour tous les types conformes au protocole Sequence (y compris Array). joined() a ce qui suit déclaration :
Retourne les éléments de cette séquence de séquences, concaténés.
func joined() -> FlattenSequence<Self>
En outre, Swift Array a un initialiseur init(_:). init(_:) a ce qui suit déclaration :
Crée un tableau contenant les éléments d'une séquence.
init<S>(_ s: S) where Element == S.Element, S : Sequence
Par conséquent, l'exemple de code Playground suivant montre comment fusionner deux tableaux de type [Int] dans un nouveau tableau à l'aide de la méthode joined() et de l'initialisateur 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. Fusionner deux tableaux dans un nouveau tableau avec la méthode Array's reduce(_:_:)
Swift Array a une méthode reduce(_:_:). reduce(_:_:) a ce qui suit déclaration :
Retourne le résultat de la combinaison des éléments de la séquence en utilisant la clôture donnée.
func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) throws -> Result) rethrows -> Result
Le code de terrain de jeu suivant montre comment fusionner deux tableaux de type [Int] dans un nouveau tableau à l'aide de la méthode 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]
Si vous n'êtes pas un grand fan de la surcharge de l'opérateur, ou juste un type fonctionnel:
// 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]
Ma méthode préférée depuis Swift 2.0 est aplatir
var a:[CGFloat] = [1, 2, 3]
var b:[CGFloat] = [4, 5, 6]
let c = [a, b].flatten()
Cela retournera FlattenBidirectionalCollection donc si vous voulez juste un CollectionType cela suffira et vous aurez une évaluation paresseuse gratuite. Si vous avez besoin exactement du tableau, vous pouvez le faire:
let c = Array([a, b].flatten())
Pour compléter la liste des alternatives possibles, reduce pourrait être utilisé pour implémenter le comportement de flatten :
var a = ["a", "b", "c"]
var b = ["d", "e", "f"]
let res = [a, b].reduce([],combine:+)
La meilleure alternative (performance/mémoire) parmi celles présentées est simplement flatten, qui encapsule simplement les tableaux d'origine sans créer de nouvelle structure de tableau.
Mais remarquez que aplatit ne retourne pas a LazyCollection, de sorte que le comportement paresseux ne sera pas propagé à la prochaine opération le long de la chaîne (carte, flatMap, filtre, etc ...).
Si lazyness a un sens dans votre cas particulier, rappelez-vous simplement d’ajouter ou d'ajouter un .lazy à flatten(), par exemple, en modifiant l'exemple de Tomasz de la manière suivante:
let c = [a, b].lazy.flatten()
Swift 3.
Vous pouvez créer un nouveau tableau en ajoutant ensemble deux tableaux existants avec des types compatibles avec l'opérateur d'addition (+). Le type du nouveau tableau est déduit du type des deux tableaux que vous ajoutez,
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]
ce sont les bons résultats des codes ci-dessus.
Si vous voulez que le second tableau soit inséré après un index particulier, vous pouvez le faire (à partir de 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]
var arrayOne = [1,2,3]
var arrayTwo = [4,5,6]
si vous voulez résultat comme: [1,2,3, [4,5,6]]
arrayOne.append(arrayTwo)
le code ci-dessus convertira arrayOne en un seul élément et l'ajoutera à la fin de arrayTwo.
si vous voulez obtenir le résultat suivant: [1, 2, 3, 4, 5, 6], alors,
arrayOne.append(contentsOf: arrayTwo)
le code ci-dessus ajoutera tous les éléments de arrayOne à la fin de arrayTwo.
Merci.
Swift 4.X
le moyen le plus simple que je connaisse consiste simplement à utiliser le signe +
var Array1 = ["Item 1", "Item 2"]
var Array2 = ["Thing 1", "Thing 2"]
var Array3 = Array1 + Array2
// Array 3 will just be them combined :)
Voici le moyen le plus rapide de fusionner deux tableaux.
var array1 = [1,2,3]
let array2 = [4,5,6]
Concaténer/fusionner
array1 += array2
New value of array1 is [1,2,3,4,5,6]
Marge tableau qui sont différents types de données:
var arrayInt = [Int]()
arrayInt.append(6)
var testArray = ["a",true,3,"b"] as [Any]
testArray.append(someInt)
Sortie:
["a", true, 3, "b", "hi", 3, [6]]
De même, avec les dictionnaires de tableaux, on peut:
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"]!)
et vous pouvez parcourir dict1 et ajouter dict2 si la "clé" correspond