Получить первое значение словаря Swift

Question

У меня есть такой тип словаря:

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"]

Я прочитал этот вопрос здесь - SO Вопрос , но он не охватывает пустые значения, и мне интересно, можно ли обойтись без карты, но с использованием циклов in или while?

Буду признателен, если кто-нибудь предоставит пример кода такого цикла. Спасибо!

Answer 1

Вот хороший и понятный конвейер, который достигает того, что вы хотите:

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 } }, IMO, это было бы так же кратко, как и приведенный выше код, однако это могло бы быть только мое чувство.

Answer 2

Вот как я бы решил, но он использует 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)

Выход:

["Значение-1-1", "Значение-2-2", "Значение-3-1", "Значение-4-1", "Значение-5-3"]]

Answer 3

Сортируйте словарь по ключам, чтобы получить четко определенный порядок, это дает массив пар ключ / значение.Затем используйте compactMap() и first(where:), чтобы сопоставить каждую пару первой непустой строке в массиве значений (если она существует):

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 array = dict.sorted(by: { $0.key < $1.key })
    .compactMap { $0.value.first(where: { !$0.isEmpty }) }

print(array) // ["Value-1-1", "Value-2-2", "Value-3-1", "Value-4-1", "Value-5-3"]

Answer 4

Это должно сработать:
Хорошей инициативой при обучении программированию является использование алгоритма для цикла вместо магических методов, таких как map() и т. Д., Алгоритмическим способом. Они делают цикл, но они неявные.
Здесь я использовал sorted() (потому что это может быть немного длиннее).
Я также использовал first(where:), он находит первое непустое значение. Его также можно заменить циклом 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)")

См. @ Martin R answer для версии с методами "более высокого уровня", но более сложными для понимания для дебютантов (цепочки, замыкания и т. Д.). Он делает то же самое, просто более компактный, менее явный.