web-dev-qa-db-fra.com

Comment échanger des éléments dans le tableau Swift?

J'ai un tableau simple comme:

var cellOrder = [1,2,3,4]

Je veux échanger des éléments comme supposer un deuxième élément avec le premier élément.

Et le résultat sera:

[2,1,3,4]

Je sais que nous pouvons utiliser exchangeObjectAtIndex avec NSMutableArray Mais je veux utiliser Swift array. Toutes les façons de faire de même avec Swift = [Int] tableau?

iosarraysswiftnsmutablearray
33
Dharmesh

Utilisez swap:

var cellOrder = [1,2,3,4]
swap(&cellOrder[0], &cellOrder[1])

Alternativement, vous pouvez simplement l'affecter en tant que Tuple:

(cellOrder[0], cellOrder[1]) = (cellOrder[1], cellOrder[0])
60
Rob Napier

Swift 4

swapAt(_:_:) :

cellOrder.swapAt(index0, index1)
43
hstdt

Une option est:

cellOrder[0...1] = [cellOrder[1], cellOrder[0]]
7
Hermann Klecker

Détails

  • Xcode version 10.3 (10G8), Swift 5

Variante de base (dangereuse mais rapide)

nsafe - signifie que vous pouvez attraper une erreur fatale lorsque vous essayez de faire un échange en utilisant un index incorrect (hors de la plage) de l'élément dans le tableau

var array = [1,2,3,4]
// way 1
(array[0],array[1]) = (array[1],array[0])
// way 2
array.swapAt(2, 3)

print(array)

Solution de swap sûr

  • enregistrer la tentative de swap (vérification des index)
  • possible de savoir quel indice mal

n'utilisez pas cette solution lorsque vous devez échanger de nombreux éléments dans la boucle. Cette solution valide les deux index (i, j) (ajoutez un peu de logique supplémentaire) dans les fonctions de swap, ce qui rendra votre code plus lent que l'utilisation de arr.swapAt(i,j) standard. Il est parfait pour les swaps simples ou pour les petits tableaux. Mais, si vous décidez d'utiliser la fonction arr.swapAt(i,j) standard, vous devrez vérifier les index manuellement ou vous assurer que les index ne sont pas hors de la plage.

import Foundation

enum SwapError: Error {
    case wrongFirstIndex
    case wrongSecondIndex
}

extension Array {
    mutating func detailedSafeSwapAt(_ i: Int, _ j: Int) throws {
        if !(0..<count ~= i) { throw SwapError.wrongFirstIndex }
        if !(0..<count ~= j) { throw SwapError.wrongSecondIndex }
        swapAt(i, j)
    }

    @discardableResult mutating func safeSwapAt(_ i: Int, _ j: Int) -> Bool {
        do {
            try detailedSafeSwapAt(i, j)
            return true
        } catch {
            return false
        }
    }
}

Utilisation de swap sûr

result = arr.safeSwapAt(5, 2)

//or
if arr.safeSwapAt(5, 2) {
    //Success
} else {
    //Fail
}

//or
arr.safeSwapAt(4, 8)

//or
do {
    try arr.detailedSafeSwapAt(4, 8)
} catch let error as SwapError {
    switch error {
    case .wrongFirstIndex: print("Error 1")
    case .wrongSecondIndex: print("Error 2")
    }
}

Échantillon complet de swap sûr

var arr = [10,20,30,40,50]
print("Original array: \(arr)")

print("\nSample 1 (with returning Bool = true): ")
var result = arr.safeSwapAt(1, 2)
print("Result: " + (result ? "Success" : "Fail"))
print("Array: \(arr)")

print("\nSample 2 (with returning Bool = false):")
result = arr.safeSwapAt(5, 2)
print("Result: " + (result ? "Success" : "Fail"))
print("Array: \(arr)")

print("\nSample 3 (without returning value):")
arr.safeSwapAt(4, 8)
print("Array: \(arr)")

print("\nSample 4 (with catching error):")
do {
    try arr.detailedSafeSwapAt(4, 8)
} catch let error as SwapError {
    switch error {
    case .wrongFirstIndex: print("Error 1")
    case .wrongSecondIndex: print("Error 2")
    }
}
print("Array: \(arr)")


print("\nSample 5 (with catching error):")
do {
    try arr.detailedSafeSwapAt(7, 1)
} catch let error as SwapError {
    print(error)
}
print("Array: \(arr)")

Exemple de journal complet de swap sécurisé

Original array: [10, 20, 30, 40, 50]

Sample 1 (with returning Bool = true): 
Result: Success
Array: [10, 30, 20, 40, 50]

Sample 2 (with returning Bool = false):
Result: Fail
Array: [10, 30, 20, 40, 50]

Sample 3 (without returning value):
Array: [10, 30, 20, 40, 50]

Sample 4 (with catching error):
Error 2
Array: [10, 30, 20, 40, 50]

Sample 5 (with catching error):
wrongFirstIndex
Array: [10, 30, 20, 40, 50]
0
Vasily Bodnarchuk

Utilisez la méthode swapAt,

var arr = [10,20,30,40,50]
arr.swapAt(2, 3)

Utilisez l'index pour permuter l'élément.

0
Sureshkumar Linganathan