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

Question 1

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

Question 2

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.

Question 3

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

Question 4

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.

Question 5

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

Question 6

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

Question 7

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ę!

Question 8

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

Question 9

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

Question 10

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

Question 11

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

Question 12

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:

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 = ""

    }

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

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

    }

     }

Question 13

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

Question 14

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

}

Question 15

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

}

Question 16

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

Question 17

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

Question 18

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

Question 19

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

}