让我们从单个数组开始，例如：

let raceResult = ["one", "two", "four"]

如果我们想将每个元素与从0开始计数的偏移量结合起来，我们可以使用Array.enumerated()沿着map。

let numberedRaceResult = raceResult
    .enumerated()
    .map { offset, element in "\(offset). \(element)" }

for numberedResult in numberedRaceResult {
    print(numberedResult)
}

// Prints:
// 0. one
// 1. two
// 2. four

您可以看到，我没有在传递给map的闭包中调用print，您 * 可以 * 这样做，但这有点违背了map的目的（这是从输入数组的变换元素创建相等大小的输出数组），因为结果将是未使用的。在这种情况下，只使用for循环或调用forEach更有意义，如@Sh_Khan所示。
处理一个嵌套数组也是一样的，我们可以使用与处理一个数组相同的逻辑，但是要将它应用到每个子数组。

let raceResults = [
    ["one", "two", "four"],
    ["two", "one", "five", "six"],
    ["two", "one", "four", "ten"],
    ["one", "two", "four"],
]

let numberedRaceResults = raceResults
    .enumerated()
    .flatMap { outterOffset, raceResult in
        raceResult
            .enumerated()
            .map { innerOffset, element in "\(outterOffset).\(innerOffset). \(element)" }
    }

for numberedResult in numberedRaceResults {
    print(numberedResult)
}

// Prints:
// 0.0. one
// 0.1. two
// 0.2. four
// 1.0. two
// 1.1. one
// 1.2. five
// 1.3. six
// 2.0. two
// 2.1. one
// 2.2. four
// 2.3. ten
// 3.0. one
// 3.1. two
// 3.2. four

你会注意到我在outter数组上使用了flatMap，而不是简单的map，你可以来回改变它并比较结果，简而言之，flatMap给你一个字符串结果的单一平面数组，而不是字符串子数组的数组。

Map用于将类型T转换为其他类型X。比如将这些整型值Map为字符串。您不应该使用map来产生副作用，比如打印值或更新数据库等。它应该是一个接受输入并返回输出的 * 纯函数 *。“将这些AMap为B”。纯函数的意思是函数的值只依赖于输入，没有任何东西像世界的当前状态，也不会改变世界（像打印到控制台），所以例如，通过函数将这些int值加2来Map它们。
在您的示例中：

var raceResults = [["one","two","four"],["two","one","five","six"],["two","one","four","ten"],["one","two","four"]]

你有一个“字符串数组”的数组。
你可以把它Map到一个数组，只要你有一个函数接受“字符串数组”，并把它变成“其他东西”
这里你用 *Identity函数 * 来Map它，这个函数只返回它的输入，它将把一个字符串数组作为输入，并返回完全相同的字符串数组作为输出：

raceResults.map {
       return $0 // Returns first array 
   }

这不起任何作用，结果与raceResults完全相同。
如果你想迭代所有这些元素，那么函数flatMap就很方便：

raceResults.flatMap { $0 }.forEach { print($0) }

Flattening一个数组的数组是返回一个所有的东西都被“flattened”了一层的数组，所以[[1，2，3]，[4，5，6]] -〉[1，2，3，4，5，6]，但是flattened的定义取决于容器的类型，例如flatMap on Optional意味着一些其他的东西。