UITableViewCell, afficher le bouton de suppression lors du glissement


568

Comment puis-je faire apparaître le bouton Supprimer lorsque je glisse sur un UITableViewCell? L'événement n'est jamais déclenché et le bouton Supprimer n'apparaît jamais.


1
Quiconque cherche une réponse détaillée et mise à jour, faites
Munib

Voir ma réponse Swift 4 pour une question similaire qui montre jusqu'à 3 façons différentes de créer un balayage pour supprimer des actions pour UITableViewCells.
Imanou Petit

J'ai posé cette question il y a 8 ans ... veuillez supprimer cette question, elle est massivement dépassée. Swift n'existait même pas!
TheLearner

pouvons-nous fixer la hauteur des boutons latéraux? par exemple: ma cellule est 150 et je veux que le bouton soit affiché seulement 50.0f est-ce possible?
Suhas Arvind Patil

cela fonctionne très bien sur les lignes, mais des indices sur la façon d'intégrer les sections?
Frostmourne

Réponses:


1035

Lors du démarrage dans (-viewDidLoad or in storyboard)do:

self.tableView.allowsMultipleSelectionDuringEditing = NO;

Remplacez pour prendre en charge la modification conditionnelle de la vue tabulaire. Cela ne doit être implémenté que si vous allez revenir NOpour certains articles. Par défaut, tous les éléments sont modifiables.

- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    // Return YES if you want the specified item to be editable.
    return YES;
}

// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        //add code here for when you hit delete
    }    
}

94
Cela fonctionne, mais ... - (BOOL) tableView: (UITableView *) tableView canEditRowAtIndexPath: (NSIndexPath *) indexPath ... n'a besoin d'être implémenté que si vous allez retourner NO pour certains éléments. Par défaut, tous les éléments sont modifiables, vous n'avez donc pas besoin de l'implémenter si vous retournez toujours OUI.
Thanos Diacakis

24
Il est également important de savoir: ce sont les méthodes UITableViewDataSource et PAS les méthodes UITableViewDelegate.
Dave Albert


12
Juste pour être clair - Vous DEVEZ remplacer tableView: commitEditingStyle: forRowAtIndexPath: sinon le geste de balayage ne sera pas reconnu et rien ne se passera lorsque vous essayez de supprimer.
Chris

Cela n'a pas fonctionné pour moi (au début). Je devais également régler self.tableView.allowsMultipleSelectionDuringEditing = NO;pour que le coup gauche fonctionne. Cela me semble être un bug car la table n'est PAS en état d'édition. Cette option ne doit appliquer que "PendantModification". Cependant, cela fonctionne maintenant et je l'ai défini sur OUI chaque fois que la table entre en état d'édition.
osxdirk

118

Cette réponse a été mise à jour vers Swift 3

Je pense toujours que c'est bien d'avoir un exemple très simple et autonome pour que rien ne soit supposé lorsque j'apprends une nouvelle tâche. Cette réponse est celle pour la suppression de UITableViewlignes. Le projet fonctionne comme ceci:

entrez la description de l'image ici

Ce projet est basé sur l' exemple UITableView pour Swift .

Ajoutez le code

Créez un nouveau projet et remplacez le code ViewController.swift par ce qui suit.

import UIKit
class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {

    // These strings will be the data for the table view cells
    var animals: [String] = ["Horse", "Cow", "Camel", "Pig", "Sheep", "Goat"]

    let cellReuseIdentifier = "cell"

    @IBOutlet var tableView: UITableView!

    override func viewDidLoad() {
        super.viewDidLoad()

        // It is possible to do the following three things in the Interface Builder
        // rather than in code if you prefer.
        self.tableView.register(UITableViewCell.self, forCellReuseIdentifier: cellReuseIdentifier)
        tableView.delegate = self
        tableView.dataSource = self
    }

    // number of rows in table view
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.animals.count
    }

    // create a cell for each table view row
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

        let cell:UITableViewCell = self.tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as UITableViewCell!

        cell.textLabel?.text = self.animals[indexPath.row]

        return cell
    }

    // method to run when table view cell is tapped
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        print("You tapped cell number \(indexPath.row).")
    }

    // this method handles row deletion
    func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {

        if editingStyle == .delete {

            // remove the item from the data model
            animals.remove(at: indexPath.row)

            // delete the table view row
            tableView.deleteRows(at: [indexPath], with: .fade)

        } else if editingStyle == .insert {
            // Not used in our example, but if you were adding a new row, this is where you would do it.
        }
    }

}

La méthode à clé unique dans le code ci-dessus qui permet la suppression de lignes est la dernière. Ici, c'est encore pour souligner:

// this method handles row deletion
func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {

    if editingStyle == .delete {

        // remove the item from the data model
        animals.remove(at: indexPath.row)

        // delete the table view row
        tableView.deleteRows(at: [indexPath], with: .fade)

    } else if editingStyle == .insert {
        // Not used in our example, but if you were adding a new row, this is where you would do it.
    }
}

Storyboard

Ajoutez un UITableViewau contrôleur de vue dans le storyboard. Utilisez la disposition automatique pour épingler les quatre côtés de la vue de table sur les bords du contrôleur de vue. Contrôlez le glissement de la vue de table dans le storyboard jusqu'à la @IBOutlet var tableView: UITableView!ligne dans le code.

Fini

C'est tout. Vous devriez pouvoir exécuter votre application maintenant et supprimer des lignes en balayant vers la gauche et en appuyant sur "Supprimer".


Variations

Modifier le texte du bouton "Supprimer"

entrez la description de l'image ici

Ajoutez la méthode suivante:

func tableView(_ tableView: UITableView, titleForDeleteConfirmationButtonForRowAt indexPath: IndexPath) -> String? {
    return "Erase"
}

Actions des boutons personnalisés

entrez la description de l'image ici

Ajoutez la méthode suivante.

func tableView(_ tableView: UITableView, editActionsForRowAt indexPath: IndexPath) -> [UITableViewRowAction]? {

    // action one
    let editAction = UITableViewRowAction(style: .default, title: "Edit", handler: { (action, indexPath) in
        print("Edit tapped")
    })
    editAction.backgroundColor = UIColor.blue

    // action two
    let deleteAction = UITableViewRowAction(style: .default, title: "Delete", handler: { (action, indexPath) in
        print("Delete tapped")
    })
    deleteAction.backgroundColor = UIColor.red

    return [editAction, deleteAction]
}

Notez que cela n'est disponible qu'à partir d'iOS 8. Voir cette réponse pour plus de détails.

Mis à jour pour iOS 11

Les actions peuvent être placées en tête ou en fin de cellule à l'aide de méthodes ajoutées à l'API UITableViewDelegate dans iOS 11.

func tableView(_ tableView: UITableView,
                leadingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration?
 {
     let editAction = UIContextualAction(style: .normal, title:  "Edit", handler: { (ac:UIContextualAction, view:UIView, success:(Bool) -> Void) in
             success(true)
         })
editAction.backgroundColor = .blue

         return UISwipeActionsConfiguration(actions: [editAction])
 }

 func tableView(_ tableView: UITableView,
                trailingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration?
 {
     let deleteAction = UIContextualAction(style: .normal, title:  "Delete", handler: { (ac:UIContextualAction, view:UIView, success:(Bool) -> Void) in
         success(true)
     })
     deleteAction.backgroundColor = .red

     return UISwipeActionsConfiguration(actions: [deleteAction])
 }

Lectures complémentaires


merci pour les exemples et le code. Je suis maintenant prêt à implémenter la fonction de suppression. Pouvez-vous me dire à quoi sert la ligne "self.tableView.registerClass (..." que vous avez ajoutée à viewDidLoad ()? Et quel est l'équivalent de cela dans le générateur d'interface? Ce n'était pas dans l'exemple de cellule personnalisé. On dirait que nous spécifions cellReuseIdentifier deux fois maintenant. Merci!
rockhammer

Si la ligne .registerClass est incluse, la compilation échoue
rockhammer

@rockhammer, vous avez raison, vous n'avez pas besoin (apparemment ne pouvez pas) définir l'identifiant de réutilisation des cellules dans le code et le générateur d'interface. Choisissez simplement un moyen selon vos préférences. Bien que ce projet repose sur cette base UITableViewun , ce projet est tout à fait se seul et vous n'avez pas besoin de faire quoi que ce soit qui ne soit pas décrit ici. La raison pour laquelle j'ai commencé à le définir dans le code est qu'il nécessite moins d'explications dans mes réponses. Je devrais revenir en arrière et modifier l'exemple de base pour utiliser du code aussi.
Suragch

Comment pourrait-on mettre en œuvre un balayage vers la droite? Dire qu'un coup gauche "rejette" quelque chose et qu'un coup droit "accepte" quelque chose dans la cellule?
Munib

1
@ return0, pour autant que je sache, la fonctionnalité de balayage vers la droite n'est pas intégrée, vous devez donc la créer à partir de zéro. Consultez cet article pour des idées pour vous aider à démarrer si vous voulez essayer. Cependant, je ne recommanderais pas de faire cela car ce n'est pas une action standard à laquelle un utilisateur s'attendrait. Au lieu de cela, je montrerais deux choix de boutons sur un balayage vers la gauche, comme dans la section d'action des boutons personnalisés dans ma réponse ci-dessus.
Suragch

70

Ce code montre comment implémenter la suppression.

#pragma mark - UITableViewDataSource

// Swipe to delete.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        [_chats removeObjectAtIndex:indexPath.row];
        [tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationAutomatic];
    }
}

Facultativement, dans votre remplacement d'initialisation, ajoutez la ligne ci-dessous pour afficher l'élément du bouton Modifier:

self.navigationItem.leftBarButtonItem = self.editButtonItem;

Vous devez implémenter cette méthode. Le contenu à l'intérieur doit correspondre à tout ce qui a du sens dans votre cas d'utilisation. Dans le code ci-dessus, _chats contient les données de support pour la vue de table. Une fois que l'utilisateur clique sur supprimer, l'objet de discussion individuel doit être supprimé de _chat afin que la source de données reflète alors le nouveau nombre de lignes (sinon, une exception est levée).
ewcy

25

J'ai eu un problème que je viens de résoudre, donc je le partage car cela peut aider quelqu'un.

J'ai un UITableView et j'ai ajouté les méthodes indiquées pour permettre au balayage de supprimer:

- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    // Return YES if you want the specified item to be editable.
    return YES;
}

// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        //add code here for when you hit delete
    }    
}

Je travaille sur une mise à jour qui me permet de mettre la table en mode édition et permet la multisélection. Pour ce faire, j'ai ajouté le code de l' exemple TableMultiSelect d'Apple . Une fois que j'ai commencé à travailler, j'ai constaté que mon balayage de la fonction de suppression avait cessé de fonctionner.

Il s'avère que l'ajout de la ligne suivante à viewDidLoad était le problème:

self.tableView.allowsMultipleSelectionDuringEditing = YES;

Avec cette ligne, la multisélection fonctionnerait, mais pas le balayage à supprimer. Sans la ligne, c'était l'inverse.

La solution:

Ajoutez la méthode suivante à votre viewController:

- (void)setEditing:(BOOL)editing animated:(BOOL)animated
{
    self.tableView.allowsMultipleSelectionDuringEditing = editing; 
    [super setEditing:editing animated:animated];
}

Ensuite, dans votre méthode qui met la table en mode édition (à partir d'une pression sur un bouton par exemple), vous devez utiliser:

[self setEditing:YES animated:YES];

au lieu de:

[self.tableView setEditing:YES animated:YES];

Cela signifie que la sélection multiple n'est activée que lorsque la table est en mode édition.


C'était utile. J'avais défini allowMultipleSelection dans le Storyboard. Cela l'a corrigé.
Mark Suman

1
Cela a résolu un problème qui nous rendait fous. Je comprends maintenant que "glisser pour supprimer" et "suppression par lots en mode édition" sont fondamentalement mutuellement exclusifs et vous devez contrôler cela lorsque vous entrez en mode d'édition / leavin. Merci beaucoup d'avoir fait des recherches à ce sujet!
fbitterlich

18

Ci-dessous, UITableViewDataSource vous aidera pour la suppression par balayage

- (BOOL)tableView:(UITableView *)tableView canEditRowAtIndexPath:(NSIndexPath *)indexPath {
    // Return YES if you want the specified item to be editable.
    return YES;
}

- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        [arrYears removeObjectAtIndex:indexPath.row];
        [tableView reloadData];
    }
}

arrYears est un NSMutableArray, puis rechargez la tableView

Rapide

 func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
            return true
        }

func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
    if editingStyle == UITableViewCellEditingStyleDelete {
        arrYears.removeObjectAtIndex(indexPath.row)
        tableView.reloadData()
    }
}

Mais c'est UITableViewDataSource
HotJard

17

Dans iOS 8 et Swift 2.0, veuillez essayer ceci,

override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
   // let the controller to know that able to edit tableView's row 
   return true
}

override func tableView(tableView: UITableView, commitEdittingStyle editingStyle UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath)  {
   // if you want to apply with iOS 8 or earlier version you must add this function too. (just left in blank code)
}

override func tableView(tableView: UITableView, editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]?  {
   // add the action button you want to show when swiping on tableView's cell , in this case add the delete button.
   let deleteAction = UITableViewRowAction(style: .Default, title: "Delete", handler: { (action , indexPath) -> Void in

   // Your delete code here.....
   .........
   .........
   })

   // You can set its properties like normal button
   deleteAction.backgroundColor = UIColor.redColor()

   return [deleteAction]
}

C'est une bonne réponse, avec cela, vous pouvez également configurer plusieurs actions.
Munib

11

@ La réponse de Kurbz est impressionnante, mais je veux laisser cette note et j'espère que cette réponse pourra faire gagner du temps aux gens.

J'ai parfois eu ces lignes dans mon contrôleur, et elles ont rendu la fonction de balayage inopérante.

- (UITableViewCellEditingStyle)tableView:(UITableView *)tableView editingStyleForRowAtIndexPath:(NSIndexPath *)indexPath{
    return UITableViewCellEditingStyleNone; 
}

Si vous utilisez UITableViewCellEditingStyleInsertou UITableViewCellEditingStyleNonecomme style d'édition, la fonction de balayage ne fonctionne pas. Vous pouvez uniquement utiliser UITableViewCellEditingStyleDelete, qui est le style par défaut.


1
Dans mon cas, je voulais pouvoir glisser pour supprimer, mais aussi pouvoir déplacer mes cellules. Une cellule mobile obtient également ce bouton "supprimer" sur le côté gauche de la cellule, ce qui ne correspondait pas à ma conception et pour le supprimer, le style d'édition devrait être .none. J'ai résolu ce problème en "if tableView.isEditing {return .none} else {return .delete}"

J'ai sauvé mon mec axz. Merci :)
Sourav Chandra

9

Swift 4

func tableView(_ tableView: UITableView, editActionsForRowAt indexPath: IndexPath) -> [UITableViewRowAction]? {
    let delete = UITableViewRowAction(style: .destructive, title: "delete") { (action, indexPath) in
        // delete item at indexPath
    tableView.deleteRows(at: [indexPath], with: .fade)

    }
    return [delete]
}

1
Ok, cela fait apparaître l'onglet de suppression, mais ne le supprime pas lorsque vous appuyez dessus. Vous devez supprimer l'objet dans la source de données et recharger la table oui?
user3069232

oui "// supprimer l'élément à indexPath" place la logique de votre ligne de suppression basée sur indexPath
Pratik Lad

8

En outre, cela peut être réalisé dans SWIFT en utilisant la méthode suivante

func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
    if (editingStyle == UITableViewCellEditingStyle.Delete){
        testArray.removeAtIndex(indexPath.row)
        goalsTableView.deleteRowsAtIndexPaths([indexPath], withRowAnimation: UITableViewRowAnimation.Automatic)
    }
}

8

Swift 3

Il vous suffit d'activer ces deux fonctions:

func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {

    return true

}

func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCellEditingStyle, forRowAt indexPath: IndexPath) {

    if editingStyle == UITableViewCellEditingStyle.delete {
        tableView.reloadData()
    }

}

7

Je sais que c'est une vieille question, mais la réponse @Kurbz a juste besoin de cela pour Xcode 6.3.2 et SDK 8.3

J'ai besoin d'ajouter [tableView beginUpdates]et [tableView endUpdates](merci à @ bay.phillips ici )

// Override to support editing the table view.
- (void)tableView:(UITableView *)tableView commitEditingStyle: (UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    // Open "Transaction"
    [tableView beginUpdates];

    if (editingStyle == UITableViewCellEditingStyleDelete) {
        // your code goes here
        //add code here for when you hit delete
        [tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationFade];
     }

    // Close "Transaction"
    [tableView endUpdates];
}

6

Lorsque vous supprimez une cellule de votre table, vous devez également supprimer votre objet tableau à l'index x.

Je pense que vous pouvez le supprimer en utilisant un geste de balayage. La vue de table appellera le délégué:

- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
    if (editingStyle == UITableViewCellEditingStyleDelete) {
        //add code here for when you hit delete
        [dataSourceArray removeObjectAtIndex:indexPath.row];
    }    
}

Après avoir retiré l'objet. Vous devez recharger l'utilisation de tableview. Ajoutez la ligne suivante dans votre code:

[tableView reloadData];

après cela, vous avez supprimé la ligne avec succès. Et lorsque vous rechargez la vue ou ajoutez des données au DataSource, l'objet ne sera plus là.

Pour tous les autres, la réponse de Kurbz est correcte.

Je voulais seulement vous rappeler que la fonction déléguée ne sera pas suffisante si vous souhaitez supprimer l'objet du tableau DataSource.

J'espère que je vous ai aidé.



6
- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath 
{
    if (editingStyle == UITableViewCellEditingStyleDelete)
    {
        //add code here for when you hit delete
        [dataSourceArray removeObjectAtIndex:indexPath.row];
        [tableView deleteRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationAutomatic];
    }    
}    

dataSourceArray est le tableau d'où provient le contenu des cellules
Rahul K Rajan

2

Swift 2.2:

override func tableView(tableView: UITableView, canEditRowAtIndexPath indexPath: NSIndexPath) -> Bool {
    return true
}

override func tableView(tableView: UITableView,
    editActionsForRowAtIndexPath indexPath: NSIndexPath) -> [UITableViewRowAction]? {
    let delete = UITableViewRowAction(style: UITableViewRowActionStyle.Default, title: "DELETE"){(UITableViewRowAction,NSIndexPath) -> Void in

    print("Your action when user pressed delete")
}
let edit = UITableViewRowAction(style: UITableViewRowActionStyle.Normal, title: "EDIT"){(UITableViewRowAction,NSIndexPath) -> Void in

    print("Your action when user pressed edit")
}
    return [delete, block]
}

2

Pour Swift, il suffit d'écrire ce code

func tableView(tableView: UITableView, commitEditingStyle editingStyle: UITableViewCellEditingStyle, forRowAtIndexPath indexPath: NSIndexPath) {
        if editingStyle == .Delete {
            print("Delete Hit")
        }
}

Pour l'objectif C, il suffit d'écrire ce code

- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath {
       if (editingStyle == UITableViewCellEditingStyleDelete) {           
            NSLog(@"index: %@",indexPath.row);
           }
}

2

pour le code swift4, activez d'abord la modification:

func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
    return true
}

puis vous ajoutez une action de suppression au délégué d'édition:

func tableView(_ tableView: UITableView, editActionsForRowAt indexPath: IndexPath) -> [UITableViewRowAction]? {
    let action = UITableViewRowAction(style: .destructive, title: "Delete") { (_, index) in
        // delete model object at the index
        self.models[index.row]
        // then delete the cell
        tableView.beginUpdates()
        tableView.deleteRows(at: [index], with: .automatic)
        tableView.endUpdates()

    }
    return [action]
}

0

Swift 4,5

Pour supprimer une cellule lors du balayage, il existe deux méthodes intégrées de UITableView. Écrivez cette méthode dans l'extension TableView dataSource.

func tableView(_ tableView: UITableView, trailingSwipeActionsConfigurationForRowAt indexPath: IndexPath) -> UISwipeActionsConfiguration? {
        let delete = deleteProperty(at: indexPath)
        return UISwipeActionsConfiguration(actions: [delete])
    }

//Declare this method in Viewcontroller Main and modify according to your need

func deleteProperty(at indexpath: IndexPath) -> UIContextualAction {
        let action = UIContextualAction(style: .destructive, title: "Delete") { (action, view, completon) in
            self.yourArray.remove(at: indexpath) //Removing from array at selected index

            completon(true)
        action.backgroundColor = .red //cell background color
    }
        return action
    }

0

Si vous adoptez des sources de données variables, vous devrez déplacer les rappels des délégués vers une UITableViewDiffableDataSourcesous - classe. Par exemple:

class DataSource: UITableViewDiffableDataSource<SectionType, ItemType> {

    override func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
        return true
    }

    override func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
        if editingStyle == .delete {
            if let identifierToDelete = itemIdentifier(for: indexPath) {
                var snapshot = self.snapshot()
                snapshot.deleteItems([identifierToDelete])
                apply(snapshot)
            }
        }
    }
}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.