Как объединить необязательный массив в другой массив в Swift?

Question

Я знаю, это звучит смешно, но сейчас я серьезно сбит с толку.В основном у меня есть две переменные, одна [Data] и одна Array<Data>?

Мне нужно объединить эти две.Я попытался сделать var1+var2, который дает мне ошибки, скажем, не может делать двоичные операции над этими двумя.Так что я погуглил, я могу использовать метод добавления, теперь возникают другие вопросы:

1. метод добавления добавлен в автозаполнение, поэтому я не уверен, стоит ли его использовать.
2. Даже если я пытаюсь использовать его (пока он вычеркивается), он все равно дает мне ошибки

Вот код и ошибки, которые я получаю:

var a1:[Data] //a return value from other function
var a2:Array<Data>? //a parameter that's passed in

a1.append(contentsOf:a2) //Cannot use mutating member on immutable value: function call returns immutable value
a1+a2 //Binary operator '+' cannot be applied to operands of type 'Array<Data>' and 'Array<Data>?'

Обамассивы могут быть пустыми, как я могу объединить эти два массива?

Answer 1

Ответ Sulthan - быстрое решение, но если вы много делаете в своем коде, вы можете перегрузить +, чтобы обработать его автоматически:

extension Array {
    static func + (lhs: [Element], rhs: [Element]?) -> [Element] {
        return lhs + (rhs ?? [])
    }
}

Answer 2

Вы также можете расширить RangeReplaceable Collection и реализовать собственный метод добавления, а также операторы сложения и дополнения, как указано ниже:

extension RangeReplaceableCollection {
    public mutating func append<S: Sequence>(contentsOf sequence: S?) where Element == S.Element {
        guard let sequence = sequence else { return }
        reserveCapacity(count + sequence.underestimatedCount)
        append(contentsOf: sequence)
    }
}

---

extension RangeReplaceableCollection {
    public static func += <S: Sequence>(lhs: inout Self, rhs: S?) where Element == S.Element {
        guard let rhs = rhs else { return }
        lhs.reserveCapacity(lhs.count + rhs.underestimatedCount)
        lhs.append(contentsOf: rhs)
    }
}

---

extension RangeReplaceableCollection {
    public static func + <S: Sequence>(lhs: Self, rhs: S?) -> Self where Element == S.Element {
        guard let rhs = rhs else { return lhs }
        var result = Self()
        result.reserveCapacity(lhs.count + rhs.underestimatedCount)
        result.append(contentsOf: lhs)
        result.append(contentsOf: rhs)
        return result
    }
}

---

Тестирование игровой площадки

var a1 = "abc"
let a2: String? = "d"
let a3: String? = nil
let a4: [Character]? = ["e","f"]

a1 + a2 + a3 + a4  // "abcdef"

a1 + a2
print("a1:", a1)
a1 += a2
print("a1:", a1)
a1 + a3
print("a1:", a1)
a1 += a3
print("a1:", a1)
a1 + a4
print("a1:", a1)
a1 += a4
print("a1:", a1)

a1.append(contentsOf: ["e","f","g"])
print("a1:", a1)
a1.append(contentsOf: "hijkl")
print("a1:", a1)

Answer 3

Один из массивов является необязательным.Вы должны как-то обработать возможное значение nil.

Простое решение, использующее nil-coalescing:

let concatenated = var1 + (var2 ?? [])

или, немного более сложное:

var concatenated = var1

if let var2 = var2 {
   concatenated.append(var2)
}

Конечно, есть и другие возможные решения.