Jak uzyskać indexpath.row, gdy element jest aktywowany?

Mam widok tabeli z przyciskami i chcę użyć indexpath.row, gdy jeden z nich zostanie dotknięty. To jest to, co obecnie mam, ale zawsze jest to 0

var point = Int()
func buttonPressed(sender: AnyObject) {
    let pointInTable: CGPoint =         sender.convertPoint(sender.bounds.origin, toView: self.tableView)
    let cellIndexPath = self.tableView.indexPathForRowAtPoint(pointInTable)
    println(cellIndexPath)
    point = cellIndexPath!.row
    println(point)
}

giorashc prawie miał to w swojej odpowiedzi, ale przeoczył fakt, że komórki mają dodatkową contentViewwarstwę. Dlatego musimy zejść o jedną warstwę głębiej:

guard let cell = sender.superview?.superview as? YourCellClassHere else {
    return // or fatalError() or whatever
}

let indexPath = itemTable.indexPath(for: cell)

Dzieje się tak, ponieważ w hierarchii widoków tableView ma komórki jako podglądy, które następnie mają swoje własne „widoki zawartości”, dlatego musisz uzyskać nadzór tego widoku zawartości, aby uzyskać samą komórkę. W rezultacie, jeśli twój przycisk znajduje się w podglądzie, a nie bezpośrednio w widoku zawartości komórki, będziesz musiał przejść o wiele warstw głębiej, aby uzyskać do niego dostęp.

Powyższe jest jednym z takich podejść, ale niekoniecznie najlepszym podejściem. Chociaż jest funkcjonalny, zakłada szczegóły dotyczące elementu, UITableViewCellktórego Apple nigdy nie dokumentował, takie jak hierarchia widoków. Może to ulec zmianie w przyszłości, a powyższy kod może w rezultacie zachowywać się nieprzewidywalnie.

W związku z powyższym, ze względu na długowieczność i niezawodność, zalecam przyjęcie innego podejścia. W tym wątku jest wiele alternatyw i zachęcam do przeczytania, ale mój osobisty faworyt jest następujący:

Przytrzymaj właściwość zamknięcia w swojej klasie komórek, niech metoda akcji przycisku wywoła this.

class MyCell: UITableViewCell {
    var button: UIButton!

    var buttonAction: ((Any) -> Void)?

    @objc func buttonPressed(sender: Any) {
        self.buttonAction?(sender)
    }
}

Następnie, kiedy utworzysz swoją komórkę w cellForRowAtIndexPath, możesz przypisać wartość do zamknięcia.

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! MyCell
    cell.buttonAction = { sender in
        // Do whatever you want from your button here.
    }
    // OR
    cell.buttonAction = buttonPressed(closure: buttonAction, indexPath: indexPath) // <- Method on the view controller to handle button presses.
}

Przenosząc tutaj swój kod obsługi, możesz skorzystać z już obecnego indexPathargumentu. Jest to znacznie bezpieczniejsze podejście niż to wymienione powyżej, ponieważ nie opiera się na nieudokumentowanych cechach.

Moje podejście do tego rodzaju problemu polega na użyciu protokołu delegata między komórką a widokiem tabeli. Pozwala to zachować procedurę obsługi przycisku w podklasie komórki, co umożliwia przypisanie procedury obsługi operacji retuszu do komórki prototypu w programie Interface Builder, jednocześnie zachowując logikę obsługi przycisku w kontrolerze widoku.

Pozwala również uniknąć potencjalnie kruchego podejścia do poruszania się po hierarchii widoków lub korzystania z tagwłaściwości, co powoduje problemy, gdy zmieniają się indeksy komórek (w wyniku wstawienia, usunięcia lub zmiany kolejności)

CellSubclass.swift

protocol CellSubclassDelegate: class {
    func buttonTapped(cell: CellSubclass)
}

class CellSubclass: UITableViewCell {

@IBOutlet var someButton: UIButton!

weak var delegate: CellSubclassDelegate?

override func prepareForReuse() {
    super.prepareForReuse()
    self.delegate = nil
}

@IBAction func someButtonTapped(sender: UIButton) {
    self.delegate?.buttonTapped(self)
}

ViewController.swift

class MyViewController: UIViewController, CellSubclassDelegate {

    @IBOutlet var tableview: UITableView!

    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

        let cell = tableView.dequeueReusableCellWithIdentifier("Cell", forIndexPath: indexPath) as! CellSubclass

        cell.delegate = self

        // Other cell setup

    } 

    //  MARK: CellSubclassDelegate

    func buttonTapped(cell: CellSubclass) {
        guard let indexPath = self.tableView.indexPathForCell(cell) else {
            // Note, this shouldn't happen - how did the user tap on a button that wasn't on screen?
            return
        }

        //  Do whatever you need to do with the indexPath

        print("Button tapped on row \(indexPath.row)")
    }
} 

UPDATE : Pobieranie indexPath komórki zawierającej przycisk (zarówno sekcja, jak i wiersz):

Korzystanie z pozycji przycisku

Wewnątrz buttonTappedmetody możesz pobrać położenie przycisku, przekonwertować go na współrzędną w tableView, a następnie pobrać indexPath wiersza o tej współrzędnej.

func buttonTapped(_ sender:AnyObject) {
    let buttonPosition:CGPoint = sender.convert(CGPoint.zero, to:self.tableView)
    let indexPath = self.tableView.indexPathForRow(at: buttonPosition)
}

UWAGA : Czasami możesz napotkać przypadek krawędzi, gdy użycie funkcji view.convert(CGPointZero, to:self.tableView)powoduje znalezienie nilwiersza w punkcie, nawet jeśli znajduje się tam komórka tableView. Aby to naprawić, spróbuj podać rzeczywistą współrzędną, która jest nieco odsunięta od początku, na przykład:

let buttonPosition:CGPoint = sender.convert(CGPoint.init(x: 5.0, y: 5.0), to:self.tableView)

Poprzednia odpowiedź: Używanie właściwości tagu (zwraca tylko wiersz)

Zamiast wspinać się po drzewach Superview, aby złapać wskaźnik do komórki, w której znajduje się przycisk UIButton, istnieje bezpieczniejsza, bardziej powtarzalna technika wykorzystująca właściwość button.tag wspomnianą przez Antonio powyżej, opisaną w tej odpowiedzi i pokazaną poniżej:

W cellForRowAtIndexPath:ustawiasz właściwość tagu:

button.tag = indexPath.row
button.addTarget(self, action: "buttonClicked:", forControlEvents: UIControlEvents.TouchUpInside)

Następnie w buttonClicked:funkcji odwołujesz się do tego tagu, aby pobrać wiersz indexPath, w którym znajduje się przycisk:

func buttonClicked(sender:UIButton) {
    let buttonRow = sender.tag
}

Wolę tę metodę, ponieważ odkryłem, że kołysanie się w drzewach nadzoru może być ryzykownym sposobem projektowania aplikacji. Ponadto w przypadku obiektywu C używałem tej techniki w przeszłości i byłem zadowolony z wyniku.

Użyj rozszerzenia UITableView, aby pobrać komórkę dla dowolnego widoku:

@ Paulw11 odpowiedź dotycząca skonfigurowania niestandardowego typu komórki z właściwością delegata, która wysyła komunikaty do widoku tabeli, jest dobrym rozwiązaniem, ale wymaga pewnej ilości pracy do skonfigurowania.

Myślę, że chodzenie po hierarchii widoku komórki w widoku tabeli w poszukiwaniu komórki to zły pomysł. Jest kruchy - jeśli później umieścisz przycisk w widoku w celach związanych z układem, kod prawdopodobnie się zepsuje.

Używanie tagów widoku jest również delikatne. Musisz pamiętać o skonfigurowaniu tagów podczas tworzenia komórki, a jeśli użyjesz tego podejścia w kontrolerze widoku, który używa tagów widoku do innego celu, możesz mieć zduplikowane numery znaczników, a kod może nie działać zgodnie z oczekiwaniami.

Utworzyłem rozszerzenie do UITableView, które pozwala uzyskać indexPath dla dowolnego widoku zawartego w komórce widoku tabeli. Zwraca wartość, Optionalktóra będzie nil, jeśli przekazany widok faktycznie nie mieści się w komórce widoku tabeli. Poniżej znajduje się plik źródłowy rozszerzenia w całości. Możesz po prostu umieścić ten plik w swoim projekcie, a następnie użyć dołączonej indexPathForView(_:)metody, aby znaleźć indexPath, która zawiera dowolny widok.

//
//  UITableView+indexPathForView.swift
//  TableViewExtension
//
//  Created by Duncan Champney on 12/23/16.
//  Copyright © 2016-2017 Duncan Champney.
//  May be used freely in for any purpose as long as this 
//  copyright notice is included.

import UIKit

public extension UITableView {
  
  /**
  This method returns the indexPath of the cell that contains the specified view
   
   - Parameter view: The view to find.
   
   - Returns: The indexPath of the cell containing the view, or nil if it can't be found
   
  */
  
    func indexPathForView(_ view: UIView) -> IndexPath? {
        let center = view.center
        let viewCenter = self.convert(center, from: view.superview)
        let indexPath = self.indexPathForRow(at: viewCenter)
        return indexPath
    }
}

Aby go użyć, możesz po prostu wywołać metodę w IBAction dla przycisku zawartego w komórce:

func buttonTapped(_ button: UIButton) {
  if let indexPath = self.tableView.indexPathForView(button) {
    print("Button tapped at indexPath \(indexPath)")
  }
  else {
    print("Button indexPath not found")
  }
}

(Zwróć uwagę, że indexPathForView(_:) funkcja będzie działać tylko wtedy, gdy przekazany obiekt widoku jest zawarty w komórce, która jest obecnie na ekranie. Jest to rozsądne, ponieważ widok, którego nie ma na ekranie, nie należy w rzeczywistości do określonej ścieżki indexPath; prawdopodobnie być przypisane do innego indexPath, gdy zawiera komórkę jest odtwarzana).

EDYTOWAĆ:

Możesz pobrać działający projekt demonstracyjny, który używa powyższego rozszerzenia z Github: TableViewExtension.git

Dla Swift2.1

Znalazłem sposób, żeby to zrobić, mam nadzieję, że to pomoże.

let point = tableView.convertPoint(CGPoint.zero, fromView: sender)

    guard let indexPath = tableView.indexPathForRowAtPoint(point) else {
        fatalError("can't find point in tableView")
    }

Rozwiązanie Swift 4:

Masz przycisk (myButton) lub inny widok w komórce. Przypisz tag w cellForRowAt w ten sposób

cell.myButton.tag = indexPath.row

Teraz w tobie TapFunction lub jakikolwiek inny. Pobierz go w ten sposób i zapisz w zmiennej lokalnej.

currentCellNumber = (sender.view?.tag)!

Następnie możesz użyć w dowolnym miejscu tego currentCellNumber, aby uzyskać indexPath.row wybranego przycisku.

Cieszyć się!

W Swift 4 po prostu użyj tego:

func buttonTapped(_ sender: UIButton) {
        let buttonPostion = sender.convert(sender.bounds.origin, to: tableView)

        if let indexPath = tableView.indexPathForRow(at: buttonPostion) {
            let rowIndex =  indexPath.row
        }
}

Bardzo proste uzyskanie szybkiej ścieżki indeksu 4, 5

let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! Cell
cell.btn.tag = indexPath.row
cell.btn.addTarget(self, action: "buttonTapped:", forControlEvents: 
UIControlEvents.TouchUpInside)

Jak uzyskać IndexPath Inside Btn Click:

func buttonTapped(_ sender: UIButton) {
     print(sender.tag)  
}

Ponieważ nadawcą programu obsługi zdarzeń jest sam przycisk, użyłbym właściwości przycisku tagdo przechowywania indeksu zainicjowanego w cellForRowAtIndexPath.

Ale przy odrobinie więcej pracy wykonałbym zupełnie inny sposób. Jeśli używasz niestandardowej komórki, podszedłbym do problemu:

• dodaj właściwość „indexPath” do niestandardowej komórki tabeli
• zainicjuj go w cellForRowAtIndexPath
• Przenieś procedurę obsługi zaczepu z kontrolera widoku do implementacji komórki
• użyj wzorca delegowania, aby powiadomić kontroler widoku o zdarzeniu tap, przekazując ścieżkę indeksu

Po zapoznaniu się z sugestią Paulw11 dotyczącą użycia funkcji wywołania zwrotnego delegata, chciałem ją nieco rozwinąć / przedstawić inną, podobną sugestię. Jeśli nie chcesz używać wzorca delegata, możesz szybko użyć domknięć w następujący sposób:

Twoja klasa komórkowa:

class Cell: UITableViewCell {
    @IBOutlet var button: UIButton!

    var buttonAction: ((sender: AnyObject) -> Void)?

    @IBAction func buttonPressed(sender: AnyObject) {
        self.buttonAction?(sender)
    }
}

Twoja cellForRowAtIndexPathmetoda:

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! Cell
    cell.buttonAction = { (sender) in
        // Do whatever you want from your button here.
    }
    // OR
    cell.buttonAction = buttonPressed // <- Method on the view controller to handle button presses.
}

Znalazłem bardzo łatwy sposób zarządzania dowolną komórką w tableView i collectionView przy użyciu klasy Model i działa to równie doskonale.

Obecnie istnieje znacznie lepszy sposób radzenia sobie z tym. To zadziała do zarządzania komórką i wartością.

Oto moje wyjście (zrzut ekranu), więc zobacz to:

1. Bardzo łatwo jest stworzyć klasę modelu , postępuj zgodnie z poniższą procedurą. Utwórz szybką klasę o nazwie RNCheckedModel, napisz kod jak poniżej.

class RNCheckedModel: NSObject {

    var is_check = false
    var user_name = ""

    }

2. stwórz swoją klasę komórek

class InviteCell: UITableViewCell {

    @IBOutlet var imgProfileImage: UIImageView!
    @IBOutlet var btnCheck: UIButton!
    @IBOutlet var lblName: UILabel!
    @IBOutlet var lblEmail: UILabel!
    }

3. i na koniec użyj klasy modelu w UIViewController, gdy używasz UITableView .

    class RNInviteVC: UIViewController, UITableViewDelegate, UITableViewDataSource {


    @IBOutlet var inviteTableView: UITableView!
    @IBOutlet var btnInvite: UIButton!

    var checkArray : NSMutableArray = NSMutableArray()
    var userName : NSMutableArray = NSMutableArray()

    override func viewDidLoad() {
        super.viewDidLoad()
        btnInvite.layer.borderWidth = 1.5
        btnInvite.layer.cornerRadius = btnInvite.frame.height / 2
        btnInvite.layer.borderColor =  hexColor(hex: "#512DA8").cgColor

        var userName1 =["Olivia","Amelia","Emily","Isla","Ava","Lily","Sophia","Ella","Jessica","Mia","Grace","Evie","Sophie","Poppy","Isabella","Charlotte","Freya","Ruby","Daisy","Alice"]


        self.userName.removeAllObjects()
        for items in userName1 {
           print(items)


            let model = RNCheckedModel()
            model.user_name = items
            model.is_check = false
            self.userName.add(model)
        }
      }
     @IBAction func btnInviteClick(_ sender: Any) {

    }
       func tableView(_ tableView: UITableView, numberOfRowsInSection 
       section: Int) -> Int {
        return userName.count
    }

    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell: InviteCell = inviteTableView.dequeueReusableCell(withIdentifier: "InviteCell", for: indexPath) as! InviteCell

        let image = UIImage(named: "ic_unchecked")
        cell.imgProfileImage.layer.borderWidth = 1.0
        cell.imgProfileImage.layer.masksToBounds = false
        cell.imgProfileImage.layer.borderColor = UIColor.white.cgColor
        cell.imgProfileImage.layer.cornerRadius =  cell.imgProfileImage.frame.size.width / 2
        cell.imgProfileImage.clipsToBounds = true

        let model = self.userName[indexPath.row] as! RNCheckedModel
        cell.lblName.text = model.user_name

        if (model.is_check) {
            cell.btnCheck.setImage(UIImage(named: "ic_checked"), for: UIControlState.normal)
        }
        else {
            cell.btnCheck.setImage(UIImage(named: "ic_unchecked"), for: UIControlState.normal)
        }

        cell.btnCheck.tag = indexPath.row
        cell.btnCheck.addTarget(self, action: #selector(self.btnCheck(_:)), for: .touchUpInside)

        cell.btnCheck.isUserInteractionEnabled = true

    return cell

    }

    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        return 80

    }

    @objc func btnCheck(_ sender: UIButton) {

        let tag = sender.tag
        let indexPath = IndexPath(row: tag, section: 0)
        let cell: InviteCell = inviteTableView.dequeueReusableCell(withIdentifier: "InviteCell", for: indexPath) as! InviteCell

        let model = self.userName[indexPath.row] as! RNCheckedModel

        if (model.is_check) {

            model.is_check = false
            cell.btnCheck.setImage(UIImage(named: "ic_unchecked"), for: UIControlState.normal)

            checkArray.remove(model.user_name)
            if checkArray.count > 0 {
                btnInvite.setTitle("Invite (\(checkArray.count))", for: .normal)
                print(checkArray.count)
                UIView.performWithoutAnimation {
                    self.view.layoutIfNeeded()
                }
            } else {
                btnInvite.setTitle("Invite", for: .normal)
                UIView.performWithoutAnimation {
                    self.view.layoutIfNeeded()
                }
            }

        }else {

            model.is_check = true
            cell.btnCheck.setImage(UIImage(named: "ic_checked"), for: UIControlState.normal)

            checkArray.add(model.user_name)
            if checkArray.count > 0 {
                btnInvite.setTitle("Invite (\(checkArray.count))", for: .normal)
                UIView.performWithoutAnimation {
                self.view.layoutIfNeeded()
                }
            } else {
                 btnInvite.setTitle("Invite", for: .normal)
            }
        }

        self.inviteTableView.reloadData()
    }

    func hexColor(hex:String) -> UIColor {
        var cString:String = hex.trimmingCharacters(in: .whitespacesAndNewlines).uppercased()

        if (cString.hasPrefix("#")) {
            cString.remove(at: cString.startIndex)
        }

        if ((cString.count) != 6) {
            return UIColor.gray
        }

        var rgbValue:UInt32 = 0
        Scanner(string: cString).scanHexInt32(&rgbValue)

        return UIColor(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: CGFloat(1.0)
        )
    }
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()

    }

     }

Użyłem metody convertPoint, aby pobrać punkt z widoku tabeli i przekazać ten punkt do metody indexPathForRowAtPoint, aby uzyskać indexPath

 @IBAction func newsButtonAction(sender: UIButton) {
        let buttonPosition = sender.convertPoint(CGPointZero, toView: self.newsTableView)
        let indexPath = self.newsTableView.indexPathForRowAtPoint(buttonPosition)
        if indexPath != nil {
            if indexPath?.row == 1{
                self.performSegueWithIdentifier("alertViewController", sender: self);
            }   
        }
    }

Spróbuj użyć #selector, aby wywołać IBaction.In the cellforrowatindexpath

            cell.editButton.tag = indexPath.row
        cell.editButton.addTarget(self, action: #selector(editButtonPressed), for: .touchUpInside)

W ten sposób możesz uzyskać dostęp do indexpath wewnątrz metody editButtonPressed

func editButtonPressed(_ sender: UIButton) {

print(sender.tag)//this value will be same as indexpath.row

}

W moim przypadku mam wiele sekcji i zarówno indeks sekcji, jak i wiersza są kluczowe, więc w takim przypadku właśnie utworzyłem właściwość w UIButton, w której ustawiłem indexPath komórki w następujący sposób:

fileprivate struct AssociatedKeys {
    static var index = 0
}

extension UIButton {

    var indexPath: IndexPath? {
        get {
            return objc_getAssociatedObject(self, &AssociatedKeys.index) as? IndexPath
        }
        set {
            objc_setAssociatedObject(self, &AssociatedKeys.index, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }
}

Następnie ustaw właściwość w cellForRowAt w następujący sposób:

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCellWithIdentifier("Cell") as! Cell
    cell.button.indexPath = indexPath
}

Następnie w handleTapAction możesz pobrać indexPath w następujący sposób:

@objc func handleTapAction(_ sender: UIButton) {
    self.selectedIndex = sender.indexPath

}

Swift 4 i 5

Metoda 1 przy użyciu delegata protokołu

Na przykład masz UITableViewCellz imieniemMyCell

class MyCell: UITableViewCell {
    
    var delegate:MyCellDelegate!
    
    @IBAction private func myAction(_ sender: UIButton){
        delegate.didPressButton(cell: self)
    }
}

Teraz utwórz plik protocol

protocol MyCellDelegate {
    func didPressButton(cell: UITableViewCell)
}

W następnym kroku utwórz rozszerzenie UITableView

extension UITableView {
    func returnIndexPath(cell: UITableViewCell) -> IndexPath?{
        guard let indexPath = self.indexPath(for: cell) else {
            return nil
        }
        return indexPath
    }
}

W swoim UIViewControllerzaimplementuj protokółMyCellDelegate

class ViewController: UIViewController, MyCellDelegate {
     
    func didPressButton(cell: UITableViewCell) {
        if let indexpath = self.myTableView.returnIndexPath(cell: cell) {
              print(indexpath)
        }
    }
}

Metoda 2 z użyciem domknięć

W UIViewController

override func viewDidLoad() {
        super.viewDidLoad()
       //using the same `UITableView extension` get the IndexPath here
        didPressButton = { cell in
            if let indexpath = self.myTableView.returnIndexPath(cell: cell) {
                  print(indexpath)
            }
        }
    }

 var didPressButton: ((UITableViewCell) -> Void)

class MyCell: UITableViewCell {

    @IBAction private func myAction(_ sender: UIButton){
        didPressButton(self)
    }
}

Uwaga: - jeśli chcesz uzyskać UICollectionViewindexPath, możesz użyć tego UICollectionView extensioni powtórzyć powyższe kroki

extension UICollectionView {
    func returnIndexPath(cell: UICollectionViewCell) -> IndexPath?{
        guard let indexPath = self.indexPath(for: cell) else {
            return nil
        }
        return indexPath
    }
}

W Swift 3. Użyto również instrukcji guard, unikając długiego łańcucha nawiasów.

func buttonTapped(sender: UIButton) {
    guard let cellInAction = sender.superview as? UITableViewCell else { return }
    guard let indexPath = tableView?.indexPath(for: cellInAction) else { return }

    print(indexPath)
}

Czasami przycisk może znajdować się wewnątrz innego widoku UITableViewCell. W takim przypadku superview.superview może nie dać obiektu komórki i dlatego indexPath będzie równa zero.

W takim przypadku powinniśmy szukać superwizji, aż otrzymamy obiekt komórki.

Funkcja pobierania obiektu komórki przez superview

func getCellForView(view:UIView) -> UITableViewCell?
{
    var superView = view.superview

    while superView != nil
    {
        if superView is UITableViewCell
        {
            return superView as? UITableViewCell
        }
        else
        {
            superView = superView?.superview
        }
    }

    return nil
}

Teraz możemy uzyskać indexPath po dotknięciu przycisku, jak poniżej

@IBAction func tapButton(_ sender: UIButton)
{
    let cell = getCellForView(view: sender)
    let indexPath = myTabelView.indexPath(for: cell)
}

// CustomCell.swift

protocol CustomCellDelegate {
    func tapDeleteButton(at cell: CustomCell)
}

class CustomCell: UICollectionViewCell {
    
    var delegate: CustomCellDelegate?
    
    fileprivate let deleteButton: UIButton = {
        let button = UIButton(frame: .zero)
        button.setImage(UIImage(named: "delete"), for: .normal)
        button.addTarget(self, action: #selector(deleteButtonTapped(_:)), for: .touchUpInside)
        button.translatesAutoresizingMaskIntoConstraints = false
        return button
    }()
    
    @objc fileprivate func deleteButtonTapped(_sender: UIButton) {
        delegate?.tapDeleteButton(at: self)
    }
    
}

//  ViewController.swift

extension ViewController: UICollectionViewDataSource {

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        guard let cell = collectionView.dequeueReusableCell(withReuseIdentifier: customCellIdentifier, for: indexPath) as? CustomCell else {
            fatalError("Unexpected cell instead of CustomCell")
        }
        cell.delegate = self
        return cell
    }

}

extension ViewController: CustomCellDelegate {

    func tapDeleteButton(at cell: CustomCell) {
        // Here we get the indexPath of the cell what we tapped on.
        let indexPath = collectionView.indexPath(for: cell)
    }

}