Wie wird die Schaltfläche zum Löschen angezeigt, wenn ich auf einem wische UITableViewCell? Das Ereignis wird nie ausgelöst und die Schaltfläche zum Löschen wird nie angezeigt.

Während des Startvorgangs in (-viewDidLoad or in storyboard)do:

self.tableView.allowsMultipleSelectionDuringEditing = NO;

Überschreiben, um die bedingte Bearbeitung der Tabellenansicht zu unterstützen. Dies muss nur implementiert werden, wenn Sie NOfür einige Artikel zurückkehren möchten. Standardmäßig können alle Elemente bearbeitet werden.

- (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
    }    
}

Diese Antwort wurde auf Swift 3 aktualisiert

Ich finde es immer schön, ein sehr einfaches, in sich geschlossenes Beispiel zu haben, damit beim Lernen einer neuen Aufgabe nichts angenommen wird. Diese Antwort dient zum Löschen von UITableViewZeilen. Das Projekt läuft folgendermaßen ab:

Dieses Projekt basiert auf dem UITableView-Beispiel für Swift .

Fügen Sie den Code hinzu

Erstellen Sie ein neues Projekt und ersetzen Sie den Code ViewController.swift durch den folgenden.

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.
        }
    }

}

Die Einzelschlüsselmethode im obigen Code, die das Löschen von Zeilen ermöglicht, ist die letzte. Hier ist es wieder zur Betonung:

// 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

Fügen Sie UITableViewdem Story Controller im Storyboard ein hinzu. Verwenden Sie das automatische Layout, um die vier Seiten der Tabellenansicht an den Rändern des View Controllers zu befestigen. Steuern Sie das Ziehen von der Tabellenansicht im Storyboard auf die @IBOutlet var tableView: UITableView!Zeile im Code.

Fertig

Das ist alles. Sie sollten jetzt in der Lage sein, Ihre App auszuführen und Zeilen zu löschen, indem Sie nach links wischen und auf "Löschen" tippen.

Variationen

Ändern Sie den Text der Schaltfläche "Löschen"

Fügen Sie die folgende Methode hinzu:

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

Benutzerdefinierte Schaltflächenaktionen

Fügen Sie die folgende Methode hinzu.

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]
}

Beachten Sie, dass dies nur unter iOS 8 verfügbar ist. Weitere Informationen finden Sie in dieser Antwort .

Aktualisiert für iOS 11

Aktionen können mithilfe von Methoden, die der UITableViewDelegate-API in iOS 11 hinzugefügt wurden, entweder vor oder nach der Zelle platziert werden.

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])
 }

Weiterführende Literatur

• So erstellen Sie eine wischbare Tabellenansichtszelle mit Aktionen - ohne Muttern mit Bildlaufansichten
• Dokumentation

Dieser Code zeigt, wie das Löschen implementiert wird.

#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];
    }
}

Fügen Sie in Ihrer Initialisierungsüberschreibung optional die folgende Zeile hinzu, um das Schaltflächenelement Bearbeiten anzuzeigen:

self.navigationItem.leftBarButtonItem = self.editButtonItem;

Ich hatte ein Problem, das ich gerade gelöst habe, also teile ich es, da es jemandem helfen kann.

Ich habe eine UITableView und habe die angezeigten Methoden hinzugefügt, damit Swipe gelöscht werden kann:

- (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
    }    
}

Ich arbeite an einem Update, mit dem ich die Tabelle in den Bearbeitungsmodus versetzen und die Mehrfachauswahl aktivieren kann. Dazu habe ich den Code aus dem TableMultiSelect- Beispiel von Apple hinzugefügt . Sobald ich das zum Laufen gebracht hatte, stellte ich fest, dass mein Löschen die Löschfunktion nicht mehr funktionierte.

Es stellt sich heraus, dass das Hinzufügen der folgenden Zeile zu viewDidLoad das Problem war:

self.tableView.allowsMultipleSelectionDuringEditing = YES;

Mit dieser Zeile würde die Mehrfachauswahl funktionieren, das Wischen zum Löschen jedoch nicht. Ohne die Linie war es umgekehrt.

Die Reparatur:

Fügen Sie Ihrem viewController die folgende Methode hinzu:

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

In Ihrer Methode, mit der die Tabelle in den Bearbeitungsmodus versetzt wird (z. B. durch Drücken einer Taste), sollten Sie Folgendes verwenden:

[self setEditing:YES animated:YES];

anstatt:

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

Dies bedeutet, dass die Mehrfachauswahl nur aktiviert ist, wenn sich die Tabelle im Bearbeitungsmodus befindet.

Unten hilft Ihnen UITableViewDataSource beim Löschen durch Wischen

- (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 ist ein NSMutableArray und lädt dann die tableView neu

Schnell

 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()
    }
}

In iOS 8 und Swift 2.0 versuchen Sie dies bitte,

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]
}

Die Antwort von @ Kurbz ist großartig, aber ich möchte diese Notiz hinterlassen und hoffe, dass diese Antwort den Menschen Zeit sparen kann.

Ich hatte gelegentlich diese Zeilen in meinem Controller und sie führten dazu, dass die Wischfunktion nicht funktionierte.

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

Wenn Sie UITableViewCellEditingStyleInsertoder UITableViewCellEditingStyleNoneals Bearbeitungsstil verwenden, funktioniert die Wischfunktion nicht. Sie können nur UITableViewCellEditingStyleDeleteden Standardstil verwenden.

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]
}

Dies kann auch in SWIFT unter Verwendung des folgenden Verfahrens erreicht werden

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

Swift 3

Sie müssen lediglich diese beiden Funktionen aktivieren:

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()
    }

}

Ich weiß, ist eine alte Frage, aber die Antwort von @Kurbz benötigt diese nur für Xcode 6.3.2 und SDK 8.3

Ich muss hinzufügen [tableView beginUpdates]und [tableView endUpdates](danke an @ bay.phillips hier )

// 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];
}

Wenn Sie eine Zelle Ihrer Tabellenansicht entfernen, müssen Sie auch Ihr Array-Objekt am Index x entfernen.

Ich denke, Sie können es mit einer Wischgeste entfernen. In der Tabellenansicht wird der Delegat aufgerufen:

- (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];
    }    
}

Nach dem Entfernen des Objekts. Sie müssen die Tabellenansicht neu laden. Fügen Sie Ihrem Code die folgende Zeile hinzu:

[tableView reloadData];

Danach haben Sie die Zeile erfolgreich gelöscht. Und wenn Sie die Ansicht neu laden oder Daten zur DataSource hinzufügen, ist das Objekt nicht mehr vorhanden.

Für alle anderen ist die Antwort von Kurbz richtig.

Ich wollte Sie nur daran erinnern, dass die Delegatenfunktion nicht ausreicht, wenn Sie das Objekt aus dem DataSource-Array entfernen möchten.

Ich hoffe ich habe dir geholfen.

- (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];
    }    
}    

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]
}

Für Swift schreiben Sie einfach diesen Code

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

Schreiben Sie für Ziel C einfach diesen Code

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

Aktivieren Sie für swift4-Code zunächst die Bearbeitung:

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

Anschließend fügen Sie dem Bearbeitungsdelegierten eine Löschaktion hinzu:

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]
}

Swift 4,5

Um eine Zelle beim Wischen zu löschen, gibt es zwei integrierte Methoden von UITableView. Schreiben Sie diese Methode in die TableView dataSource-Erweiterung.

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
    }

Wenn Sie unterschiedliche Datenquellen verwenden, müssen Sie die Rückrufe der Delegierten in eine UITableViewDiffableDataSourceUnterklasse verschieben. Zum Beispiel:

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)
            }
        }
    }
}