objective-c - iOS 8 UITableView Separator Inset 0 funktioniert nicht




swift ios8 (25)

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

Ich habe eine App, bei der der UITableView des UITableView auf benutzerdefinierte Werte gesetzt ist - Right 0 , Left 0 . Dies funktioniert perfekt in iOS 7.x , aber in iOS 8.0 sehe ich, dass der Separatoreinsatz auf der rechten Seite auf den Standardwert 15 . Obwohl es in den xib-Dateien auf 0 , wird es immer noch falsch angezeigt.

Wie entferne ich die UITableViewCell Trennzeichen Ränder?


Fügen Sie einfach unten 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];
       }

}

Anstatt die layoutMargins und layoutMargins jedes Mal zu aktualisieren preservesSuperviewLayoutMargins layoutMargins die Zelle scrollt (mithilfe von willDisplayCell ), würde ich vorschlagen, dies einmal in cellForRowAtIndexPath: zu tun:

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

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

    cell.preservesSuperviewLayoutMargins = false
    cell.layoutMargins = UIEdgeInsetsZero

    return cell

}

Sie können UIAppearance einmal beim Start der Anwendung (vor dem Laden der Benutzeroberfläche) verwenden, um es 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 behalten Sie den Code Ihres UIViewControllers sauber und können ihn jederzeit überschreiben.


Nach viel Nachforschungen ...

Hier ist der einzige Weg, um dieses Zeug (das ich finden konnte) vollständig zu kontrollieren

Um beide Trenneinfügungen und Layout-Ränder für jede Zelle vollständig zu steuern. Tun Sie dies in der Methode willDisplayCell 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 contentView steuert das Trennzeichen und das contentView steuert alles andere. Wenn die eingefügten Trennbereiche in einer unerwarteten Farbe angezeigt werden, sollte das Problem gelöst werden:

cell.backgroundColor = cell.contentView.backgroundColor

Ich habe es geschafft, indem ich Folgendes machte:

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

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

Ein kurzer Blick in den Debugger sagt Ihnen, dass Trennlinien Unteransichten von UITableViewCell . Es scheint, dass die Zelle selbst eine ziemlich große Verantwortung für das Layout dieser Linien übernimmt.

iOS 8 führt das Konzept der Layout-Ränder ein . Standardmäßig sind die Layout-Ränder einer Ansicht auf allen Seiten 8pt und werden von Vorfahrenansichten geerbt .

Wie wir am besten sehen können, wählt UITableViewCell den linken Layout-Rand und verwendet ihn, um den linken Einsatz zu beschränken.

Um all das zusammen zu bringen, um den gewünschten Einsatz von wirklich Null zu erreichen, müssen wir:

  • Legen Sie den linken Layout-Rand auf 0
  • Stoppen Sie alle vererbten Ränder, die das überschreiben

So gesehen ist es eine ziemlich einfache Aufgabe zu erreichen:

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

Dinge zu beachten:

  • Dieser Code muss nur einmal pro Zelle ausgeführt werden (Sie konfigurieren nur die Eigenschaften der Zelle), und es gibt nichts Besonderes bei der Ausführung. Tun Sie, was Ihnen am saubersten erscheint.
  • Leider ist keine Eigenschaft in Interface Builder konfigurierbar, aber Sie können bei Bedarf ein benutzerdefiniertes Laufzeitattribut für preservesSuperviewLayoutMargins angeben.
  • Wenn Ihre App auch auf ältere OS-Versionen abzielt, müssen Sie die Ausführung des obigen Codes vermeiden, bis sie auf iOS 8 und höher ausgeführt wird.
  • Anstatt set preservesSuperviewLayoutMargins , können Sie auch Vorfahrenansichten (z. B. die Tabelle) so konfigurieren, dass sie auch 0 linken Rand haben. Dies scheint jedoch an sich fehleranfälliger zu sein, da Sie die gesamte Hierarchie nicht steuern.
  • Es wäre wahrscheinlich etwas sauberer, nur den linken Rand auf 0 und die anderen zu belassen.
  • Wenn Sie eine 0-Einfügung für die "Extra" UITableView haben möchten, die UITableView am Ende von einfachen Stil-Tabellen zeichnet, dann müssen Sie UITableView die gleichen Einstellungen auch auf Tabellenebene UITableView (haben Sie diese nicht versucht!)

Hier ist eine einfache Möglichkeit, den Insert 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) überschreiben Sie auch separatorInset in der Erweiterung oder b) legen layoutMargins stattdessen den Darstellungsproxy für layoutMargins . Keine wird funktionieren. Auch wenn " separatorInset als Eigenschaft angegeben ist, generiert der Versuch, es als Eigenschaft (oder Methode) zu überschreiben, Compilerfehler. Und das Einstellen des Darstellungs - Proxys für die UITableViewCell layoutMargins (oder auch das Festlegen der Darstellungs - Proxies für die layoutMargins und das separatorInset layoutMargins ) hat keine Auswirkungen.


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
}

In iOS8:

Hinzufügen zu meiner UITableViewCell Subclass:

- (UIEdgeInsets)layoutMargins {
    return UIEdgeInsetsZero;
}

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

[editCell setSeparatorInset:UIEdgeInsetsZero];

GEARBEITET für mich.


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

In iOS 8 gibt es eine neue Eigenschaft für alle Objekte, die von UIView erben. Die Lösung, mit der das SeparatorInset in iOS 7.x eingerichtet wird, kann den in 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 cell.layoutMargins = UIEdgeInsetsZero; ohne zu prüfen, ob die layoutMargins existieren, layoutMargins die App auf iOS 7.x ab. Der beste Weg wäre also zu überprüfen, ob das layoutMargins zuerst vor setLayoutMargins:UIEdgeInsetsZero .


In einer kompakteren Weise 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];
    }

}


In Swift ist es etwas ärgerlicher, da es sich bei layoutMargins um eine Eigenschaft handelt, also müssen Getter und Setter überschrieben werden.

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

Dies wird layoutMargins effektiv layoutMargins machen, was in meinem Fall in Ordnung ist.


Hinzufügen dieses Schnipsel, 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
}

Was cdstamper anstelle der Tabellenansicht vorgeschlagen hat, funktioniert das Hinzufügen von 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];
        }
}

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


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

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

2.

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

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


Verwenden Sie das folgende Code-Snippet, um ein unerwünschtes Padding-Problem für UITableView in IOS 8 & 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];
    }
}

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

Diese Eigenschaft ist unter iOS 7.0 nicht verfügbar. Sie müssen daher sicherstellen, dass Sie sie vor dem Zuweisen überprüfen.

Darüber hinaus hat Apple Ihrer Zelle eine Eigenschaft hinzugefügt, die verhindert, dass sie die Randeinstellungen der Tabellenansicht erbt. Wenn diese Eigenschaft festgelegt ist, können Ihre Zellen ihre eigenen Ränder unabhängig von der Tabellenansicht konfigurieren. Betrachten Sie es als einen Override.

Diese Eigenschaft heißt layoutMargin , und layoutMargin sie auf NO , kann die layoutMargin Einstellung der Zelle das layoutMargin von layoutMargin in Ihrem TableView überschreiben. Dies spart Zeit ( Sie müssen die Einstellungen der Tabellenansicht nicht ändern ) und ist prägnanter. Bitte beziehen Sie sich auf Mike Abdullahs Antwort für eine detaillierte Erklärung.

HINWEIS: Was folgt, ist eine saubere Implementierung für eine Randeinstellung auf Zellenebene , wie sie in Mike Abdullahs Antwort ausgedrückt wird. Wenn Sie die conservesSuperviewLayoutMargins = NO Ihrer Zelle festlegen, wird sichergestellt, dass Ihre Tabellenansicht die Zelleneinstellungen nicht überschreibt. Wenn Sie möchten, dass Ihre gesamte Tabellenansicht konsistente Ränder aufweist, passen Sie Ihren Code entsprechend an.

Richten Sie Ihre Zellenrä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];
    }
}

Wenn Sie die Eigenschaft conservesSuperviewLayoutMargins in Ihrer Zelle auf NO setzen, sollte Ihre Tabellenansicht die Zellenränder nicht überschreiben. In einigen Fällen scheint es nicht richtig zu funktionieren.

Wenn alles fehlschlägt, können Sie die Ränder der Tabellenansicht bruten:

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

... und los gehts! Dies sollte unter iOS 7 und 8 funktionieren.

BEARBEITEN: Mohamed Saleh hat mich auf eine mögliche Änderung in iOS 9 aufmerksam gemacht. Möglicherweise müssen Sie die cellLayoutMarginsFollowReadableWidth der cellLayoutMarginsFollowReadableWidth auf NO wenn Sie die cellLayoutMarginsFollowReadableWidth von cellLayoutMarginsFollowReadableWidth oder Rändern anpassen möchten. Ihre Laufleistung kann variieren, dies ist nicht sehr gut dokumentiert.

Diese Eigenschaft ist nur in iOS 9 vorhanden. Überprüfe dies also vor der Einstellung.

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

(über Code von iOS 8 UITableView Trennzeichen Einsatz 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 folgen ...


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

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

Für weitere Details lesen Sie bitte die question .


Für mich hat die einfache Linie den Job gemacht

cell.layoutMargins = UIEdgeInsetsZero

Schnelle Version

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

Diese Eigenschaft ist in iOS 7.0 nicht verfügbar, daher müssen Sie vor dem Zuweisen sicherstellen, dass Sie sie überprüfen.

Allerdings hat Apple der Zelle eine Eigenschaft namens preservesSuperviewLayoutMargins hinzugefügt, die verhindert, dass sie die Randeinstellungen der Table View erbt. Auf diese Weise können Ihre Zellen ihre eigenen Ränder unabhängig von der Tabellenansicht konfigurieren. Betrachten Sie es als einen Override.

Diese Eigenschaft heißt conservesSuperviewLayoutMargins. Wenn Sie sie auf NO setzen, können Sie die LayoutMargin-Einstellungen Ihrer Table View mit der LayoutMargin-Einstellung Ihrer eigenen Zelle überschreiben. Dies spart Zeit ( Sie müssen die Einstellungen der Tabellenansicht nicht ändern ) und ist prägnanter. Bitte beziehen Sie sich auf Mike Abdullahs Antwort für eine detaillierte Erklärung.

HINWEIS: Dies ist die richtige, weniger chaotische Implementierung, wie sie in Mike Abdullahs Antwort zum Ausdruck kommt. Wenn Sie die conservesSuperviewLayoutMargins = NO Ihrer Zelle festlegen, wird sichergestellt, dass Ihre Tabellenansicht die Zelleneinstellungen nicht überschreibt.

Erster Schritt - Richten Sie Ihre Zellenrä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
    }
}

Setzen Sie die preservesSuperviewLayoutMargins-Eigenschaft in Ihrer Zelle auf NO, um zu verhindern, dass Ihre Tabellenansicht die Zellenränder überschreibt. In einigen Fällen scheint es nicht richtig zu funktionieren.

Zweiter Schritt - Nur wenn alle Fehler auftreten, können Sie die Ränder der Tabellenansicht brutto 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 gehts! Dies sollte sowohl auf iOS 8 als auch auf iOS 7 funktionieren.

Hinweis: Getestet mit iOS 8.1 und 7.1, musste ich in meinem Fall nur den ersten Schritt dieser Erklärung verwenden.

Der zweite Schritt ist nur erforderlich, wenn Sie unter den gerenderten Zellen eine leere Zelle haben, d. wenn die Tabelle größer als die Anzahl der Zeilen im Tabellenmodell ist. Wenn Sie den zweiten Schritt nicht ausführen, führt dies zu unterschiedlichen Separator-Offsets.


Arg !!! Nachdem du das in deiner Cell Unterklasse gemacht hast:

- (UIEdgeInsets)layoutMargins
{
    return UIEdgeInsetsZero;
}

oder cell.layoutMargins = UIEdgeInsetsZero; reparierte es für mich.


Nachdem ich die Antworten in der 3. Etage gesehen hatte, versuchte ich herauszufinden, wie die Beziehung zwischen TableView und TableViewCell aussehen sollte, und testete sie. Hier sind meine Schlussfolgerungen:

  1. Wir können davon ausgehen, dass das Trennzeichen der Zelle auf Null gesetzt werden muss, um das Trennzeichen in zwei Schritten zu verschieben: Im ersten Schritt wird das Trennzeichen der Zelle auf null gesetzt. Der zweite Schritt besteht darin, das marginlayout der Zelle auf Null zu setzen.

  2. Legen Sie fest, dass das Separatorinset und das marginlayout des TableView das Separatorinset der Zelle beeinflussen können. Bei dem Test finde ich jedoch, dass das Trennzeichen des TableViews nutzlos erscheint, TableViews Marginlayout kann das Marginlayout der Zelle beeinflussen .

  3. Setzen Sie Cell's PreservesSuperviewLayoutMargins = false, um den Marginlayout- Effekt von TableView auf Zellen zu unterbinden .

  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
    }
    

Swift-4 Doble extension - Dies funktioniert in allen Fällen gut.

extension Double {

  // Formatting double value to k and M
  // 1000 = 1k
  // 1100 = 1.1k
  // 15000 = 15k
  // 115000 = 115k
  // 1000000 = 1m
  func formatPoints() -> String{
        let thousandNum = self/1000
        let millionNum = self/1000000
        if self >= 1000 && self < 1000000{
            if(floor(thousandNum) == thousandNum){
                return ("\(Int(thousandNum))k").replacingOccurrences(of: ".0", with: "")
            }
            return("\(thousandNum.roundTo(places: 1))k").replacingOccurrences(of: ".0", with: "")
        }
        if self > 1000000{
            if(floor(millionNum) == millionNum){
                return("\(Int(thousandNum))k").replacingOccurrences(of: ".0", with: "")
            }
            return ("\(millionNum.roundTo(places: 1))M").replacingOccurrences(of: ".0", with: "")
        }
        else{
            if(floor(self) == self){
                return ("\(Int(self))")
            }
            return ("\(self)")
        }
    }

    /// Returns rounded value for passed places
    ///
    /// - parameter places: Pass number of digit for rounded value off after decimal
    ///
    /// - returns: Returns rounded value with passed places
    func roundTo(places:Int) -> Double {
        let divisor = pow(10.0, Double(places))
        return (self * divisor).rounded() / divisor
    }
}








ios objective-c swift uitableview ios8