在Swift中展平数组

在Scala、Xtend、Groovy、Ruby和co中，Swift中是否有对应的

flant

var aofa = [[1,2,3],[4],[5,6,7,8,9]]
aofa.flatten() // shall deliver [1,2,3,4,5,6,7,8,9] 

当然我可以用reduce，但那有点糟糕

var flattened = aofa.reduce(Int[]()){
    a,i in var b : Int[] = a
    b.extend(i)
    return b
}

Swift>=3.0

减少

：

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = numbers.reduce([], +)

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = numbers.flatMap { $0 }

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let joined = Array(numbers.joined())

flatMap

：

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = numbers.reduce([], +)

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = numbers.flatMap { $0 }

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let joined = Array(numbers.joined())

加入

：

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = numbers.reduce([], +)

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = numbers.flatMap { $0 }

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let joined = Array(numbers.joined())

---

另一个更通用的

reduce实现

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let reduced = reduce(numbers,[],+)

这可以实现同样的功能，但可以让您更深入地了解
reduce
中的情况

从苹果的文档中

func reduce<S : SequenceType, U>(sequence: S, initial: U, combine: (U, S.Generator.Element) -> U) -> U

func-reduce（序列：S，首字母：U，组合：（U，S.Generator.Element）->U）->U

说明

返回反复调用combine的结果，并依次使用初始化为initial和sequence的每个元素的累积值。
编辑：使用
joined（）
：


原答复:

let number=[[1,2,3]，[4,5,6]]
让数字=数字。减少（[]，合并：+）
在Swift标准库中，为符合
序列
协议的所有类型（或Swift 3之前的
序列类型
上）实施了功能，其中包括
阵列
：

let numbers = [[1,2,3],[4],[5,6,7,8,9]]
let flattened = Array(numbers.joined())

在某些情况下，使用
joined（）
可能是有益的，因为它返回一个惰性集合而不是一个新数组，但在传递给
array（）
初始化器时，总是可以转换为数组，如上例所示。
flatte（）
在Swift 3 per SE-0133中被重命名为
joined（）
：


Swift 4.x/5.x

只是为了增加数组的复杂性，如果有一个数组包含数组数组，那么
flatMap
实际上会失败

假设数组是

var array:[Any] = [1,2,[[3,4],[5,6,[7]]],8]

flatMap
或
compactMap
返回的是：

array.compactMap({$0})

//Output
[1, 2, [[3, 4], [5, 6, [7]]], 8]

为了解决这个问题，我们可以使用简单的for循环逻辑+递归

func flattenedArray(array:[Any]) -> [Int] {
    var myArray = [Int]()
    for element in array {
        if let element = element as? Int {
            myArray.append(element)
        }
        if let element = element as? [Any] {
            let result = flattenedArray(array: element)
            for i in result {
                myArray.append(i)
            }

        }
    }
    return myArray
}

所以用给定的数组调用这个函数

flattenedArray(array: array)

结果是：

[1, 2, 3, 4, 5, 6, 7, 8]

考虑到
Int
的情况，此函数将有助于展平任何类型的数组

操场输出：
Swift 4.x

flatMap
的这种用法并不是不推荐的，它是针对这一点的。

可以使用以下方法展平嵌套数组：

var arrays = [1, 2, 3, 4, 5, [12, 22, 32], [[1, 2, 3], 1, 3, 4, [[[777, 888, 8999]]]]] as [Any]

func flatten(_ array: [Any]) -> [Any] {

    return array.reduce([Any]()) { result, current in
        switch current {
        case(let arrayOfAny as [Any]):
            return result + flatten(arrayOfAny)
        default:
            return result + [current]
        }
    }
}

let result = flatten(arrays)

print(result)

/// [1, 2, 3, 4, 5, 12, 22, 32, 1, 2, 3, 1, 3, 4, 777, 888, 8999]

Swift 4.2

我在下面编写了一个简单的数组扩展。可以使用展开包含其他数组或元素的数组。与joined（）方法不同

修改了@RahmiBozdag的答案，
1.公共扩展中的方法是公共的。
2.删除了额外的方法，因为开始索引将始终为零。
3.我没有找到一种方法将compactMap放在nil和optionals的内部，因为内部方法T总是[Any？]，欢迎任何建议

 let array = [[[1, 2, 3], 4], 5, [6, [9], 10], 11, nil] as [Any?]

 public extension Array {

 func flatten<T>(_ index: Int = 0) -> [T] {
        guard index < self.count else { 
            return [] 
        }

        var flatten: [T] = []

        if let itemArr = self[index] as? [T] {
            flatten += itemArr.flatten()
        } else if let element = self[index] as? T {
            flatten.append(element)
        }
        return flatten + self.flatten(index + 1)
   }

}

let result: [Any] = array.flatten().compactMap { $0 }
print(result)
//[1, 2, 3, 4, 5, 6, 9, 10, 11]

让数组=[[1,2,3]，4]，5，[6,9,10]，11，nil]作为[Any？]
公共扩展阵列{
func展平（u指数：Int=0）->[T]{
保护索引
Apple Swift 5.1.2版（swiftlang-1100.0.278-1100.0.33.9）


目标：x86_64-apple-darwin19.2.0


let optionalNumber=[[1,2,3,nil]，nil[4]，[5,6,7,8,9]]
打印（OptionalNumber.compactMap{$0}）/[[可选（1）、可选（2）、可选（3）、无]，[可选（4）]、[可选（5）、可选（6）、可选（7）、可选（8）、可选（9）]]
打印（optionalNumbers.compactMap{$0}.reduce（[]，+）.map{$0 as？Int？？nil}.compactMap{$0}）/[1,2,3,4,5,6,7,8,9]
打印（OptionalNumber.compactMap{$0}.flatMap{$0}.map{$0 as？Int？？nil}.compactMap{$0}）/[1,2,3,4,5,6,7,8,9]
打印（数组（optionalNumber.compactMap{$0}.joined（））.map{$0 as？Int？？nil}.compactMap{$0}）/[1,2,3,4,5,6,7,8,9]
设非可选数=[[1,2,3]，[4]，[5,6,7,8,9]]
打印（非可选数字.compactMap{$0}）/[[1,2,3]，[4]，[5,6,7,8,9]]
打印（非可选数字。减少（[]，+）/[1,2,3,4,5,6,7,8,9]
打印（非可选数字.flatMap{$0}）/[1,2,3,4,5,6,7,8,9]
打印（数组（nonoptionalNumber.joined（））/[1,2,3,4,5,6,7,8,9]
矩阵是[[myDTO]]

在swift 5中，您可以使用此=数组（self.matrix！.joined（））
swift 5.1

public extension Array where Element: Collection {

    func flatten() -> [Element.Element] {
        return reduce([], +)
    }
}

如果您还希望它用于字典值：

public extension Dictionary.Values where Value : Collection {
    func flatten() -> [Value.Element]{
         return self.reduce([], +)
    }
}

这不就像使用数组的add对象吗？我还没有研究Swift本身，但在Haskell和F#中，它是“concat”-所以可能看起来像这样我很肯定这在某个地方（大多数FP语言。了解单子，这是列表的绑定）是的，在haskell中它实际上被称为concat。你应该接受。更一般地说，从Swift 1.2开始，
flatMap
可用。
joined
（正式名称为“展平”

）使用

flatMap

？是不是当

flatMap

连接时，它也可以映射/转换东西。但是在这个例子中，我们真的不需要ie，我们返回

$0

@Dschee

flatMap

将二维数组展平为一维数组，或者删除

nil

值，而不是两个值。它根据第一个-level数组的

元素
是一个数组或可选的-因此如果你给它传递一个可选的2D数组（例如
[[Int？]]
），它会选择将其展平到1D（例如
[Int？]
）。要展平到1-D并删除第二级零，你必须执行
数组.flatMap{$0}.flatMap{$0}
。换句话说，维度展平相当于
数组（Array.joined（））
和零删除“fla”