Swift'de numaralandırma sırasında diziden çıkarılsın mı?

Swift'de bir dizi aracılığıyla numaralandırmak ve belirli öğeleri kaldırmak istiyorum. Bunun güvenli olup olmadığını ve değilse bunu nasıl başarmam gerektiğini merak ediyorum.

Şu anda bunu yapıyorum:

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

Swift 2'de bunu kullanmak oldukça kolaydır enumerateve reverse.

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

Bir filteryolunu düşünebilirsiniz :

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

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

Parametresi, filterdizi tipi bir örnek alan (bu durumda String) ve bir Bool. Sonuç olduğu truezaman elemanı tutar, aksi takdirde eleman filtrelenir.

In Swift 3. ve 4. , bu şöyle olacaktır:

Johnston'ın cevabına göre sayılarla:

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

İle dizeleri OP'ın soru olarak:

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

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

Ancak şimdi Swift 4.2 veya sonraki sürümlerde, Apple tarafından WWDC2018'de önerilen daha iyi ve daha hızlı bir yol var:

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

Bu yeni yöntemin birçok avantajı vardır:

1. İle uygulamalardan daha hızlıdır filter.
2. Dizileri ters çevirme ihtiyacını ortadan kaldırır.
3. Öğeleri yerinde kaldırır ve böylece yeni bir dizi tahsis etmek ve geri döndürmek yerine orijinal diziyi günceller.

Belirli bir dizindeki bir öğe bir diziden çıkarıldığında, sonraki tüm öğelerin konumları (ve dizinleri) değişir, çünkü bir konum geri kayarlar.

Bu yüzden en iyi yol, dizide ters sırada gezinmektir - ve bu durumda geleneksel bir for döngüsü kullanmanızı öneririm:

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

Ancak bence en iyi yaklaşım, filter@perlfly'nin cevabında anlattığı gibi yöntemi kullanmaktır .

Hayır, numaralandırma sırasında dizileri değiştirmek güvenli değildir, kodunuz çökecektir.

Yalnızca birkaç nesneyi silmek istiyorsanız, filterişlevi kullanabilirsiniz .

Ya silinecek öğeleri depolamak için değiştirilebilir bir dizi oluşturun ve ardından numaralandırmadan sonra bu öğeleri orijinalden kaldırın. Veya dizinin bir kopyasını oluşturun (değişmez), bunu numaralandırın ve numaralandırma sırasında orijinalden nesneleri (dizine göre değil) kaldırın.

Geleneksel for döngüsü basit bir while döngüsü ile değiştirilebilir; bu, çıkarmadan önce her öğe üzerinde başka işlemler de gerçekleştirmeniz gerekiyorsa yararlıdır.

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

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

     index -= 1
}

Numaralandırma sırasında öğeleri nil olarak ayarlamanızı ve tamamlandıktan sonra tüm boş öğeleri arrays filter () yöntemini kullanarak kaldırmanızı öneririm.

Eklemek gerekirse, birden fazla diziniz varsa ve A dizisinin N dizinindeki her öğe, B dizisinin N diziniyle ilişkiliyse, o zaman numaralandırılmış diziyi tersine çevirmek için yöntemi kullanmaya devam edebilirsiniz (geçmişteki yanıtlar gibi). Ancak diğer dizilerin öğelerine erişirken ve bunları silerken bunları tersine çevirmeye gerek olmadığını unutmayın.

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