Làm cách nào để ghép hoặc ghép các mảng trong Swift?

Nếu có hai mảng được tạo trong swift như thế này:

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

Làm thế nào họ có thể được sáp nhập [1, 2, 3, 4, 5, 6]?

Bạn có thể nối các mảng với +, xây dựng một mảng mới

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

hoặc nối một mảng với mảng khác bằng +=(hoặc 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]

Với Swift 5, theo nhu cầu của bạn, bạn có thể chọn một trong sáu cách sau để nối / hợp nhất hai mảng.

# 1. Hợp nhất hai mảng thành một mảng mới với Array's +(_:_:)điều hành chung

Arraycó một +(_:_:)toán tử chung. +(_:_:)có tuyên bố sau :

Tạo một bộ sưu tập mới bằng cách ghép các phần tử của một bộ sưu tập và một chuỗi.

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

Mã mẫu Playground sau đây cho thấy cách hợp nhất hai mảng loại [Int]thành một mảng mới bằng +(_:_:)toán tử chung:

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

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

# 2. Nối các phần tử của một mảng thành một mảng hiện với Array's +=(_:_:)điều hành chung

Arraycó một +=(_:_:)toán tử chung. +=(_:_:)có tuyên bố sau :

Nối các phần tử của chuỗi vào bộ sưu tập có thể thay thế phạm vi.

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

Mã mẫu Playground sau đây cho thấy cách nối các phần tử của một loại kiểu [Int]vào một mảng hiện có bằng +=(_:_:)toán tử chung:

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

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

# 3. Nối một mảng vào mảng khác với Array's append(contentsOf:)phương pháp

Swift Arraycó một append(contentsOf:)phương pháp. append(contentsOf:)có tuyên bố sau :

Thêm các yếu tố của một chuỗi hoặc bộ sưu tập vào cuối bộ sưu tập này.

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

Mã mẫu Playground sau đây cho thấy cách nối một mảng vào một mảng kiểu khác [Int]bằng append(contentsOf:)phương thức:

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

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

#4. Hợp nhất hai mảng thành một mảng mới với Sequence's flatMap(_:)phương pháp

Swift cung cấp một flatMap(_:)phương thức cho tất cả các loại phù hợp với Sequencegiao thức (bao gồm Array). flatMap(_:)có tuyên bố sau :

Trả về một mảng chứa các kết quả được nối bằng cách gọi phép biến đổi đã cho với mỗi phần tử của chuỗi này.

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

Mã mẫu Playground sau đây cho thấy cách hợp nhất hai mảng loại [Int]thành một mảng mới bằng flatMap(_:)phương thức:

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. Hợp nhất hai mảng thành một mảng mới với Sequence's joined()phương pháp và Array' s init(_:)initializer

Swift cung cấp một joined()phương thức cho tất cả các loại phù hợp với Sequencegiao thức (bao gồm Array). joined()có tuyên bố sau :

Trả về các phần tử của chuỗi trình tự này, được nối.

func joined() -> FlattenSequence<Self>

Bên cạnh đó, Swift Arraycó một trình init(_:)khởi tạo. init(_:)có tuyên bố sau :

Tạo một mảng chứa các phần tử của một chuỗi.

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

Do đó, mã mẫu Playground sau đây cho thấy cách hợp nhất hai mảng loại [Int]thành một mảng mới bằng cách sử dụng joined()phương thức và trình init(_:)khởi tạo:

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. Hợp nhất hai mảng thành một mảng mới với Array's reduce(_:_:)phương pháp

Swift Arraycó một reduce(_:_:)phương pháp. reduce(_:_:)có tuyên bố sau :

Trả về kết quả của việc kết hợp các phần tử của chuỗi bằng cách sử dụng bao đóng đã cho.

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

Mã Playground sau đây cho thấy cách hợp nhất hai mảng loại [Int]thành một mảng mới bằng reduce(_:_:)phương thức:

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]

Nếu bạn không phải là một fan hâm mộ lớn của quá tải nhà điều hành, hoặc chỉ là một loại chức năng:

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

Phương pháp yêu thích của tôi kể từ Swift 2.0 là làm phẳng

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

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

Điều này sẽ trở lại FlattenBidirectionalCollectionvì vậy nếu bạn chỉ muốn một CollectionTypeđiều này là đủ và bạn sẽ có đánh giá lười biếng miễn phí. Nếu bạn cần chính xác Mảng, bạn có thể làm điều này:

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

Để hoàn thành danh sách các lựa chọn thay thế reducecó thể , có thể được sử dụng để thực hiện hành vi của flatten :

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

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

Cách thay thế tốt nhất (hiệu năng / bộ nhớ khôn ngoan) trong số những thứ được trình bày đơn giản flattenlà chỉ cần bọc các mảng ban đầu một cách lười biếng mà không tạo ra cấu trúc mảng mới.

Nhưng lưu ý rằng flatten không trả về a LazyCollection, do đó hành vi lười biếng sẽ không được truyền đến hoạt động tiếp theo dọc theo chuỗi (map, FlatMap, bộ lọc, v.v.).

Nếu sự lười biếng có ý nghĩa trong trường hợp cụ thể của bạn, chỉ cần nhớ thêm trước hoặc nối thêm .lazyvào flatten(), ví dụ, sửa đổi mẫu của Tomasz theo cách này:

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

Nếu bạn muốn chèn mảng thứ hai sau một chỉ mục cụ thể, bạn có thể thực hiện việc này (kể từ 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] 

Swift 3.0

Bạn có thể tạo một mảng mới bằng cách thêm hai mảng hiện có với các loại tương thích với toán tử cộng ( +). Kiểu của mảng mới được suy ra từ kiểu của hai mảng bạn thêm vào với nhau,

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]

đây là kết quả đúng của các mã trên.

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

nếu bạn muốn kết quả là: [1,2,3, [4,5,6]]

arrayOne.append(arrayTwo)

đoạn mã trên sẽ chuyển đổi mảngOne thành một phần tử duy nhất và thêm nó vào cuối mảngTwo.

nếu bạn muốn kết quả là: [1, 2, 3, 4, 5, 6] thì,

arrayOne.append(contentsOf: arrayTwo)

đoạn mã trên sẽ thêm tất cả các phần tử của mảngOne vào cuối mảngTwo.

Cảm ơn.

Swift 4.X

Cách dễ nhất tôi biết là chỉ sử dụng dấu +

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

var Array3 = Array1 + Array2

// Array 3 will just be them combined :)

Đây là cách ngắn nhất để hợp nhất hai mảng.

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

Ghép / hợp nhất chúng

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

Tương tự, với từ điển của mảng người ta có thể:

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

và bạn có thể lặp lại trên dict1 và thêm dict2 nếu "khóa" khớp

Mảng Marge là các loại dữ liệu khác nhau:

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

Đầu ra:

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