ta odpowiedź została zaktualizowana do Swift 3

Zawsze myślę, że miło jest mieć bardzo prosty, samodzielny przykład, tak, że nic nie jest zakładane, gdy uczę się nowego zadania. Ta odpowiedź dotyczy usuwania UITableView wierszy. Projekt działa tak:

Ten projekt jest oparty na przykładzie UITableView dla Swift.

Dodaj kod

Utwórz nowy projekt i zastąp Kontroler ViewController.kod swift z następujące.

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

}

Metoda pojedynczego klucza w powyższym kodzie, która umożliwia usuwanie wierszy, jest ostatnią. Tu znowu dla podkreślenia:

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

Dodaj UITableView do kontrolera widoku w storyboardzie. Układ automatyczny pozwala przypiąć cztery strony widoku stołu do krawędzi kontrolera widoku. Sterowanie przeciąganiem z widoku tabeli w storyboardzie do linii @IBOutlet var tableView: UITableView! w kodzie.

Zakończone

Wariacje

Zmień tekst przycisku "Usuń"

Dodać następującą metodę:

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

Niestandardowe działania przycisków

Dodaj następującą metodę.

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

Zauważ, że jest to dostępne tylko z iOS 8. Zobacz ta odpowiedź Aby uzyskać więcej szczegółów.

Aktualizacja dla systemu iOS 11

Akcje mogą być umieszczane na początku lub na końcu komórki za pomocą metod dodanych do interfejsu API UITableViewDelegate w systemie 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])
 }

Czytaj dalej

• Jak Zrobić Komórkę Widoku Tabeli Z Działaniami-Bez Szaleństw Z Widokami Przewijania
• dokumentacja

Ten kod pokazuje jak zaimplementować delete.

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

Opcjonalnie, w nadpisaniu inicjalizacji, dodaj poniższą linię, aby wyświetlić pozycję przycisku Edytuj:

self.navigationItem.leftBarButtonItem = self.editButtonItem;

Uwaga: nie mam wystarczającej reputacji, aby dodać komentarz w odpowiedzi od Kurbz.

Odpowiedź od Kurbza jest słuszna. Ale dla mnie to nigdy nie zadziałało.

Po pewnym dochodzeniu, zdałem sobie sprawę, że przesunięcie w celu usunięcia ma miejsce, gdy nie edytuje widoku tabeli..

Nigdy nie widziałem tego jednoznacznie stwierdzonego jako takiego. O ile się nie mylę, nie znalazłem innego sposobu, żeby to zadziałało.

Podczas edycji pojawi się kontrolka Usuń i / lub zmień kolejność.

Miałem problem, który właśnie udało mi się rozwiązać, więc dzielę się nim, ponieważ może to komuś pomóc.

Mam UITableView i dodałem pokazane metody pozwalające na usunięcie:

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

Pracuję nad aktualizacją, która pozwala mi przełączyć tabelę w tryb edycji i włączyć multiselect. Aby to zrobić, dodałem kod z tabeli Apple Tabelamultiselect sample. Gdy już to działa, odkryłem, że moje przesunięcie funkcja usuwania przestała działać.

Okazuje się, że problem polegał na dodaniu następującej linii do viewDidLoad:

self.tableView.allowsMultipleSelectionDuringEditing = YES;

Z tą linią, multiselect będzie działał, ale przesunięcie, aby usunąć nie. bez linii było odwrotnie.

Fix:

Dodaj następującą metodę do kontrolera viewController:

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

Następnie w metodzie, która wprowadza tabelę w tryb edycji (na przykład po naciśnięciu przycisku) należy użyć:

[self setEditing:YES animated:YES];

Zamiast:

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

Oznacza to, że multiselect jest włączone tylko wtedy, gdy tabela jest w trybie edycji.

Poniżej UITableViewDataSource pomoże Ci przesunąć delete

- (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 jest NSMutableArray, a następnie przeładuj tableView

Swift

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

W iOS 8 i Swift 2.0 spróbuj tego,

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

@Kurbz odpowiedź jest super, ale chcę zostawić tę notkę i mam nadzieję, że ta odpowiedź zaoszczędzi ludziom trochę czasu.

Czasami miałem te linie w kontrolerze i sprawiły, że funkcja przesuwania nie działała.

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

Jeśli używasz UITableViewCellEditingStyleInsert lub UITableViewCellEditingStyleNone jako stylu edycji, funkcja przesuwania nie działa. Możesz używać tylko UITableViewCellEditingStyleDelete, który jest domyślnym stylem.

Można to również osiągnąć w systemie SWIFT za pomocą metody w następujący sposób

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

Wystarczy włączyć te dwie funkcje:

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

}

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

Gdy usuniesz komórkę tableview, musisz również usunąć obiekt tablicy z indeksem x.

Myślę, że można go usunąć za pomocą gestu machnięcia. Widok tabeli wywoła delegata:

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

Po usunięciu obiektu. Musisz ponownie załadować widok tableview. Dodaj następujący wiersz w kodzie:

[tableView reloadData];

Następnie wiersz został pomyślnie usunięty. A po przeładowaniu widoku lub dodaniu danych do DataSource obiekt już tam nie będzie.

Dla wszystkich innych jest odpowiedź od Kurbz poprawne.

Chciałem tylko przypomnieć, że funkcja delegata nie wystarczy, jeśli chcesz usunąć obiekt z tablicy DataSource.

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

Wiem, że to stare pytanie, ale @ Kurbz odpowiedz tylko potrzebuje tego dla Xcode 6.3.2 i SDK 8.3

Muszę dodać [tableView beginUpdates] i [tableView endUpdates] (dzięki @ bay.phillips here )

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

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

Dla Swifta wystarczy napisać ten kod

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

Dla Objective C, po prostu napisz ten kod

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

Dla kodu swift4, najpierw Włącz edycję:

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

Następnie dodajesz akcję delete do delegata edycji:

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