Ios SwiftUI字符串似乎不正确

我在

列表

中使用数组，在

列表

中有一个

ForEach

，如：

struct AView: View {

    @State var foo: [String] = ["a", "b", "c"]

    var body: some View {
        ZStack {
            Color.white
            List {
                ForEach(foo.indices) { index in
                    Text(foo[index])
                }
            }
        }

    }
}

这很好，然后我想添加一个按钮来插入新项目：

   List {
            ForEach(foo.indices) { index in
                Text(foo[index])
            }
        }
        Button("Add") {
            foo.append("foo")
        }
    }

然后我得到了一个错误，很明显：

ForEach<Range<Int>, Int, Text> count (4) != its initial count (3). `ForEach(_:content:)` should only be used for *constant* data. Instead conform data to `Identifiable` or use `ForEach(_:id:content:)` and provide an explicit `id`!

但还是有同样的问题。我错过了什么，明白吗？谢谢

编辑

根据@newdev的评论，由于我是literal

索引

，所以我给

Int

添加了扩展名：

extension Int: Identifiable {
    public var id: Int { self }
}

---

仍然不起作用。

ForEach

有多个

init

重载

init（Range，content:（Int）->content）

仅适用于常量范围-因此会出现错误

init（数据，内容：（Data.Element）->content）

要求

数据

符合

可识别

元素的

随机访问集合

。这就是你想用的

问题是您的

RandomAccessCollection

（符合

Range

的范围）是

Int

元素的集合

虽然您可以将

Int

与

可识别的
一致，但这仍然不起作用。它仍然会使用第一个
ForEach.init
和
Range
参数，因为方法重载首选项-即
Range
匹配更具体的
init
和
Range
参数，而不是不太具体的
init
和
RandomAccessCollection


因此，您的选择是：

通过显式指定
id
来使用第三个
init（Data，id:KeyPath，content:（Data.Element）->content）
转换为
Array
并符合
Int:Identifiable
：
ForEach
具有多个
init
重载

init（Range，content:（Int）->content）
仅适用于常量范围-因此会出现错误

init（数据，内容：（Data.Element）->content）
要求
数据
符合
可识别
元素的
随机访问集合
。这就是你想用的

问题是您的
RandomAccessCollection
（符合
Range
的范围）是
Int
元素的集合

虽然您可以将
Int
与
可识别的
一致，但这仍然不起作用。它仍然会使用第一个
ForEach.init
和
Range
参数，因为方法重载首选项-即
Range
匹配更具体的
init
和
Range
参数，而不是不太具体的
init
和
RandomAccessCollection


因此，您的选择是：

通过显式指定
id
来使用第三个
init（Data，id:KeyPath，content:（Data.Element）->content）
转换为
Array
并符合
Int:Identifiable
：
你做了
ForEach（foo.index，id:\.self）
，它成功了。还有问题吗？我明白了。。。您将
字符串
与
可识别
一致，但实际上您迭代了数组的索引（恰好是
Int
）。你可以只做
ForEach（foo）{foostrin…}
是的，
ForEach（foo）
如果我不需要
index
但是我需要索引，我试着将
Identifiable
与
Int
一致，但还是不走运
foo.index
实际上是
范围
，而不是
[Int]
。。。。为什么
ForEach（foo.indexes，id:\.self）
不适合您？
ForEach（Array（foo.indexes））
在您将
Int
扩展为
可识别的
时起作用。您做到了
ForEach（foo.indexes，id:\.self）
并且它起了作用。还有问题吗？我明白了。。。您将
字符串
与
可识别
一致，但实际上您迭代了数组的索引（恰好是
Int
）。你可以只做
ForEach（foo）{foostrin…}
是的，
ForEach（foo）
如果我不需要
index
但是我需要索引，我试着将
Identifiable
与
Int
一致，但还是不走运
foo.index
实际上是
范围
，而不是
[Int]
。。。。为什么
ForEach（foo.indexes，id:\.self）
不适合你？
ForEach（Array（foo.indexes））
在你扩展
Int
成为
可识别的
时工作。扩展
Int
时返回
self
的目的是什么？@LeoDabus它没有什么区别。与什么相反<代码>整数
？这是品味的问题，不是吗？这就是我的意思。这是毫无意义的。味道？它将始终是
Int
@LeoDabus，我更喜欢它，因为它对任何其他
Hashable
兼容类型的工作方式完全相同，而且我认为它更好地传达了语义意图。。。。在任何情况下，这都是一个品味的问题。当扩展
Int
时返回
Self
的目的是什么？@LeoDabus这没有什么区别。与什么相反<代码>整数
？这是品味的问题，不是吗？这就是我的意思。这是毫无意义的。味道？它将始终是
Int
@LeoDabus，我更喜欢它，因为它对任何其他
Hashable
兼容类型的工作方式完全相同，而且我认为它更好地传达了语义意图。。。。无论如何，这是一个品味的问题。
extension Int: Identifiable {
    public var id: Int { self }
}

ForEach(foo.indices, id:\.self) { index in 
}

extension Int: Identifiable { var id: Self { self } }

ForEach(Array(foo.indices)) { index in 
}