Rimozione dall'array durante l'enumerazione in Swift?

Desidero enumerare un array in Swift e rimuovere determinati elementi. Mi chiedo se sia sicuro e, in caso contrario, come dovrei ottenerlo.

Attualmente, lo farei:

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

In Swift 2 è abbastanza facile usare enumeratee reverse.

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

Potresti considerare il filtermodo:

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

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

Il parametro di filterè solo una chiusura che accetta un'istanza di tipo array (in questo caso String) e restituisce un file Bool. Quando il risultato è truemantiene l'elemento, altrimenti l'elemento viene filtrato.

In Swift 3 e 4 , questo sarebbe:

Con i numeri, secondo la risposta di Johnston:

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

Con stringhe come domanda dell'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)

Tuttavia, ora in Swift 4.2 o versioni successive, esiste anche un modo migliore e più veloce versioni consigliato da Apple nel WWDC2018:

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

Questo nuovo modo ha diversi vantaggi:

1. È più veloce delle implementazioni con filter .
2. Elimina la necessità di invertire gli array.
3. Rimuove gli elementi sul posto e quindi aggiorna l'array originale invece di allocare e restituire un nuovo array.

Quando un elemento a un certo indice viene rimosso da un array, tutti gli elementi successivi avranno la loro posizione (e indice) cambiati, perché tornano indietro di una posizione.

Quindi il modo migliore è navigare nell'array in ordine inverso, e in questo caso suggerisco di utilizzare un ciclo for tradizionale:

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

Tuttavia secondo me l'approccio migliore è usare il filtermetodo, come descritto da @perlfly nella sua risposta.

No, non è sicuro modificare gli array durante l'enumarazione, il codice andrà in crash.

Se vuoi eliminare solo pochi oggetti puoi usare la filterfunzione.

Crea un array modificabile per memorizzare gli elementi da eliminare e quindi, dopo l'enumerazione, rimuovi quegli elementi dall'originale. Oppure creare una copia dell'array (immutabile), enumerarla e rimuovere gli oggetti (non per indice) dall'originale durante l'enumerazione.

Il tradizionale ciclo for potrebbe essere sostituito con un semplice ciclo while, utile se è necessario eseguire anche altre operazioni su ogni elemento prima della rimozione.

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

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

     index -= 1
}

Consiglio di impostare gli elementi su nil durante l'enumerazione e dopo aver completato rimuovere tutti gli elementi vuoti utilizzando il metodo arrays filter ().

Solo per aggiungere, se hai più array e ogni elemento nell'indice N dell'array A è correlato all'indice N dell'array B, puoi comunque utilizzare il metodo che inverte l'array enumerato (come le risposte precedenti). Ma ricorda che quando accedi ed elimini gli elementi degli altri array, non è necessario invertirli.

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) // ["!", "@", "$"]