Arrays 检索第一个字典值

我有这类字典：

var dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"], 
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]

我需要在这个字典上循环，只获取每个键下的第一个值，该值不是nil，并将其追加到数组中

因此，最终，我的数组将如下所示：

var array = ["Value-1-1", "Value-2-2", "Value3-1", "Value-4-1", "Value-5-3"]

我在这里读过这个问题，但它不包括空值，我想知道是否可以不使用map，而使用in或while循环

---

如果有人能提供这种循环的代码示例，我将不胜感激。谢谢

这应该可以做到：
在学习编程时，以算法的方式使用手动for循环，而不是像

map（）

等神奇的方法，这是一个很好的开端。它们确实循环，但它们是隐式的。
在这里，我使用了

sorted（）

（因为它可能有点长）。
我还使用了

first（其中：）

，它查找第一个非空值。它也可以替换为while循环，但我不知道您是否想要for循环

var dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]
var finalArray = [String]()
let keys = Array(dict.keys).sorted(by: { return $0<$1 }) // because keys aren't sorted
for aKey in keys {
    if let anArrayValue = dict[aKey], let firstNonEmptyValue = anArrayValue.first(where: { !$0.isEmpty }) {
        finalArray.append(firstNonEmptyValue)
    }
}
print("finalArray: \(finalArray)")

var dict=[1:[“Value-1-1”，“”，“”，“”]，
2:[，“值-2-2”，“值-2-3”]，
3:[“值-3-1”、“值-3-2”、“值-3-2”]，
4:[“Value-4-1”、“Value-4-3”、“Value-4-1”，
5:[“”、“”、“值-5-3”]]
var finalArray=[String]（）
让keys=Array（dict.keys）.sorted（按：{return$0这应该可以做到：

在学习编程时，以算法的方式使用手动for循环，而不是像
map（）
等神奇的方法，这是一个很好的开端。它们确实循环，但它们是隐式的。

在这里，我使用了
sorted（）
（因为它可能有点长）。

我还使用了
first（其中：）
，它查找第一个非空值。它也可以替换为while循环，但我不知道是否需要for循环

var dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]
var finalArray = [String]()
let keys = Array(dict.keys).sorted(by: { return $0<$1 }) // because keys aren't sorted
for aKey in keys {
    if let anArrayValue = dict[aKey], let firstNonEmptyValue = anArrayValue.first(where: { !$0.isEmpty }) {
        finalArray.append(firstNonEmptyValue)
    }
}
print("finalArray: \(finalArray)")

var dict=[1:[“Value-1-1”，“”，“”，“”]，
2:[，“值-2-2”，“值-2-3”]，
3:[“值-3-1”、“值-3-2”、“值-3-2”]，
4:[“Value-4-1”、“Value-4-3”、“Value-4-1”，
5:[“”、“”、“值-5-3”]]
var finalArray=[String]（）
让keys=Array（dict.keys）。排序（按：{return$0这是我将如何解决它的，但它确实使用flatMap:

var dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]

let newArray = dict.keys.flatMap({
    dict[$0]?.first(where: { !$0.isEmpty })
}).sorted()

print(newArray)

输出：

[“Value-1-1”、“Value-2-2”、“Value-3-1”、“Value-4-1”、“Value-5-3”]

这是我将如何解决它的，但它确实使用flatMap：

var dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]

let newArray = dict.keys.flatMap({
    dict[$0]?.first(where: { !$0.isEmpty })
}).sorted()

print(newArray)

输出：

[“Value-1-1”、“Value-2-2”、“Value-3-1”、“Value-4-1”、“Value-5-3”]

按键对字典进行排序，以获得定义良好的顺序，
这将提供一个键/值对数组。
然后使用
compactMap（）
和
首先（其中：）
将每一对映射到
值数组中的第一个非空字符串（如果存在）：

let dict=[1:[“Value-1-1”，“”，“”，“”]，
2:[，“值-2-2”，“值-2-3”]，
3:[“值-3-1”、“值-3-2”、“值-3-2”]，
4:[“Value-4-1”、“Value-4-3”、“Value-4-1”，
5:[“”、“”、“值-5-3”]]
让数组=dict.sorted（按：{$0.key<$1.key}）
.compactMap{$0.value.first（其中：{！$0.isEmpty}）}
打印（数组）/[“Value-1-1”、“Value-2-2”、“Value-3-1”、“Value-4-1”、“Value-5-3”]
按键对字典进行排序，以获得明确的顺序，
这将提供一个键/值对数组。
然后使用
compactMap（）
和
首先（其中：）
将每一对映射到
值数组中的第一个非空字符串（如果存在）：

let dict=[1:[“Value-1-1”，“”，“”，“”]，
2:[，“值-2-2”，“值-2-3”]，
3:[“值-3-1”、“值-3-2”、“值-3-2”]，
4:[“Value-4-1”、“Value-4-3”、“Value-4-1”，
5:[“”、“”、“值-5-3”]]
让数组=dict.sorted（按：{$0.key<$1.key}）
.compactMap{$0.value.first（其中：{！$0.isEmpty}）}
打印（数组）/[“Value-1-1”、“Value-2-2”、“Value-3-1”、“Value-4-1”、“Value-5-3”]
这里有一条清晰的管道，可以满足您的需求：

let dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]

let result = dict.values // we only care about values
    .compactMap { value in value.first(where: { !$0.isEmpty }) } // extract the first non-empty string, filter out nils (i.e. empty arrays or arrays made up only of empty strings
    .sorted() // sort the results
print(result) // ["Value-1-1", "Value-2-2", "Value-3-1", "Value-4-1", "Value-5-3"]

管道的每一步，即使是以简洁的形式写的，都传达了意图，使得人们更容易对它所做的事情产生共鸣

我们可以在第2步中变得更简洁一些：
compactMap{$0.first{！$0.isEmpty}
，在我看来，这应该和上面的代码一样简洁，但这可能只是我的感觉。
这里有一个很好的清晰的管道，可以实现您想要的：

let dict = [1: ["Value-1-1", "", ""],
            2: ["", "Value-2-2", "Value-2-3"],
            3: ["Value-3-1", "Value-3-2", ""],
            4: ["Value-4-1", "", "Value-4-3"],
            5: ["", "", "Value-5-3"]]

let result = dict.values // we only care about values
    .compactMap { value in value.first(where: { !$0.isEmpty }) } // extract the first non-empty string, filter out nils (i.e. empty arrays or arrays made up only of empty strings
    .sorted() // sort the results
print(result) // ["Value-1-1", "Value-2-2", "Value-3-1", "Value-4-1", "Value-5-3"]

管道的每一步，即使是以简洁的形式写的，都传达了意图，使得人们更容易对它所做的事情产生共鸣

我们可以通过第2步变得更简洁一些：
compactMap{$0.first{$0.isEmpty}
，在我看来，这应该和上面的代码一样简洁，但是这可能只是我的感觉。
“…第一个值不是nil…”-
“
是一个空字符串而不是“nil”。为什么不使用map（）这就是我来这里的原因。我想知道在这种情况下你是否可以避免使用map…如果不能-那么你应该如何避免空字符串并用map循环它？这个数据结构代表什么？它完全奇怪，看起来很难使用。@Alexander key-产品id，值-产品图像是否有组织n这样的顺序。“…第一个值不是nil…”–
“
是一个空字符串，不是“nil”。为什么不使用map（）这就是我来这里的原因。我想知道在这种情况下你是否可以避免使用map…如果不能-那么你应该如何避免空字符串并用map循环它？这个数据结构代表什么？它完全奇怪，看起来很难使用。@Alexander key-产品id，值-产品图像是否有组织n这样的顺序。或者：
如果让anArrayValue=dict[aKey]，让firstNonEmptyValue=anArrayValue.first（其中：…）
来摆脱可选的链接。很好的一点。我认为XCode本身添加了“？”，没有注意到。@Larme，谢谢你的回答。标记为已接受，因为这对我作为初学者来说更容易理解。或者更简单地说：
let keys=dict.keys.sorted（）
@Larme-我还有一个问题：如果你的值为空，它会跳过，但是如果我