Question

这是一个可以按预期工作的简单SwiftUI列表：

struct App: View {
  let items = Array(100...200)
  var body: some View {
    List {
      ForEach(items, id: \.self) { index, item in
        Text("Item \(item)")
      }
    }.frame(width: 200, height: 200)
  }
}

但是当我尝试通过将items替换为items.enumerated()来枚举项目时，会出现以下错误：

在'ForEach'上引用初始化程序'init（_：id：content :)'要求'（（offset：Int，element：Int）'）符合'Hashable'

在'ForEach'上引用初始化程序'init（_：id：content :)'要求'EnumeratedSequence <[Int]>'符合'RandomAccessCollection'

我如何进行这项工作？

Answer 1

TL; DR

警告：如果您习惯将enumerated()与ForEach一起使用，则有一天可能会遇到EXC_BAD_INSTRUCTION或Fatal error: Index out of bounds例外。这是因为并非所有集合都具有从0开始的索引。

更好的默认设置是改用zip：

ForEach(Array(zip(items.indices, items)), id: \.0) { index, item in
  // index and item are both safe to use here
}

（如果您的商品符合id: \.1，也可以使用Identifiable。）

Point-Free mentioned that it's not safe to rely on enumerated() with ForEach in production since not all collections are zero-index based的乡亲们：

从技术上讲，这不是最正确的方法。用其索引集合压缩todos数组会更正确，也更冗长。在这种情况下，我们是安全的，因为我们正在处理基于0的简单索引数组，但是如果我们在生产中进行此操作，则可能应该采用基于zip的方法。

Apple的枚举函数文档也提到了这一点：

    /// Returns a sequence of pairs (*n*, *x*), where *n* represents a
    /// consecutive integer starting at zero and *x* represents an element of
    /// the sequence.
    ///
    /// This example enumerates the characters of the string "Swift" and prints
    /// each character along with its place in the string.
    ///
    ///     for (n, c) in "Swift".enumerated() {
    ///         print("\(n): '\(c)'")
    ///     }
    ///     // Prints "0: 'S'"
    ///     // Prints "1: 'w'"
    ///     // Prints "2: 'i'"
    ///     // Prints "3: 'f'"
    ///     // Prints "4: 't'"
    ///
    /// When you enumerate a collection, the integer part of each pair is a counter
    /// for the enumeration, but is not necessarily the index of the paired value.
    /// These counters can be used as indices only in instances of zero-based,
    /// integer-indexed collections, such as `Array` and `ContiguousArray`. For
    /// other collections the counters may be out of range or of the wrong type
    /// to use as an index. To iterate over the elements of a collection with its
    /// indices, use the `zip(_:_:)` function.
    ///
    /// This example iterates over the indices and elements of a set, building a
    /// list consisting of indices of names with five or fewer letters.
    ///
    ///     let names: Set = ["Sofia", "Camilla", "Martina", "Mateo", "Nicolás"]
    ///     var shorterIndices: [Set<String>.Index] = []
    ///     for (i, name) in zip(names.indices, names) {
    ///         if name.count <= 5 {
    ///             shorterIndices.append(i)
    ///         }
    ///     }
    ///
    /// Now that the `shorterIndices` array holds the indices of the shorter
    /// names in the `names` set, you can use those indices to access elements in
    /// the set.
    ///
    ///     for i in shorterIndices {
    ///         print(names[i])
    ///     }
    ///     // Prints "Sofia"
    ///     // Prints "Mateo"
    ///
    /// - Returns: A sequence of pairs enumerating the sequence.
    ///
    /// - Complexity: O(1)

在特定情况下，enumerated()可以使用，因为您使用的是基于0的索引数组，但是由于上面的详细信息，始终依靠enumerated()可能会导致不明显错误。

以以下代码段为例：

ForEach(Array(items.enumerated()), id: \.offset) { offset, item in
  Button(item, action: { store.didTapItem(at: offset) })
}

// ...

class Store {

  var items: ArraySlice<String>

  func didTapItem(at index: Int) {
    print(items[index])
  }
}

首先要注意的是，由于Button(item...已保证可以直接访问enumerated()而不会引起异常，因此我们在item处添加了项目符号。但是，如果我们使用item代替items[offset]，则很容易引发异常。

最后，由于索引（实际上是偏移量）可能超出范围，因此print(items[index])行很容易导致异常。

因此，一种更安全的方法是始终使用本文顶部提到的zip方法。

更喜欢zip的另一个原因是，如果您尝试将相同的代码用于不同的Collection（例如Set），则在索引到类型（items[index]）时可能会遇到以下语法错误：< / p>

无法将“ Int”类型的值转换为预期的参数类型“ Set.Index”

通过使用基于zip的方法，您仍然可以索引到集合中。

如果您打算经常使用它，也可以create an extension on collection。

您可以在Playground中进行全部测试：

import PlaygroundSupport
import SwiftUI

// MARK: - Array

let array = ["a", "b", "c"]
Array(array.enumerated()) // [(offset 0, element "a"), (offset 1, element "b"), (offset 2, element "c")]
Array(zip(array.indices, array)) // [(.0 0, .1 "a"), (.0 1, .1 "b"), (.0 2, .1 "c")]

let arrayView = Group {
  ForEach(Array(array.enumerated()), id: \.offset) { offset, element in
    PrintView("offset: \(offset), element: \(element)")
    Text("value: \(array[offset])")
  }
//  offset: 0, element: a
//  offset: 1, element: b
//  offset: 2, element: c


  ForEach(Array(zip(array.indices, array)), id: \.0) { index, element in
    PrintView("index: \(index), element: \(element)")
    Text("value: \(array[index])")
  }
//  index: 0, element: a
//  index: 1, element: b
//  index: 2, element: c
}

// MARK: - Array Slice

let arraySlice = array[1...2] // ["b", "c"]
Array(arraySlice.enumerated()) // [(offset 0, element "b"), (offset 1, element "c")]
Array(zip(arraySlice.indices, arraySlice)) // [(.0 1, .1 "b"), (.0 2, .1 "c")]

// arraySlice[0] // ❌ EXC_BAD_INSTRUCTION
arraySlice[1] // "b"
arraySlice[2] // "c"


let arraySliceView = Group {
  ForEach(Array(arraySlice.enumerated()), id: \.offset) { offset, element in
    PrintView("offset: \(offset), element: \(element)")
    // Text("value: \(arraySlice[offset])") ❌ Fatal error: Index out of bounds
  }
//  offset: 0, element: b
//  offset: 1, element: c

  ForEach(Array(zip(arraySlice.indices, arraySlice)), id: \.0) { index, element in
    PrintView("index: \(index), element: \(element)")
    Text("value: \(arraySlice[index])")
  }
//  index: 1, element: b
//  index: 2, element: c
}

// MARK: - Set

let set: Set = ["a", "b", "c"]
Array(set.enumerated()) // [(offset 0, element "b"), (offset 1, element "c"), (offset 2, element "a")]
Array(zip(set.indices, set)) // [({…}, .1 "a"), ({…}, .1 "b"), ({…}, .1 "c")]

let setView = Group {
  ForEach(Array(set.enumerated()), id: \.offset) { offset, element in
    PrintView("offset: \(offset), element: \(element)")
    // Text("value: \(set[offset])") // ❌ Syntax error: Cannot convert value of type 'Int' to expected argument type 'Set<String>.Index'
  }
//  offset: 0, element: a
//  offset: 1, element: b
//  offset: 2, element: c


  ForEach(Array(zip(set.indices, set)), id: \.0) { index, element in
    PrintView("index: \(index), element: \(element)")
    Text("value: \(set[index])")
  }
//  index: Index(_variant: Swift.Set<Swift.String>.Index._Variant.native(Swift._HashTable.Index(bucket: Swift._HashTable.Bucket(offset: 0), age: -481854246))), element: a
//  index: Index(_variant: Swift.Set<Swift.String>.Index._Variant.native(Swift._HashTable.Index(bucket: Swift._HashTable.Bucket(offset: 2), age: -481854246))), element: b
//  index: Index(_variant: Swift.Set<Swift.String>.Index._Variant.native(Swift._HashTable.Index(bucket: Swift._HashTable.Bucket(offset: 3), age: -481854246))), element: c

}

// MARK: -

struct PrintView: View {
  init(_ string: String) {
    print(string)
    self.string = string
  }

  var string: String

  var body: some View {
    Text(string)
  }
}

let allViews = Group {
  arrayView
  arraySliceView
  setView
}

PlaygroundPage.current.setLiveView(allViews)

Answer 2

Apple SwiftUI 示例中的一个 enumerated() 是在 Array 内部使用，然后您可以添加偏移量作为 id，这在您枚举 Array 时是唯一的。

ForEach(Array(data.enumerated()), id: \.offset) { index, observation in

Answer 3

枚举此集合时，枚举中的每个元素都是一个类型的touple：

 (offset: Int, element: Int)

因此id参数应从id: \.self更改为id: \.element。

ForEach(items.enumerated(), id: \.element) { ...

但是，在进行此更改后，您仍然会收到错误消息：

在'ForEach'上引用初始化程序'init（_：id：content :)'要求'EnumeratedSequence <[Int]>'符合'RandomAccessCollection'

因为ForEach需要对数据进行随机访问，但是枚举仅允许按顺序访问。要解决此问题，请将枚举转换为数组。

ForEach(Array(items.enumerated()), id: \.element) { ...

这是一个扩展名，您可以使用它来简化一些操作：

extension Collection {
  func enumeratedArray() -> Array<(offset: Int, element: Self.Element)> {
    return Array(self.enumerated())
  }
}

以及可以在（macos）Xcode游乐场中运行的示例：

import AppKit
import PlaygroundSupport
import SwiftUI

extension Collection {
  func enumeratedArray() -> Array<(offset: Int, element: Self.Element)> {
    return Array(self.enumerated())
  }
}

struct App: View {
  let items = 100...200
  var body: some View {
    List {
      ForEach(items.enumeratedArray(), id: \.element) { index, item in
        Text("\(index): Item \(item)")
      }
    }.frame(width: 200, height: 200)
  }
}

PlaygroundPage.current.liveView = NSHostingView(rootView: App())

Answer 4

在大多数情况下，您不需要enumerate，因为它有点慢。

struct App: View {
    let items = Array(100...200)
    var body: some View {
        List {
           ForEach(items.indices, id: \.self) { index in
               Text("Item \(self.items[index])")
           }
        }.id(items).frame(width: 200, height: 200)
    }
}

在SwiftUI中，如何在ForEach中使用.enumerated（）？

4 个答案: