Удаление из массива при перечислении в Swift?

Я хочу перечислить массив в Swift и удалить определенные элементы. Мне интересно, безопасно ли это делать, а если нет, то как я должен этого добиться.

В настоящее время я бы сделал это:

for (index, aString: String) in enumerate(array) {
    //Some of the strings...
    array.removeAtIndex(index)
}

В Swift 2 это довольно просто использовать enumerateи reverse.

var a = [1,2,3,4,5,6]
for (i,num) in a.enumerate().reverse() {
    a.removeAtIndex(i)
}
print(a)

Вы можете рассмотреть filterспособ:

var theStrings = ["foo", "bar", "zxy"]

// Filter only strings that begins with "b"
theStrings = theStrings.filter { $0.hasPrefix("b") }

Параметр filter- это просто замыкание, которое принимает экземпляр типа массива (в данном случае String) и возвращает Bool. Когда в результате trueон сохраняет элемент, в противном случае элемент отфильтровывается.

В Swift 3 и 4 это будет:

С числами, согласно ответу Джонстона:

var a = [1,2,3,4,5,6]
for (i,num) in a.enumerated().reversed() {
   a.remove(at: i)
}
print(a)

Со строками в качестве вопроса OP:

var b = ["a", "b", "c", "d", "e", "f"]

for (i,str) in b.enumerated().reversed()
{
    if str == "c"
    {
        b.remove(at: i)
    }
}
print(b)

Однако теперь в Swift 4.2 или новее есть даже лучший и более быстрый способ , рекомендованный Apple в WWDC2018:

var c = ["a", "b", "c", "d", "e", "f"]
c.removeAll(where: {$0 == "c"})
print(c)

Этот новый способ имеет несколько преимуществ:

1. Это быстрее, чем реализации с filter.
2. Это избавляет от необходимости переворачивать массивы.
3. Он удаляет элементы на месте и, таким образом, обновляет исходный массив вместо выделения и возврата нового массива.

Когда элемент с определенным индексом удаляется из массива, все последующие элементы изменят свою позицию (и индекс), потому что они сдвигаются назад на одну позицию.

Итак, лучший способ - перемещаться по массиву в обратном порядке - и в этом случае я предлагаю использовать традиционный цикл for:

for var index = array.count - 1; index >= 0; --index {
    if condition {
        array.removeAtIndex(index)
    }
}

Однако, на мой взгляд, лучший подход - использовать filterметод, описанный @perlfly в его ответе.

Нет, изменять массивы во время перечисления небезопасно, код выйдет из строя.

Если вы хотите удалить только несколько объектов, вы можете использовать эту filterфункцию.

Либо создайте изменяемый массив для хранения элементов, которые нужно удалить, а затем, после перечисления, удалите эти элементы из оригинала. Или создайте копию массива (неизменяемую), перечислите ее и удалите объекты (не по индексу) из оригинала при перечислении.

Традиционный цикл for можно заменить простым циклом while, который полезен, если вам также необходимо выполнить некоторые другие операции с каждым элементом перед удалением.

var index = array.count-1
while index >= 0 {

     let element = array[index]
     //any operations on element
     array.remove(at: index)

     index -= 1
}

Я рекомендую установить для элементов значение nil во время перечисления, а после завершения удалить все пустые элементы с помощью метода массивов filter ().

Чтобы добавить, если у вас есть несколько массивов, и каждый элемент в индексе N массива A связан с индексом N массива B, вы все равно можете использовать метод, обращающий нумерованный массив (как в прошлых ответах). Но помните, что при доступе к элементам других массивов и их удалении не нужно их отменять.

Like so, (one can copy and paste this on Playground)

var a = ["a", "b", "c", "d"]
var b = [1, 2, 3, 4]
var c = ["!", "@", "#", "$"]

// remove c, 3, #

for (index, ch) in a.enumerated().reversed() {
    print("CH: \(ch). INDEX: \(index) | b: \(b[index]) | c: \(c[index])")
    if ch == "c" {
        a.remove(at: index)
        b.remove(at: index)
        c.remove(at: index)
    }
}

print("-----")
print(a) // ["a", "b", "d"]
print(b) // [1, 2, 4]
print(c) // ["!", "@", "$"]