iOS 8 UITableView Separator Inset 0 funktioniert nicht

Ich habe eine App, in der UITableViewder Trennzeicheneinsatz des Benutzers auf benutzerdefinierte Werte eingestellt ist - rechts 0, links 0. Dies funktioniert perfekt in iOS 7.x, aber iOS 8.0ich sehe, dass der Separator-Einschub auf den Standardwert von 15rechts gesetzt ist. Obwohl in den XIB-Dateien, auf die es eingestellt ist, 0wird es immer noch falsch angezeigt .

Wie entferne ich die UITableViewCellTrennränder?

iOS 8.0 führt die Eigenschaft layoutMargins für Zellen- UND Tabellenansichten ein.

Diese Eigenschaft ist unter iOS 7.0 nicht verfügbar. Sie müssen sie daher überprüfen, bevor Sie sie zuweisen.

Die einfache Lösung besteht darin, Ihre Zelle in Unterklassen zu unterteilen und die Layoutränder-Eigenschaft zu überschreiben, wie von @ user3570727 vorgeschlagen. Sie verlieren jedoch jegliches Systemverhalten wie das Erben von Rändern aus dem sicheren Bereich. Daher empfehle ich die folgende Lösung nicht:

(Ziel c)

-(UIEdgeInsets)layoutMargins { 
     return UIEdgeInsetsZero // override any margins inc. safe area
}

(schnell 4.2):

override var layoutMargins: UIEdgeInsets { get { return .zero } set { } }

Wenn Sie die Eigenschaft nicht überschreiben möchten oder bedingt festlegen müssen, lesen Sie weiter.

Zusätzlich zu dieser layoutMarginsEigenschaft hat Apple Ihrer Zelle eine Eigenschaft hinzugefügt , die verhindert, dass die Randeinstellungen Ihrer Tabellenansicht übernommen werden. Wenn diese Eigenschaft festgelegt ist, können Ihre Zellen unabhängig von der Tabellenansicht ihre eigenen Ränder konfigurieren. Betrachten Sie es als Überschreibung.

Diese Eigenschaft wird aufgerufen preservesSuperviewLayoutMargins, und wenn Sie sie auf festlegen, NOkann die layoutMarginEinstellung der Zelle alle layoutMarginin Ihrer TableView festgelegten Einstellungen überschreiben . Beides spart Zeit ( Sie müssen die Einstellungen der Tabellenansicht nicht ändern ) und ist präziser. Eine ausführliche Erklärung finden Sie in der Antwort von Mike Abdullah.

HINWEIS: Was folgt, ist eine saubere Implementierung für eine Randeinstellung auf Zellebene , wie in der Antwort von Mike Abdullah ausgedrückt. Durch das Festlegen Ihrer Zellen preservesSuperviewLayoutMargins=NOwird sichergestellt, dass Ihre Tabellenansicht die Zelleneinstellungen nicht überschreibt. Wenn Sie tatsächlich möchten, dass Ihre gesamte Tabellenansicht konsistente Ränder aufweist, passen Sie Ihren Code entsprechend an.

Richten Sie Ihre Zellränder ein:

-(void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Remove seperator inset
    if ([cell respondsToSelector:@selector(setSeparatorInset:)]) {
           [cell setSeparatorInset:UIEdgeInsetsZero];
    }

    // Prevent the cell from inheriting the Table View's margin settings
    if ([cell respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)]) {
        [cell setPreservesSuperviewLayoutMargins:NO];
    }

    // Explictly set your cell's layout margins
    if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
        [cell setLayoutMargins:UIEdgeInsetsZero];
    }
}

Swift 4:

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // Remove seperator inset
    if cell.responds(to: #selector(setter: UITableViewCell.separatorInset)) {
        cell.separatorInset = .zero
    }
    // Prevent the cell from inheriting the Table View's margin settings
    if cell.responds(to: #selector(setter: UITableViewCell.preservesSuperviewLayoutMargins)) {
        cell.preservesSuperviewLayoutMargins = false
    }
    // Explictly set your cell's layout margins
    if cell.responds(to: #selector(setter: UITableViewCell.layoutMargins)) {
        cell.layoutMargins = .zero
    }
}

Wenn Sie die preservesSuperviewLayoutMarginsEigenschaft für Ihre Zelle auf NEIN setzen, sollte verhindert werden, dass Ihre Tabellenansicht Ihre Zellenränder überschreibt. In einigen Fällen scheint es nicht richtig zu funktionieren.

Wenn alles fehlschlägt, können Sie Ihre Tabellenansichtsränder brutal erzwingen:

-(void)viewDidLayoutSubviews
{
    [super viewDidLayoutSubviews];

    // Force your tableview margins (this may be a bad idea)
    if ([self.tableView respondsToSelector:@selector(setSeparatorInset:)]) {
        [self.tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([self.tableView respondsToSelector:@selector(setLayoutMargins:)]) {
        [self.tableView setLayoutMargins:UIEdgeInsetsZero];
    }
} 

Swift 4:

func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()
    // Force your tableview margins (this may be a bad idea)
    if tableView.responds(to: #selector(setter: UITableView.separatorInset)) {
        tableView.separatorInset = .zero
    }
    if tableView.responds(to: #selector(setter: UITableView.layoutMargins)) {
        tableView.layoutMargins = .zero
    }
}

... und los geht's! Dies sollte unter iOS 7 und 8 funktionieren.

BEARBEITEN: Mohamed Saleh machte mich auf eine mögliche Änderung in iOS 9 aufmerksam. Möglicherweise müssen Sie die Tabellenansichten auf einstellen cellLayoutMarginsFollowReadableWidth, NOwenn Sie Einfügungen oder Ränder anpassen möchten. Ihr Kilometerstand kann variieren, dies ist nicht sehr gut dokumentiert.

Diese Eigenschaft ist nur in iOS 9 vorhanden. Überprüfen Sie sie daher unbedingt, bevor Sie sie einstellen.

if([myTableView respondsToSelector:@selector(setCellLayoutMarginsFollowReadableWidth:)])
{
    myTableView.cellLayoutMarginsFollowReadableWidth = NO;
} 

Swift 4:

if myTableView.responds(to: #selector(setter: self.cellLayoutMarginsFollowReadableWidth)) {
    myTableView.cellLayoutMarginsFollowReadableWidth = false
}

(über Code von iOS 8 UITableView Separator Inset 0 funktioniert nicht )

EDIT: Hier ist ein reiner Interface Builder-Ansatz:

HINWEIS: iOS 11 ändert und vereinfacht einen Großteil dieses Verhaltens. Ein Update wird in Kürze veröffentlicht.

Arg !!! Nachdem Sie herumgespielt haben, tun Sie dies entweder in Ihrer CellUnterklasse:

- (UIEdgeInsets)layoutMargins
{
    return UIEdgeInsetsZero;
}

oder das cell.layoutMargins = UIEdgeInsetsZero;für mich fixiert einstellen .

Nehmen wir uns einen Moment Zeit, um das Problem zu verstehen, bevor wir blindlings aufladen, um zu versuchen, es zu beheben.

Ein kurzer Blick in den Debugger zeigt Ihnen, dass Trennlinien Unteransichten von sind UITableViewCell . Es scheint, dass die Zelle selbst eine angemessene Verantwortung für das Layout dieser Linien übernimmt.

iOS 8 führt das Konzept der Layoutränder ein . Standardmäßig befinden sich die Layoutränder einer Ansicht 8ptauf allen Seiten und werden von den Vorfahrenansichten geerbt .

Wie wir am besten erkennen können, wird beim Auslegen der Trennlinie UITableViewCellder linke Layoutrand berücksichtigt, um den linken Einschub einzuschränken.

Wenn wir all das zusammenfassen, um den gewünschten Einschub von wirklich Null zu erreichen, müssen wir:

• Stellen Sie den linken Layoutrand auf ein 0
• Stoppen Sie alle geerbten Ränder, die dies überschreiben

So ausgedrückt ist es eine ziemlich einfache Aufgabe:

cell.layoutMargins = UIEdgeInsetsZero;
cell.preservesSuperviewLayoutMargins = NO;

Dinge zu beachten:

• Dieser Code benötigt nur ausgeführt werden , einmal pro Zelle (Sie nur die Zelle der Eigenschaften schließlich Konfiguration), und es gibt nichts Besonderes , wenn Sie wählen , um es auszuführen. Tu, was dir am saubersten erscheint.
• Leider ist keine der beiden Eigenschaften zum Konfigurieren in Interface Builder verfügbar, aber Sie können bei Bedarf ein benutzerdefiniertes Laufzeitattribut angeben preservesSuperviewLayoutMargins.
• Wenn Ihre App auch auf frühere Betriebssystemversionen abzielt, müssen Sie die Ausführung des obigen Codes vermeiden, bis Sie unter iOS 8 und höher ausgeführt werden.
• Anstatt Einstellungen vorzunehmen preservesSuperviewLayoutMargins, können Sie Vorfahrenansichten (z. B. die Tabelle) so konfigurieren, dass sie auch einen 0linken Rand haben. Dies scheint jedoch von Natur aus fehleranfälliger zu sein, da Sie nicht die gesamte Hierarchie steuern.
• Es wäre wahrscheinlich etwas sauberer, nur den linken Rand zu setzen 0und die anderen zu lassen.
• Wenn Sie eine 0-Einfügung in die "zusätzlichen" Trennzeichen wünschen, die UITableViewam unteren Rand von Tabellen im einfachen Stil gezeichnet werden, müssen Sie vermutlich auch auf Tabellenebene dieselben Einstellungen angeben (haben Sie diese nicht ausprobiert!).

Ich glaube, dies ist die gleiche Frage, die ich hier gestellt habe: Entfernen Sie SeparatorInset unter iOS 8 UITableView für XCode 6 iPhone Simulator

In iOS 8 gibt es eine neue Eigenschaft für alle Objekte, von denen geerbt wird UIView. Also, die Lösung, um die einzustellenSeparatorInset Festlegen von in iOS 7.x in der UITableView in iOS 8 angezeigten Leerraum nicht entfernen.

Die neue Eigenschaft heißt " layoutMargins ".

@property(nonatomic) UIEdgeInsets layoutMargins
Description   The default spacing to use when laying out content in the view.
Availability  iOS (8.0 and later)
Declared In   UIView.h
Reference UIView Class Reference

Die Lösung:-

-(void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{

    if ([tableView respondsToSelector:@selector(setSeparatorInset:)]) {
        [tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([tableView respondsToSelector:@selector(setLayoutMargins:)]) {
        [tableView setLayoutMargins:UIEdgeInsetsZero];
    }

   if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
        [cell setLayoutMargins:UIEdgeInsetsZero];
   }
}

Wenn Sie festlegen, cell.layoutMargins = UIEdgeInsetsZero;ohne zu überprüfen, ob das layoutMarginsvorhanden ist, stürzt die App unter iOS 7.x ab. Der beste Weg wäre also zu überprüfen, ob das layoutMarginszuerst existiert setLayoutMargins:UIEdgeInsetsZero.

Sie können UIAppearance einmal beim Start Ihrer Anwendung (bevor die Benutzeroberfläche geladen wird) verwenden, um sie als globale Standardeinstellungen festzulegen:

// iOS 7:
[[UITableView appearance] setSeparatorStyle:UITableViewCellSeparatorStyleSingleLine];
[[UITableView appearance] setSeparatorInset:UIEdgeInsetsZero];

[[UITableViewCell appearance] setSeparatorInset:UIEdgeInsetsZero];

// iOS 8:
if ([UITableView instancesRespondToSelector:@selector(setLayoutMargins:)]) {

    [[UITableView appearance] setLayoutMargins:UIEdgeInsetsZero];
    [[UITableViewCell appearance] setLayoutMargins:UIEdgeInsetsZero];
    [[UITableViewCell appearance] setPreservesSuperviewLayoutMargins:NO];

}

Auf diese Weise halten Sie den Code Ihres UIViewControllers sauber und können ihn jederzeit überschreiben, wenn Sie möchten.

iOS führt die Eigenschaft layoutMargins für Zellen- UND Tabellenansichten ein.

Diese Eigenschaft ist in iOS 7.0 nicht verfügbar, daher müssen Sie sie überprüfen, bevor Sie sie zuweisen!

Allerdings hat Apple ein hinzugefügt Eigenschaft namens preservesSuperviewLayoutMargins für Ihr Handy , die es von vererben Ihrer Tabellenansicht der Randeinstellung zu verhindern. Auf diese Weise können Ihre Zellen unabhängig von der Tabellenansicht ihre eigenen Ränder konfigurieren. Betrachten Sie es als Überschreibung.

Diese Eigenschaft heißt preservesSuperviewLayoutMargins , und es NO Einstellung ermöglicht es Ihnen , Ihre Tabellenansicht der layoutMargin Einstellung mit Ihrer eigenen Zelle layoutMargin Einstellung außer Kraft zu setzen. Beides spart Zeit ( Sie müssen die Einstellungen der Tabellenansicht nicht ändern ) und ist präziser. Eine ausführliche Erklärung finden Sie in der Antwort von Mike Abdullah.

HINWEIS: Dies ist die richtige, weniger chaotische Implementierung, wie in der Antwort von Mike Abdullah ausgedrückt. Durch Festlegen der Vorbehalte Ihrer ZelleServerviewLayoutMargins = NO wird sichergestellt, dass Ihre Tabellenansicht die Zelleneinstellungen nicht überschreibt.

Erster Schritt - Richten Sie Ihre Zellränder ein:

/*
    Tells the delegate that the table view is about to draw a cell for a particular row.
*/
override func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,
    forRowAtIndexPath indexPath: NSIndexPath)
{
    // Remove separator inset
    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset = UIEdgeInsetsZero
    }

    // Prevent the cell from inheriting the Table View's margin settings
    if cell.respondsToSelector("setPreservesSuperviewLayoutMargins:") {
        cell.preservesSuperviewLayoutMargins = false
    }

    // Explictly set your cell's layout margins
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins = UIEdgeInsetsZero
    }
}

Wenn Sie die EigenschafterveSuperviewLayoutMargins für Ihre Zelle auf NO setzen, sollte verhindert werden, dass Ihre Tabellenansicht Ihre Zellenränder überschreibt. In einigen Fällen scheint es nicht richtig zu funktionieren.

Zweiter Schritt - Nur wenn alles fehlschlägt, können Sie Ihre Tabellenansichtsränder brutal erzwingen:

/*
    Called to notify the view controller that its view has just laid out its subviews.
*/
override func viewDidLayoutSubviews() {
    super.viewDidLayoutSubviews()

    // Force your tableview margins (this may be a bad idea)
    if self.tableView.respondsToSelector("setSeparatorInset:") {
        self.tableView.separatorInset = UIEdgeInsetsZero
    }

    if self.tableView.respondsToSelector("setLayoutMargins:") {
        self.tableView.layoutMargins = UIEdgeInsetsZero
    }
}

... und los geht's! Dies sollte sowohl unter iOS 8 als auch unter iOS 7 funktionieren.

Hinweis: Mit iOS 8.1 und 7.1 getestet. In meinem Fall musste ich nur den ersten Schritt dieser Erklärung verwenden.

Der zweite Schritt ist nur erforderlich, wenn Sie eine nicht ausgefüllte Zelle unter den gerenderten Zellen haben, d. H. Wenn die Tabelle größer als die Anzahl der Zeilen im Tabellenmodell ist. Wenn der zweite Schritt nicht ausgeführt wird, führt dies zu unterschiedlichen Trennzeichenversätzen.

In Swift ist es etwas ärgerlicher, weil layoutMarginses eine Eigenschaft ist, also müssen Sie den Getter und den Setter überschreiben .

override var layoutMargins: UIEdgeInsets {
  get { return UIEdgeInsetsZero }
  set(newVal) {}
}

Dies wird effektiv layoutMarginsschreibgeschützt machen , was in meinem Fall in Ordnung ist.

Für iOS 9 müssen Sie Folgendes hinzufügen:

if([myTableView respondsToSelector:@selector(setCellLayoutMarginsFollowReadableWidth:)])
{
    myTableView.cellLayoutMarginsFollowReadableWidth = NO;
} 

Weitere Einzelheiten entnehmen Sie bitte der Frage .

Swift 2.0-Erweiterung

Ich wollte nur eine Erweiterung freigeben, die ich gemacht habe, um die Ränder aus den Tabellenansicht-Zellentrennzeichen zu entfernen.

extension UITableViewCell {
    func removeMargins() {

        if self.respondsToSelector("setSeparatorInset:") {
            self.separatorInset = UIEdgeInsetsZero
        }

        if self.respondsToSelector("setPreservesSuperviewLayoutMargins:") {
            self.preservesSuperviewLayoutMargins = false
        }

        if self.respondsToSelector("setLayoutMargins:") {
            self.layoutMargins = UIEdgeInsetsZero
        }
    }
}

Wird im Kontext verwendet:

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

    cell.removeMargins()
    return cell

Schnell:

override func viewDidLoad() {
    super.viewDidLoad()

    if self.tableView.respondsToSelector("setSeparatorInset:") {
        self.tableView.separatorInset = UIEdgeInsetsZero
    }
    if self.tableView.respondsToSelector("setLayoutMargins:") {
        self.tableView.layoutMargins = UIEdgeInsetsZero
    }

    self.tableView.layoutIfNeeded()            // <--- this do the magic
}

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

    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset = UIEdgeInsetsZero
    }
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins = UIEdgeInsetsZero
    }

    return cell
}

Ich habe es so gemacht:

tableView.separatorInset = UIEdgeInsetsZero;
tableView.layoutMargins = UIEdgeInsetsZero;
cell.layoutMargins = UIEdgeInsetsZero;

In Bezug auf das, was cdstamper anstelle der Tabellenansicht vorgeschlagen hat, funktioniert das Hinzufügen der folgenden Zeilen in der layoutSubview-Methode der Zelle für mich.

- (void)layoutSubviews 
{
    [super layoutSubviews];

    if ([self respondsToSelector:@selector(setSeparatorInset:)])
                [self setSeparatorInset:UIEdgeInsetsZero];

        if ([self respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)])
        {
            [self setPreservesSuperviewLayoutMargins:NO];;
        }

        if ([self respondsToSelector:@selector(setLayoutMargins:)]) 
        {
            [self setLayoutMargins:UIEdgeInsetsZero];
        }
}

Swift 3.0 Beispiel:

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    // removing seperator inset
    if cell.responds(to: #selector(setter: UITableViewCell.separatorInset)) {
        cell.separatorInset = .zero
    }
    // prevent the cell from inheriting the tableView's margin settings
    if cell.responds(to: #selector(setter: UIView.preservesSuperviewLayoutMargins)) {
        cell.preservesSuperviewLayoutMargins = false
    }
    // explicitly setting cell's layout margins
    if cell.responds(to: #selector(setter: UITableViewCell.layoutMargins)) {
        cell.layoutMargins = .zero
    }
}

Nach langem Nachforschen ...

Hier ist die einzige Möglichkeit, dieses Zeug vollständig zu kontrollieren (das ich finden konnte)

Vollständige Steuerung der Trennzeicheneinfügungen und Layoutränder in jeder Zelle. Tun Sie dies in der willDisplayCellMethode auf Ihrem UITableviewDelegate.

func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
    cell.layoutMargins = UIEdgeInsetsZero
    cell.contentView.layoutMargins = UIEdgeInsetsMake(0, 10, 0, 10)
    cell.separatorInset = UIEdgeInsetsMake(0, 0, 0, 0)
}

Das Zellenobjekt steuert das Trennzeichen und contentViewalles andere. Wenn die Leerzeichen Ihrer Trennzeichen in einer unerwarteten Farbe angezeigt werden, sollte dies folgende Probleme lösen:

cell.backgroundColor = cell.contentView.backgroundColor

Einfache Lösung in Swift für iOS 8 mit einem benutzerdefiniertenUITableViewCell

override func awakeFromNib() {
    super.awakeFromNib()

    self.layoutMargins = UIEdgeInsetsZero
    self.separatorInset = UIEdgeInsetsZero
}

Auf diese Weise setzen Sie layoutMarginund separatorInsetnur einmal, anstatt es für jedes zu tun, willDisplayCellwie die meisten der obigen Antworten vorschlagen.

Wenn Sie einen benutzerdefinierten Benutzer verwenden, ist UITableViewCelldies der richtige Ort, um dies zu tun. Ansonsten solltest du es in tun tableView:cellForRowAtIndexPath.

Nur ein weiterer Hinweis: Sie müssen nicht festlegen, preservesSuperviewLayoutMargins = falseda der Standardwert bereits ist NO!

Für mich hat die einfache Linie den Job gemacht

cell.layoutMargins = UIEdgeInsetsZero

Fügen Sie einfach den folgenden Code hinzu, um dieses Programm zu lösen.

Viel Glück!

-(void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath {

       if ([cell respondsToSelector:@selector(setSeparatorInset:)]) {
           [cell setSeparatorInset:UIEdgeInsetsZero];
       }

       if ([cell respondsToSelector:@selector(setLayoutMargins:)]) {
           [cell setLayoutMargins:UIEdgeInsetsZero];
       }

}

Lukasz antwortet in Swift:

    // iOS 7:
    UITableView.appearance().separatorStyle = .SingleLine
    UITableView.appearance().separatorInset = UIEdgeInsetsZero
    UITableViewCell.appearance().separatorInset = UIEdgeInsetsZero

    // iOS 8:
    if UITableView.instancesRespondToSelector("setLayoutMargins:") {
        UITableView.appearance().layoutMargins = UIEdgeInsetsZero
        UITableViewCell.appearance().layoutMargins = UIEdgeInsetsZero
        UITableViewCell.appearance().preservesSuperviewLayoutMargins = false
    }

Dies ist der Code, der für mich in Swift funktioniert:

override func viewDidLoad() 
{
    super.viewDidLoad()
    ...
    if tableView.respondsToSelector("setSeparatorInset:") {
        tableView.separatorInset = UIEdgeInsetsZero
    }
}

func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,forRowAtIndexPath indexPath: NSIndexPath)
{
    if cell.respondsToSelector("setSeparatorInset:") {
        cell.separatorInset.left = CGFloat(0.0)
    }
    if tableView.respondsToSelector("setLayoutMargins:") {
        tableView.layoutMargins = UIEdgeInsetsZero
    }
    if cell.respondsToSelector("setLayoutMargins:") {
        cell.layoutMargins.left = CGFloat(0.0)
    }
}

Dies scheint mir (vorerst) am saubersten zu sein, da alle Zellen- / Tabellenansicht-Kanten- / Randanpassungen in der tableView:willDisplayCell:forRowAtIndexPath:Methode vorgenommen werden, ohne unnötigen Code einzupferchen tableView:cellForRowAtIndexPath:.

Übrigens setze ich nur das linke SeparatorInset / layoutMargins der Zelle, weil ich in diesem Fall meine Einschränkungen, die ich in meiner Zelle eingerichtet habe, nicht vermasseln möchte.

Code aktualisiert auf Swift 2.2:

 override func viewDidLoad() {
   super.viewDidLoad()       

    if tableView.respondsToSelector(Selector("setSeparatorInset:")) {
      tableView.separatorInset = UIEdgeInsetsZero
        }
    }

 override func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell,forRowAtIndexPath indexPath: NSIndexPath) {
        if cell.respondsToSelector(Selector("setSeparatorInset:")) {
            cell.separatorInset.left = CGFloat(0.0)
        }
        if tableView.respondsToSelector(Selector("setLayoutMargins:")) {
            tableView.layoutMargins = UIEdgeInsetsZero
        }
        if cell.respondsToSelector(Selector("setLayoutMargins:")) {
            cell.layoutMargins.left = CGFloat(0.0)
        }
    }

Die meisten Antworten zeigen Separator Einfügungen und Layout - Ränder über eine Vielzahl von Verfahren eingestellt werden (dh viewDidLayoutSubviews, willDisplayCellusw.) für Zellen und Tableviews, aber ich habe festgestellt , dass diese in nur darum , cellForRowAtIndexPathgroßen Werken. Scheint der sauberste Weg zu sein.

// kill insets for iOS 8
if ([[UIDevice currentDevice].systemVersion floatValue] >= 8) {
    cell.preservesSuperviewLayoutMargins = NO;
    [cell setLayoutMargins:UIEdgeInsetsZero];
}
// iOS 7 and later
if ([cell respondsToSelector:@selector(setSeparatorInset:)])
    [cell setSeparatorInset:UIEdgeInsetsZero];

Verwenden Sie das folgende Code-Snippet, um unerwünschte Auffüllprobleme für UITableView in IOS 8 und 7 zu vermeiden.

-(void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{

    if ([tableView respondsToSelector:@selector(setSeparatorInset:)])
    {
        [tableView setSeparatorInset:UIEdgeInsetsZero];
    }

    if ([tableView respondsToSelector:@selector(setLayoutMargins:)])
    {
        [tableView setLayoutMargins:UIEdgeInsetsZero];
    }

    if ([cell respondsToSelector:@selector(setLayoutMargins:)])
    {
        [cell setLayoutMargins:UIEdgeInsetsZero];
    }
}

Anstatt zu aktualisieren preservesSuperviewLayoutMarginsund layoutMarginsjedes Mal, wenn die Zelle einen Bildlauf durchführt (mit willDisplayCell), würde ich vorschlagen, dies einmal zu tun cellForRowAtIndexPath::

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

    let cell = super.tableView(tableView, cellForRowAtIndexPath: indexPath)

    cell.preservesSuperviewLayoutMargins = false
    cell.layoutMargins = UIEdgeInsetsZero

    return cell

}

Hier ist eine einfache Möglichkeit, den Einschub global zu entfernen.

In UITableViewCell+Extensions.swift:

import UIKit

extension UITableViewCell {

  override public var layoutMargins: UIEdgeInsets {
    get { return UIEdgeInsetsZero }
    set { }
  }

}

In AppDelegate application:didFinishLaunchingWithOptions::

  UITableViewCell.appearance().separatorInset = UIEdgeInsetsZero

Sie könnten denken, a) auch nur separatorInsetin der Erweiterung überschreiben oder b) layoutMarginsstattdessen den Erscheinungs-Proxy für festlegen . Beides wird nicht funktionieren. Obwohl separatorInsetangegeben wird, dass es sich um eine Eigenschaft handelt, führt der Versuch, sie als Eigenschaft (oder Methode) zu überschreiben, zu Compilerfehlern. Das Festlegen des Erscheinungs-Proxys für UITableViewCell's layoutMargins(oder auch das Festlegen der Erscheinungs-Proxys für UITableView' s layoutMarginsund separatorInset) hat keine Auswirkung.

In iOS8:

Hinzufügen zu meiner UITableViewCell-Unterklasse:

- (UIEdgeInsets)layoutMargins {
    return UIEdgeInsetsZero;
}

und dies zu "tableView: cellForRowAtIndexPath" oder "tableView: willDisplayCell":

[editCell setSeparatorInset:UIEdgeInsetsZero];

Für mich gearbeitet.

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
        // ... Get the cell
        cell.separatorInset = UIEdgeInsetsMake(0.f, 20.f, 0.f, [UIScreen mainScreen].bounds.size.width - 20);
        // others
        return cell;
}

Für eine bestimmte Zelle möchten Sie das Trennzeichen ausblenden.

Nachdem ich die Antworten in Etage 3 gesehen hatte, versuchte ich herauszufinden, in welcher Beziehung das Einrichten des Trennzeichens zwischen TableView und TableViewCell steht, und führte einige Tests durch. Hier sind meine Schlussfolgerungen:

1. Wir können davon ausgehen, dass das Setzen des Trennzeichens der Zelle auf Null das Trennzeichen in zwei Schritten verschieben muss: Der erste Schritt besteht darin, das Trennzeichen der Zelle auf Null zu setzen. Der zweite Schritt besteht darin, das Randlayout der Zelle auf Null zu setzen.

2. stellen Sie die die Tableview separatorinset und marginlayout kann der Zelle beeinflussen separatorinset . Aus dem Test geht jedoch hervor, dass das Separator- Set von TableView nutzlos zu sein scheint. Das Marginlayout von TableView kann sich tatsächlich auf das Marginlayout der Zelle auswirken .

3. Wenn Sie PreservesSuperviewLayoutMargins = false von Cell festlegen , kann der Marginlayout- Effekt von TableView für Zellen abgeschnitten werden .

4. eine der Lösungen:

   func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
       var cell = UITableViewCell()
   
       cell.preservesSuperviewLayoutMargins = false
       cell.separatorInset = UIEdgeInsetsZero
       cell.layoutMargins = UIEdgeInsetsZero
   
       return cell
   }

Das ist meine Lösung. Dies gilt für die benutzerdefinierte Zellenunterklasse. Fügen Sie beide einfach zur Unterklasse hinzu.

1. - (UIEdgeInsets)layoutMargins {    
       return UIEdgeInsetsMake(0, 10, 0, 10);
   }

2.

self.separatorInset = UIEdgeInsetsMake(0, 10, 0, 10);

Und es ist praktisch, dass Sie die Position des Trennzeichens anpassen können, ohne Ihren Designer zu bitten, eines für Sie zu zeichnen ..........

Kompakter als die am meisten gewählte Antwort ...

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath {

    if ([cell respondsToSelector:@selector(setSeparatorInset:)] && [cell respondsToSelector:@selector(setPreservesSuperviewLayoutMargins:)] && [cell respondsToSelector:@selector(setLayoutMargins:)]) {
         [cell setSeparatorInset:UIEdgeInsetsZero];
         [cell setPreservesSuperviewLayoutMargins:NO];
         [cell setLayoutMargins:UIEdgeInsetsZero];
    }

}}

Das Hinzufügen dieses Snippets, einfach elegant in Swift, funktioniert für mich in iOS8 :)

    // tableview single line
func tableView(tableView: UITableView, willDisplayCell cell: UITableViewCell, forRowAtIndexPath indexPath: NSIndexPath) {
    cell.preservesSuperviewLayoutMargins = false
    cell.layoutMargins = UIEdgeInsetsZero
}

Dies funktionierte perfekt für mich in iOS 8 und iOS 9.

Für OBJ-C

 - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath  { 
        if ([tableView respondsToSelector:@selector(setSeparatorInset:)])
        {
            [tableView setSeparatorInset:UIEdgeInsetsZero];
        }

        if ([tableView respondsToSelector:@selector(setLayoutMargins:)])
        {
            [tableView setLayoutMargins:UIEdgeInsetsZero];
        }

        if ([cell respondsToSelector:@selector(setLayoutMargins:)])
        {
            [cell setLayoutMargins:UIEdgeInsetsZero];
        }
         return cell;
    }