Η σωστή λύση είναι η εξής:

- (void)viewDidLoad
{
 [super viewDidLoad];
 UINib *nib = [UINib nibWithNibName:@"ItemCell" bundle:nil];
 [[self tableView] registerNib:nib forCellReuseIdentifier:@"ItemCell"];
}

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
   // Create an instance of ItemCell
   PointsItemCell *cell =  [tableView dequeueReusableCellWithIdentifier:@"ItemCell"];

return cell;
}

Κανω ΕΓΓΡΑΦΗ

Μετά iOS 7, αυτή η διαδικασία έχει απλοποιηθεί τα κάτω για να ( ταχεία 3.0 ):

// For registering nib files
tableView.register(UINib(nibName: "MyCell", bundle: Bundle.main), forCellReuseIdentifier: "cell")

// For registering classes
tableView.register(MyCellClass.self, forCellReuseIdentifier: "cell")

( Σημείωση ) Αυτή είναι επίσης εφικτό με τη δημιουργία των κυττάρων στα .xibή .stroyboardαρχεία, ως πρωτότυπο κύτταρα. Αν χρειαστεί να συνδέσετε μια τάξη σε αυτά, μπορείτε να επιλέξετε το κελί πρωτότυπο και προσθέστε την αντίστοιχη κατηγορία (πρέπει να είναι απόγονος του UITableViewCell, φυσικά).

dequeue

Και αργότερα, dequeued χρήση ( ταχεία 3.0 ):

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
{
    let cell : UITableViewCell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)

    cell.textLabel?.text = "Hello"

    return cell
}

Η διαφορά είναι ότι αυτή η νέα μέθοδος dequeues όχι μόνο το κύτταρο, δημιουργεί όμως και αν ανύπαρκτο (αυτό σημαίνει ότι δεν έχετε να κάνετε if (cell == nil)ανοησίες), και το κύτταρο είναι έτοιμο προς χρήση ακριβώς όπως στο παραπάνω παράδειγμα.

( Προειδοποίηση ) tableView.dequeueReusableCell(withIdentifier:for:)διαθέτει τη νέα συμπεριφορά, εάν καλέσετε το άλλο (χωρίς indexPath:) μπορείτε να πάρετε την παλιά συμπεριφορά, στην οποία θα πρέπει να ελέγξετε για nilκαι παράδειγμα τον εαυτό σας, παρατηρήστε την UITableViewCell?τιμή επιστροφής.

if let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath) as? MyCellClass
{
    // Cell be casted properly
    cell.myCustomProperty = true
}
else
{
    // Wrong type? Wrong identifier?
}

Και φυσικά, ο τύπος της σχετικής κατηγορίας του κυττάρου είναι αυτή που ορίζεται στο αρχείο .xib για την UITableViewCellυποκατηγορία, ή εναλλακτικά, με τη χρήση της άλλης μεθόδου μητρώο.

Διαμόρφωση

Στην ιδανική περίπτωση, τα κύτταρά σας έχουν ήδη ρυθμιστεί όσον αφορά την εμφάνιση και την τοποθέτηση του περιεχομένου (όπως οι ετικέτες και τις απόψεις εικόνα) από τη στιγμή που τα εγγραφεί, και από την cellForRowAtIndexPathμέθοδο μπορείτε απλά να συμπληρώσετε.

Ολοι μαζί

class MyCell : UITableViewCell
{
    // Can be either created manually, or loaded from a nib with prototypes
    @IBOutlet weak var labelSomething : UILabel? = nil
}

class MasterViewController: UITableViewController 
{
    var data = ["Hello", "World", "Kinda", "Cliche", "Though"]

    // Register
    override func viewDidLoad()
    {
        super.viewDidLoad()

        tableView.register(MyCell.self, forCellReuseIdentifier: "mycell")
        // or the nib alternative
    }

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

    // Dequeue
    override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
    {
        let cell = tableView.dequeueReusableCell(withIdentifier: "mycell", for: indexPath) as! MyCell

        cell.labelSomething?.text = data[indexPath.row]

        return cell
    }
}

Και φυσικά, όλα αυτά είναι διαθέσιμα σε ObjC με τα ίδια ονόματα.

Πήρε την απάντηση Shawn λαχταρών και καθαριστεί μέχρι λίγο.

BBCell.h:

#import <UIKit/UIKit.h>

@interface BBCell : UITableViewCell {
}

+ (BBCell *)cellFromNibNamed:(NSString *)nibName;

@end

BBCell.m:

#import "BBCell.h"

@implementation BBCell

+ (BBCell *)cellFromNibNamed:(NSString *)nibName {
    NSArray *nibContents = [[NSBundle mainBundle] loadNibNamed:nibName owner:self options:NULL];
    NSEnumerator *nibEnumerator = [nibContents objectEnumerator];
    BBCell *customCell = nil;
    NSObject* nibItem = nil;
    while ((nibItem = [nibEnumerator nextObject]) != nil) {
        if ([nibItem isKindOfClass:[BBCell class]]) {
            customCell = (BBCell *)nibItem;
            break; // we have a winner
        }
    }
    return customCell;
}

@end

Κάνω όλες τις υποκατηγορίες UITableViewCell μου της BBCell, και στη συνέχεια να αντικαταστήσει το πρότυπο

cell = [[[BBDetailCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"BBDetailCell"] autorelease];

με:

cell = (BBDetailCell *)[BBDetailCell cellFromNibNamed:@"BBDetailCell"];

Θα χρησιμοποιηθεί bentford του Μέθοδος # 2 :

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"BDCustomCell"];
    if (cell == nil) {
        // Load the top-level objects from the custom cell XIB.
        NSArray *topLevelObjects = [[NSBundle mainBundle] loadNibNamed:@"BDCustomCell" owner:self options:nil];
        // Grab a pointer to the first object (presumably the custom cell, as that's all the XIB should contain).
        cell = [topLevelObjects objectAtIndex:0];
    }

    return cell;
}

Λειτουργεί, αλλά προσέξτε για τις συνδέσεις στο Αρχείο κατόχου του στην προσαρμοσμένη UITableViewCell .xib το αρχείο σας.

Με το πέρασμα owner:selfσε σας loadNibNamedδήλωση, μπορείτε να ορίσετε το UITableViewControllerως αρχείο του ιδιοκτήτη σας UITableViewCell.

Αν drag and drop στο αρχείο κεφαλίδα στο IB για να ρυθμίσετε τις δράσεις και τα καταστήματα, θα τους συστήσει ως κάτοχος αρχείων από προεπιλογή.

Σε loadNibNamed:owner:options, τον κωδικό της Apple θα προσπαθήσει να ορίσετε τις ιδιότητες σε σας UITableViewController, δεδομένου ότι είναι ο ιδιοκτήτης. Αλλά δεν έχετε αυτές τις ιδιότητες που ορίζονται εκεί, ώστε να μπορείτε να πάρετε ένα λάθος για να είναι το κλειδί αξία κωδικοποίησης συμβατό με :

*** Terminating app due to uncaught exception 'NSUnknownKeyException', reason:     '[<MyUITableViewController 0x6a383b0> setValue:forUndefinedKey:]: this class is not key value coding-compliant for the key myLabel.'

Αν ένα συμβάν παίρνει ενεργοποιηθεί αντ 'αυτού, θα πάρετε μια NSInvalidArgumentException:

-[MyUITableViewController switchValueDidChange:]: unrecognized selector sent to instance 0x8e9acd0
*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[MyUITableViewController switchValueDidChange:]: unrecognized selector sent to instance 0x8e9acd0'
*** First throw call stack:
(0x1903052 0x15eed0a 0x1904ced 0x1869f00 0x1869ce2 0x1904ec9 0x5885c2 0x58855a 0x62db76 0x62e03f 0x77fa6c 0x24e86d 0x18d7966 0x18d7407 0x183a7c0 0x1839db4 0x1839ccb 0x1f8b879 0x1f8b93e 0x585a9b 0xb904d 0x2c75)
terminate called throwing an exceptionCurrent language:  auto; currently objective-c

Μια εύκολη λύση είναι να επισημάνω Interface Builder συνδέσεις σας στο UITableViewCellΙδιοκτήτης αντί του αρχείου είναι:

1. Κάντε δεξί κλικ στο Αρχείο κατόχου του να τραβήξει τον κατάλογο των συνδέσεων
2. Ρίξτε μια οθόνη συλλαμβάνει με Command-Shift-4 (σύρετε για να επιλέξετε την περιοχή για να συλληφθούν)
3. x έξω οι συνδέσεις από το Αρχείο κατόχου του
4. Κάντε δεξί κλικ στο UITableCell στην ιεραρχία αντικειμένων και προσθέστε ξανά τις συνδέσεις.

Έχω αποφασίσει να δημοσιεύσετε δεδομένου ότι δεν μου αρέσει κάποια από αυτές τις απαντήσεις - τα πράγματα μπορεί πάντα να είναι πιο απλό και αυτό είναι μακράν το πιο περιεκτικό τρόπο που έχω βρεθεί.

1. Φτιάξτε ΧΙΒ σας στο Interface Builder, όπως σας αρέσει

• Ιδιοκτήτης Ορισμός αρχείου για την κατηγορία NSObject
• Προσθέστε ένα UITableViewCell και να ορίσετε την κατηγορία της να MyTableViewCellSubclass - αν κολλάει IB σας (συμβαίνει σε Xcode> 4 όπως αυτής της γραφής), απλά χρησιμοποιήστε ένα UIView του κάνει τη διεπαφή στο Xcode 4, αν εξακολουθείτε να έχετε το βάζοντας γύρω
• Διάταξη subviews σας μέσα σε αυτό το κελί και να επισυνάψετε συνδέσεις IBOutlet σας για να @interface σας στο .h ή .m (.m είναι η προτίμησή μου)

2. Σε UIViewController ή UITableViewController σας υποκατηγορία

@implementation ViewController

static NSString *cellIdentifier = @"MyCellIdentier";

- (void) viewDidLoad {

    ...
    [self.tableView registerNib:[UINib nibWithNibName:@"MyTableViewCellSubclass" bundle:nil] forCellReuseIdentifier:cellIdentifier];
}

- (UITableViewCell*) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    MyTableViewCellSubclass *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];

    ...

    return cell;
}

3. Σε MyTableViewCellSubclass σας

- (id) initWithCoder:(NSCoder *)aDecoder {
    if (self = [super initWithCoder:aDecoder]) {
        ...
    }

    return self;
}

Εάν χρησιμοποιείτε Interface Builder να κάνουν τα κύτταρα, βεβαιωθείτε ότι έχετε ορίσει το αναγνωριστικό του Επιθεωρητή. Στη συνέχεια, ελέγξτε ότι είναι το ίδιο όταν καλείτε dequeueReusableCellWithIdentifier.

Έκανα κατά λάθος ξέχασε να θέσει μερικά αναγνωριστικά σε ένα έργο πίνακα-βαρύ, και η αλλαγή των επιδόσεων ήταν σαν νύχτα και μέρα.

Φόρτωση UITableViewCells από XIBs εξοικονομεί πολύ κώδικα, αλλά συνήθως οδηγεί σε φρικτά ταχύτητα κύλισης (στην πραγματικότητα, δεν είναι η ΧΙΒ, αλλά η υπερβολική χρήση των UIViews που προκαλούν αυτό).

Σας προτείνω να ρίξετε μια ματιά σε αυτό: παραπομπή Σύνδεσμος

Εδώ είναι η μέθοδος κατηγορίας που έχω χρησιμοποιήσει για τη δημιουργία προσαρμοσμένων κύτταρα από XIBs:

+ (CustomCell*) createNewCustomCellFromNib {

    NSArray* nibContents = [[NSBundle mainBundle]
                            loadNibNamed:@"CustomCell" owner:self options:NULL];

    NSEnumerator *nibEnumerator = [nibContents objectEnumerator];
    CustomCell *customCell= nil;
    NSObject* nibItem = nil;

    while ( (nibItem = [nibEnumerator nextObject]) != nil) {

        if ( [nibItem isKindOfClass: [CustomCell class]]) {
            customCell = (CustomCell*) nibItem;

            if ([customCell.reuseIdentifier isEqualToString: @"CustomCell"]) {
                break; // we have a winner
            }
            else
                fuelEntryCell = nil;
        }
    }
    return customCell;
}

Στη συνέχεια, στο ΧΙΒ, εγώ που το όνομα της κλάσης, και αναγνωριστικό επαναχρησιμοποίηση. Μετά από αυτό, μπορώ να καλέσω ακριβώς αυτή τη μέθοδο στον ελεγκτή τη γνώμη μου, αντί του

[[UITableViewCell] alloc] initWithFrame:]

Είναι πολλά αρκετά γρήγορα, και να χρησιμοποιηθεί σε δύο εφαρμογές αποστολής μου. Είναι πιο αξιόπιστο από τα ζητούν [nib objectAtIndex:0], και στο μυαλό μου τουλάχιστον, πιο αξιόπιστο από το παράδειγμα Stephan Burlot επειδή είστε εγγυημένοι για να αρπάξει μόνο μια άποψη από ένα ΧΙΒ που είναι ο σωστός τύπος.

Η σωστή λύση είναι αυτή

- (void)viewDidLoad
{
    [super viewDidLoad];
    [self.tableView registerNib:[UINib nibWithNibName:@"CustomCell" bundle:[NSBundle mainBundle]] forCellReuseIdentifier:@"CustomCell"];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    UITableViewCell  *cell = [tableView dequeueReusableCellWithIdentifier:@"CustomCell"];
    return cell; 
    }

Επιλέξτε αυτό - http://eppz.eu/blog/custom-uitableview-cell/ - πολύ βολικό τρόπο χρησιμοποιώντας ένα μικρό τάξη που καταλήγει μία γραμμή στην εφαρμογή ελεγκτή:

-(UITableViewCell*)tableView:(UITableView*) tableView cellForRowAtIndexPath:(NSIndexPath*) indexPath
{
    return [TCItemCell cellForTableView:tableView
                          atIndexPath:indexPath
                      withModelSource:self];
}

Επαναφόρτωση της ΕΕΦ είναι ακριβό. Καλύτερα να το φορτώσετε μια φορά, τότε υπόσταση των αντικειμένων όταν χρειάζεστε ένα κελί. Σημειώστε ότι μπορείτε να προσθέσετε UIImageViews κλπ στην μύτη, ακόμα και πολλαπλά κύτταρα, χρησιμοποιώντας αυτή τη μέθοδο (της Apple «registerNIB» iOS5 επιτρέπει μόνο μία κορυφαία αντικείμενο επίπεδο - Bug 10580062 «iOS5 TableView registerNib: υπερβολικά περιοριστικές»

Έτσι κωδικός μου είναι κάτω - μπορείτε να διαβάσετε στο ΕΕΦ φορά (σε Προετοιμασία όπως έκανα και στο viewDidLoad -.. Ό, τι Από κει και πέρα, μπορείτε υπόσταση της μύτης σε αντικείμενα, στη συνέχεια, επιλέξτε αυτό που χρειάζεστε Αυτό είναι πολύ πιο αποτελεσματική από τη φόρτωση της μύτης ξανά και ξανά.

static UINib *cellNib;

+ (void)initialize
{
    if(self == [ImageManager class]) {
        cellNib = [UINib nibWithNibName:@"ImageManagerCell" bundle:nil];
        assert(cellNib);
    }
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellID = @"TheCell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellID];
    if(cell == nil) {
        NSArray *topLevelItems = [cellNib instantiateWithOwner:nil options:nil];
        NSUInteger idx = [topLevelItems indexOfObjectPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop)
                            {
                                UITableViewCell *cell = (UITableViewCell *)obj;
                                return [cell isKindOfClass:[UITableViewCell class]] && [cell.reuseIdentifier isEqualToString:cellID];
                            } ];
        assert(idx != NSNotFound);
        cell = [topLevelItems objectAtIndex:idx];
    }
    cell.textLabel.text = [NSString stringWithFormat:@"Howdie %d", indexPath.row];

    return cell;
}

Πρώτα εισάγετε προσαρμοσμένο αρχείο κυττάρων σας #import "CustomCell.h"και στη συνέχεια να αλλάξετε τη μέθοδο εκπρόσωπο, όπως αναφέρονται παρακάτω:

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

static NSString *simpleTableIdentifier = @"CustomCell";

CustomCell *cell = (CustomCell *)[tableView dequeueReusableCellWithIdentifier:simpleTableIdentifier];
if (cell == nil)
{
    NSArray *nib = [[NSBundle mainBundle] loadNibNamed:@"CustomCell" owner:self options:nil];
    cell = [nib objectAtIndex:0];

    [cell setSelectionStyle:UITableViewCellSelectionStyleNone];
}         

     return cell;
}

Ο σωστός τρόπος για να το κάνετε είναι να δημιουργήσετε μια εφαρμογή υποκατηγορία UITableViewCell, κεφαλίδα, και ΧΙΒ. Στο ΧΙΒ αφαιρέστε τυχόν απόψεις και απλά προσθέστε ένα κελί πίνακα. Ρυθμίστε την κατηγορία και το όνομα της υποκατηγορίας UITableViewCell. Για τον ιδιοκτήτη του αρχείου, το όνομα της κλάσης υποκατηγορία UITableViewController κάνουν. Συνδέστε τον ιδιοκτήτη του αρχείου στο κελί χρησιμοποιώντας την έξοδο tableViewCell.

Στο αρχείο επικεφαλίδα:

UITableViewCell *_tableViewCell;
@property (assign) IBOutlet UITableViewCell *tableViewCell;

Στο αρχείο της εφαρμογής:

@synthesize tableViewCell = _tableViewCell;

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *kCellIdentifier = @"reusableCell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:kCellIdentifier];
    if (cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:kCellIdentifier owner:self options:nil];
        cell = _tableViewCell;
        self.tableViewCell = nil;
    }

    return cell;
}

Τι να κάνω για αυτό είναι να δηλώσει ένα IBOutlet UITableViewCell *cellστην κατηγορία του ελεγκτή σας. Στη συνέχεια, να επικαλεστεί τη NSBundle loadNibNamedμέθοδο της κατηγορίας, η οποία θα τροφοδοτούν το UITableViewCellστο κελί που ανακοινώνονται ανωτέρω.

Για την xib θα δημιουργήσει ένα κενό xib και προσθέστε το UITableViewCellαντικείμενο στην ΙΒ όπου μπορεί να ρυθμιστεί ανάλογα με τις ανάγκες. Η άποψη αυτή στη συνέχεια συνδέεται με το κύτταρο IBOutletστην κατηγορία ελεγκτή.

- (UITableViewCell *)tableView:(UITableView *)table
         cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    NSLog(@"%@ loading RTEditableCell.xib", [self description] );

    static NSString *MyIdentifier = @"editableCellIdentifier";
    cell = [table dequeueReusableCellWithIdentifier:MyIdentifier];

    if(cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:@"RTEditableCell"
                                      owner:self
                                    options:nil];
    }

    return cell;
}

NSBundle προσθήκες loadNibNamed (login ADC)

άρθρο cocoawithlove.com που προέρχεται η ιδέα από το (πάρει το τηλέφωνο αριθμοί δείγμα app)

Σε Swift 4.2 και Xcode 10

Έχω τρία αρχεία των κυττάρων ΧΙΒ

σε viewDidLoad καταχωρήσετε τα αρχεία ΧΙΒ σας αρέσει αυτό ...

Αυτή είναι η πρώτη προσέγγιση

tableView.register(UINib.init(nibName: "XIBCell", bundle: nil), forCellReuseIdentifier: "cell1")
tableView.register(UINib.init(nibName: "XIBCell2", bundle: nil), forCellReuseIdentifier: "cell2")
//tableView.register(UINib.init(nibName: "XIBCell3", bundle: nil), forCellReuseIdentifier: "cell3")

Δεύτερη προσέγγιση εγγραφείτε απευθείας τα αρχεία ΧΙΒ στην cellForRowAt indexPath:

Αυτό είναι λειτουργίες TableView εκπρόσωπος μου

//MARK: - Tableview delegates
override func numberOfSections(in tableView: UITableView) -> Int {

    return 1
}

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {

    return 6
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    //This is first approach
    if indexPath.row == 0 {//Load first XIB cell
        let placeCell = tableView.dequeueReusableCell(withIdentifier: "cell1") as! XIBCell
        return placeCell
    //Second approach
    } else if indexPath.row == 5 {//Load XIB cell3
        var cell = tableView.dequeueReusableCell(withIdentifier:"cell3") as? XIBCell3
        if cell == nil{
            let arrNib:Array = Bundle.main.loadNibNamed("XIBCell3",owner: self, options: nil)!
            cell = arrNib.first as? XIBCell3
        }

        //ADD action to XIB cell button
        cell?.btn.tag = indexPath.row//Add tag to button
        cell?.btn.addTarget(self, action: #selector(self.bookbtn1(_:)), for: .touchUpInside);//selector

        return cell!
    //This is first approach
    } else {//Load XIB cell2
        let placeCell = tableView.dequeueReusableCell(withIdentifier: "cell2") as! XIBCell2

        return placeCell
    }

}

1. Δημιουργήστε το δικό σας προσαρμοσμένο τάξη AbcViewCellυποκατηγορία από UITableViewCell(Βεβαιωθείτε ότι το όνομα του αρχείου τάξη σας και το όνομα του αρχείου μύτη είναι το ίδιο)

2. Δημιουργήστε τη μέθοδο αυτή την κατηγορία επέκτασης.

   extension UITableViewCell {
       class func fromNib<T : UITableViewCell>() -> T {
           return Bundle.main.loadNibNamed(String(describing: T.self), owner: nil, options: nil)?[0] as! T
       }
   }
   

3. Χρησιμοποιησετο.

   let cell: AbcViewCell = UITableViewCell.fromNib()

Δεν ξέρω αν υπάρχει κανονικό τρόπο, αλλά εδώ είναι η μέθοδος μου:

• Δημιουργήστε ένα xib για ViewController
• Ρυθμίστε την κατηγορία File ιδιοκτήτη να UIViewController
• Διαγράψτε τη θέα και να προσθέσετε ένα UITableViewCell
• Ρυθμίστε την κλάση του UITableViewCell σας για να έθιμο τάξη σας
• Ορίστε το αναγνωριστικό της UITableViewCell σας
• Ρυθμίστε την έξοδο από την άποψή σας άποψη ελεγκτή για UITableViewCell σας

Και χρησιμοποιήσετε αυτόν τον κωδικό:

MyCustomViewCell *cell = (MyCustomViewCell *)[_tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
  UIViewController* c = [[UIViewController alloc] initWithNibName:CellIdentifier bundle:nil];
  cell = (MyCustomViewCell *)c.view;
  [c release];
}

Στο παράδειγμά σας, χρησιμοποιώντας

[nib objectAtIndex:0]

μπορεί να σπάσει αν η Apple αλλάζει τη σειρά των στοιχείων στη ΧΙβ.

 func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

            let cellReuseIdentifier = "collabCell"
            var cell:collabCell! = tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as? collabCell
            if cell == nil {
                tableView.register(UINib(nibName: "collabCell", bundle: nil), forCellReuseIdentifier: cellReuseIdentifier)
                cell = tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as! collabCell!
            }


            return cell

}

Εδώ είναι μια καθολική προσέγγιση για την καταχώρηση των κυττάρων σε UITableView:

protocol Reusable {
    static var reuseID: String { get }
}

extension Reusable {
    static var reuseID: String {
        return String(describing: self)
    }
}

extension UITableViewCell: Reusable { }

extension UITableView {

func register<T: UITableViewCell>(cellClass: T.Type = T.self) {
    let bundle = Bundle(for: cellClass.self)
    if bundle.path(forResource: cellClass.reuseID, ofType: "nib") != nil {
        let nib = UINib(nibName: cellClass.reuseID, bundle: bundle)
        register(nib, forCellReuseIdentifier: cellClass.reuseID)
    } else {
        register(cellClass.self, forCellReuseIdentifier: cellClass.reuseID)
    }
}

Εξήγηση:

1. Reusableπρωτόκολλο δημιουργεί ταυτότητας κυψέλης από την ονομασία της κατηγορίας του. Βεβαιωθείτε ότι ακολουθείτε τη σύμβαση: cell ID == class name == nib name.
2. UITableViewCellσυμμορφώνεται με Reusableτο πρωτόκολλο.
3. UITableView επέκταση αφαιρεί μακριά τη διαφορά στην εγγραφή κύτταρα μέσω μύτη ή τάξη.

Παράδειγμα Χρήσης:

override func viewDidLoad() {
    super.viewDidLoad()
    let tableView = UITableView()
    let cellClasses: [UITableViewCell.Type] = [PostCell.self, ProfileCell.self, CommentCell.self]
    cellClasses.forEach(tableView.register)
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: PostCell.self.reuseID) as? PostCell
    ...
    return cell
}

Αυτή η επέκταση απαιτεί Xcode7 beta6

extension NSBundle {
    enum LoadViewError: ErrorType {
        case ExpectedXibToExistButGotNil
        case ExpectedXibToContainJustOneButGotDifferentNumberOfObjects
        case XibReturnedWrongType
    }

    func loadView<T>(name: String) throws -> T {
        let topLevelObjects: [AnyObject]! = loadNibNamed(name, owner: self, options: nil)
        if topLevelObjects == nil {
            throw LoadViewError.ExpectedXibToExistButGotNil
        }
        if topLevelObjects.count != 1 {
            throw LoadViewError.ExpectedXibToContainJustOneButGotDifferentNumberOfObjects
        }
        let firstObject: AnyObject! = topLevelObjects.first
        guard let result = firstObject as? T else {
            throw LoadViewError.XibReturnedWrongType
        }
        return result
    }
}

Δημιουργήστε ένα αρχείο ΧΙβ που περιέχει μόνο 1 προσαρμοσμένη UITableViewCell.

Τοποθετήστε αυτό.

let cell: BacteriaCell = try NSBundle.mainBundle().loadView("BacteriaCell")

 NSString *CellIdentifier = [NSString stringWithFormat:@"cell %ld %ld",(long)indexPath.row,(long)indexPath.section];


    NewsFeedCell *cell = (NewsFeedCell *)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    cell=nil;

    if (cell == nil)
    {
        NSArray *topLevelObjects = [[NSBundle mainBundle] loadNibNamed:@"NewsFeedCell" owner:nil options:nil];

        for(id currentObject in topLevelObjects)
        {
            if([currentObject isKindOfClass:[NewsFeedCell class]])
            {
                cell = (NewsFeedCell *)currentObject;
                break;
            }
        }
}
return cell;

Εδώ είναι η μέθοδος μου για το ότι: Φόρτωση Προσαρμοσμένη UITableViewCells από ΧΙΒ αρχεία ... Ακόμα μια άλλη μέθοδος

Η ιδέα είναι να δημιουργηθεί μια υποκατηγορία SampleCell του UITableViewCellμε μια IBOutlet UIView *contentπεριουσία και ιδιοκτησία για κάθε προσαρμοσμένη δευτερεύουσας προβολής θα πρέπει να ρυθμίσετε τις παραμέτρους του κώδικα. Στη συνέχεια, για να δημιουργήσετε ένα αρχείο SampleCell.xib. Σε αυτό το αρχείο μύτη, αλλάξτε τον ιδιοκτήτη του αρχείου για να SampleCell. Προσθέστε μια περιεκτικότητα σε UIViewτέτοιο μέγεθος ώστε να ταιριάζει στις ανάγκες σας. Προσθέστε και να ρυθμίσετε όλες τις subviews (ετικέτα, προβολές εικόνων, κουμπιά, κλπ) που θέλετε. Τέλος, συνδέουν την άποψη του περιεχομένου και των subviews στον ιδιοκτήτη του αρχείου.