Extension de tableau pour supprimer un objet par valeur

extension Array {
    func removeObject<T where T : Equatable>(object: T) {
        var index = find(self, object)
        self.removeAtIndex(index)
    }
}

Cependant, j'obtiens une erreur sur var index = find(self, object)

«T» n'est pas convertible en «T»

J'ai aussi essayé avec cette signature de méthode: func removeObject(object: AnyObject)cependant, j'obtiens la même erreur:

'AnyObject' n'est pas convertible en 'T'

Quelle est la bonne façon de procéder?

À partir de Swift 2 , cela peut être réalisé avec une méthode d'extension de protocole . removeObject()se définit comme une méthode sur tous les types conforme à RangeReplaceableCollectionType(en particulier sur Array) si les éléments de la collection sont Equatable:

extension RangeReplaceableCollectionType where Generator.Element : Equatable {

    // Remove first collection element that is equal to the given `object`:
    mutating func removeObject(object : Generator.Element) {
        if let index = self.indexOf(object) {
            self.removeAtIndex(index)
        }
    }
}

Exemple:

var ar = [1, 2, 3, 2]
ar.removeObject(2)
print(ar) // [1, 3, 2]

Mise à jour pour Swift 2 / Xcode 7 beta 2: Comme Airspeed Velocity l'a remarqué dans les commentaires, il est désormais possible d'écrire une méthode sur un type générique plus restrictif sur le modèle, donc la méthode pourrait désormais être définie comme une extension de Array:

extension Array where Element : Equatable {

    // ... same method as above ...
}

L'extension de protocole a toujours l'avantage d'être applicable à un plus grand ensemble de types.

Mise à jour pour Swift 3:

extension Array where Element: Equatable {

    // Remove first collection element that is equal to the given `object`:
    mutating func remove(object: Element) {
        if let index = index(of: object) {
            remove(at: index)
        }
    }
}

Vous ne pouvez pas écrire une méthode sur un type générique qui est plus restrictif sur le modèle.

REMARQUE : à partir de Swift 2.0, vous pouvez maintenant écrire des méthodes qui sont plus restrictives sur le modèle. Si vous avez mis à niveau votre code vers 2.0, consultez les autres réponses ci-dessous pour de nouvelles options pour implémenter cela à l'aide d'extensions.

La raison pour laquelle vous obtenez l'erreur 'T' is not convertible to 'T' est que vous définissez en fait un nouveau T dans votre méthode qui n'est pas du tout lié au T. d'origine. Si vous souhaitez utiliser T dans votre méthode, vous pouvez le faire sans le spécifier dans votre méthode.

La raison pour laquelle vous obtenez la deuxième erreur 'AnyObject' is not convertible to 'T' est que toutes les valeurs possibles pour T ne sont pas toutes des classes. Pour qu'une instance soit convertie en AnyObject, il doit s'agir d'une classe (ce ne peut pas être une structure, une énumération, etc.).

Votre meilleur pari est d'en faire une fonction qui accepte le tableau comme argument:

func removeObject<T : Equatable>(object: T, inout fromArray array: [T]) {
}

Ou au lieu de modifier le tableau d'origine, vous pouvez rendre votre méthode plus sûre pour les threads et réutilisable en renvoyant une copie:

func arrayRemovingObject<T : Equatable>(object: T, fromArray array: [T]) -> [T] {
}

Comme alternative que je ne recommande pas, vous pouvez faire échouer votre méthode en silence si le type stocké dans le tableau ne peut pas être converti en modèle de méthodes (qui peut être égalisé). (Pour plus de clarté, j'utilise U au lieu de T pour le modèle de la méthode):

extension Array {
    mutating func removeObject<U: Equatable>(object: U) {
        var index: Int?
        for (idx, objectToCompare) in enumerate(self) {
            if let to = objectToCompare as? U {
                if object == to {
                    index = idx
                }
            }
        }

        if(index != nil) {
            self.removeAtIndex(index!)
        }
    }
}

var list = [1,2,3]
list.removeObject(2) // Successfully removes 2 because types matched
list.removeObject("3") // fails silently to remove anything because the types don't match
list // [1, 3]

Edit Pour surmonter l'échec silencieux, vous pouvez renvoyer le succès sous forme de valeur booléenne:

extension Array {
  mutating func removeObject<U: Equatable>(object: U) -> Bool {
    for (idx, objectToCompare) in self.enumerate() {  //in old swift use enumerate(self) 
      if let to = objectToCompare as? U {
        if object == to {
          self.removeAtIndex(idx)
          return true
        }
      }
    }
    return false
  }
}
var list = [1,2,3,2]
list.removeObject(2)
list
list.removeObject(2)
list

brièvement et de manière concise:

func removeObject<T : Equatable>(object: T, inout fromArray array: [T]) 
{
    var index = find(array, object)
    array.removeAtIndex(index!)
}

Après avoir lu tout ce qui précède, à mon avis, la meilleure réponse est:

func arrayRemovingObject<U: Equatable>(object: U, # fromArray:[U]) -> [U] {
  return fromArray.filter { return $0 != object }
}

Échantillon:

var myArray = ["Dog", "Cat", "Ant", "Fish", "Cat"]
myArray = arrayRemovingObject("Cat", fromArray:myArray )

Extension de tableau Swift 2 (xcode 7b4):

extension Array where Element: Equatable {  
  func arrayRemovingObject(object: Element) -> [Element] {  
    return filter { $0 != object }  
  }  
}  

Échantillon:

var myArray = ["Dog", "Cat", "Ant", "Fish", "Cat"]
myArray = myArray.arrayRemovingObject("Cat" )

Mise à jour Swift 3.1

J'y suis revenu maintenant que Swift 3.1 est sorti. Vous trouverez ci-dessous une extension qui fournit des variantes exhaustives, rapides, mutantes et créatrices.

extension Array where Element:Equatable {
    public mutating func remove(_ item:Element ) {
        var index = 0
        while index < self.count {
            if self[index] == item {
                self.remove(at: index)
            } else {
                index += 1
            }
        }
    }

    public func array( removing item:Element ) -> [Element] {
        var result = self
        result.remove( item )
        return result
    }
}

Échantillons:

// Mutation...
      var array1 = ["Cat", "Dog", "Turtle", "Cat", "Fish", "Cat"]
      array1.remove("Cat")
      print(array1) //  ["Dog", "Turtle", "Socks"]

// Creation...
      let array2 = ["Cat", "Dog", "Turtle", "Cat", "Fish", "Cat"]
      let array3 = array2.array(removing:"Cat")
      print(array3) // ["Dog", "Turtle", "Fish"]

Avec les extensions de protocole, vous pouvez le faire,

extension Array where Element: Equatable {
    mutating func remove(object: Element) {
        if let index = indexOf({ $0 == object }) {
            removeAtIndex(index)
        }
    }
}

Même fonctionnalité pour les cours,

Swift 2

extension Array where Element: AnyObject {
    mutating func remove(object: Element) {
        if let index = indexOf({ $0 === object }) {
            removeAtIndex(index)
        }
    }
}

Swift 3

extension Array where Element: AnyObject {
    mutating func remove(object: Element) {
        if let index = index(where: { $0 === object }) {
             remove(at: index)
        }
    }
}

Mais si une classe implémente Equatable, cela devient ambigu et le compilateur renvoie une erreur.

Avec l'utilisation d'extensions de protocole dans Swift 2.0

extension _ArrayType where Generator.Element : Equatable{
    mutating func removeObject(object : Self.Generator.Element) {
        while let index = self.indexOf(object){
            self.removeAtIndex(index)
        }
    }
}

qu'en est-il du filtrage? ce qui suit fonctionne assez bien même avec [AnyObject].

import Foundation
extension Array {
    mutating func removeObject<T where T : Equatable>(obj: T) {
        self = self.filter({$0 as? T != obj})
    }

}

Il existe une autre possibilité de supprimer un élément d'un tableau sans avoir une utilisation non sécurisée possible, car le type générique de l'objet à supprimer ne peut pas être le même que le type du tableau. L'utilisation d'options n'est pas non plus la solution idéale car elles sont très lentes. Vous pouvez donc utiliser une fermeture comme elle est déjà utilisée lors du tri d'un tableau par exemple.

//removes the first item that is equal to the specified element
mutating func removeFirst(element: Element, equality: (Element, Element) -> Bool) -> Bool {
    for (index, item) in enumerate(self) {
        if equality(item, element) {
            self.removeAtIndex(index)
            return true
        }
    }
    return false
}

Lorsque vous étendez la Arrayclasse avec cette fonction, vous pouvez supprimer des éléments en procédant comme suit:

var array = ["Apple", "Banana", "Strawberry"]
array.removeFirst("Banana") { $0 == $1 } //Banana is now removed

Cependant, vous pouvez même supprimer un élément uniquement s'il a la même adresse mémoire (uniquement pour les classes conformes au AnyObjectprotocole, bien sûr):

let date1 = NSDate()
let date2 = NSDate()
var array = [date1, date2]
array.removeFirst(NSDate()) { $0 === $1 } //won't do anything
array.removeFirst(date1) { $0 === $1 } //array now contains only 'date2'

La bonne chose est que vous pouvez spécifier le paramètre à comparer. Par exemple, lorsque vous avez un tableau de tableaux, vous pouvez spécifier la fermeture d'égalité comme{ $0.count == $1.count } et le premier tableau ayant la même taille que celui à supprimer est supprimé du tableau.

Vous pouvez même raccourcir l'appel de fonction en ayant la fonction as mutating func removeFirst(equality: (Element) -> Bool) -> Bool, puis remplacer if-evaluation par equality(item)et appeler la fonction par array.removeFirst({ $0 == "Banana" })par exemple.

Pas besoin de prolonger:

var ra = [7, 2, 5, 5, 4, 5, 3, 4, 2]

print(ra)                           // [7, 2, 5, 5, 4, 5, 3, 4, 2]

ra.removeAll(where: { $0 == 5 })

print(ra)                           // [7, 2, 4, 3, 4, 2]

if let i = ra.firstIndex(of: 4) {
    ra.remove(at: i)
}

print(ra)                           // [7, 2, 3, 4, 2]

if let j = ra.lastIndex(of: 2) {
    ra.remove(at: j)
}

print(ra)                           // [7, 2, 3, 4]

En utilisant indexOfau lieu d'un forou enumerate:

extension Array where Element: Equatable {

   mutating func removeElement(element: Element) -> Element? {
      if let index = indexOf(element) {
         return removeAtIndex(index)
      }
      return nil
   }

   mutating func removeAllOccurrencesOfElement(element: Element) -> Int {
       var occurrences = 0
       while true {
          if let index = indexOf(element) {
             removeAtIndex(index)
             occurrences++
          } else {
             return occurrences
          }
       }
   }   
}

Peut-être que je n'ai pas compris la question.

Pourquoi cela ne fonctionnerait-il pas?

import Foundation
extension Array where Element: Equatable {
    mutating func removeObject(object: Element) {
        if let index = self.firstIndex(of: object) {
            self.remove(at: index)
        }
    }
}

var testArray = [1,2,3,4,5,6,7,8,9,0]
testArray.removeObject(object: 6)
let newArray = testArray

var testArray2 = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "0"]
testArray2.removeObject(object: "6")
let newArray2 = testArray2

J'ai finalement fini avec le code suivant.

extension Array where Element: Equatable {

    mutating func remove<Element: Equatable>(item: Element) -> Array {
        self = self.filter { $0 as? Element != item }
        return self
    }

}

J'ai réussi à supprimer un [String:AnyObject]d'un tableau [[String:AnyObject]]en implémentant un compte en dehors d'une boucle for pour représenter l'index depuis .findet je ne suis .filterpas compatible avec [String:AnyObject].

let additionValue = productHarvestChoices[trueIndex]["name"] as! String
var count = 0
for productHarvestChoice in productHarvestChoices {
  if productHarvestChoice["name"] as! String == additionValue {
    productHarvestChoices.removeAtIndex(count)
  }
  count = count + 1
}

Implémentation dans Swift 2:

extension Array {
  mutating func removeObject<T: Equatable>(object: T) -> Bool {
    var index: Int?
    for (idx, objectToCompare) in self.enumerate() {
      if let toCompare = objectToCompare as? T {
        if toCompare == object {
          index = idx
          break
        }
      }
    }
    if(index != nil) {
      self.removeAtIndex(index!)
      return true
    } else {
      return false
    }
  }
}

J'ai pu le faire fonctionner avec:

extension Array {
    mutating func removeObject<T: Equatable>(object: T) {
        var index: Int?
        for (idx, objectToCompare) in enumerate(self) {
            let to = objectToCompare as T
            if object == to {
                index = idx
            }
        }

        if(index) {
            self.removeAtIndex(index!)
        }
    }
}