Wie überprüfe ich, ob UILabel abgeschnitten ist?

Ich habe eine UILabel, die unterschiedlich lang sein kann, je nachdem, ob meine App auf einem iPhone oder iPad im Hoch- oder Querformat ausgeführt wird. Wenn der Text zu lang ist, um in einer Zeile angezeigt zu werden, und abgeschnitten wird, möchte ich, dass der Benutzer ihn drücken und ein Popup des vollständigen Textes erhalten kann.

Wie kann ich überprüfen, ob UILabelder Text abgeschnitten wird? Ist es überhaupt möglich? Im Moment suche ich nur nach verschiedenen Längen, je nachdem in welchem ​​Modus ich mich befinde, aber es funktioniert nicht besonders gut.

Sie können die Breite der Zeichenfolge berechnen und feststellen, ob die Breite größer als istlabel.bounds.size.width

NSString UIKit Additions bietet verschiedene Methoden zum Berechnen der Größe der Zeichenfolge mit einer bestimmten Schriftart. Wenn Sie jedoch eine minimale Schriftgröße für Ihr Etikett haben, mit der das System den Text auf diese Größe verkleinern kann. In diesem Fall möchten Sie möglicherweise sizeWithFont: minFontSize: actualFontSize: forWidth: lineBreakMode: verwenden .

CGSize size = [label.text sizeWithAttributes:@{NSFontAttributeName:label.font}];
if (size.width > label.bounds.size.width) {
   ...
}

Swift (als Erweiterung) - funktioniert für mehrzeiliges Uilabel:

swift4: ( attributesParameter boundingRectleicht geändert)

extension UILabel {

    var isTruncated: Bool {

        guard let labelText = text else {
            return false
        }

        let labelTextSize = (labelText as NSString).boundingRect(
            with: CGSize(width: frame.size.width, height: .greatestFiniteMagnitude),
            options: .usesLineFragmentOrigin,
            attributes: [.font: font],
            context: nil).size

        return labelTextSize.height > bounds.size.height
    }
}

swift3:

extension UILabel {

    var isTruncated: Bool {

        guard let labelText = text else { 
            return false
        }

        let labelTextSize = (labelText as NSString).boundingRect(
            with: CGSize(width: frame.size.width, height: .greatestFiniteMagnitude),
            options: .usesLineFragmentOrigin,
            attributes: [NSFontAttributeName: font],
            context: nil).size

        return labelTextSize.height > bounds.size.height
    }
}

swift2:

extension UILabel {

    func isTruncated() -> Bool {

        if let string = self.text {

            let size: CGSize = (string as NSString).boundingRectWithSize(
                CGSize(width: self.frame.size.width, height: CGFloat(FLT_MAX)),
                options: NSStringDrawingOptions.UsesLineFragmentOrigin,
                attributes: [NSFontAttributeName: self.font],
                context: nil).size

            if (size.height > self.bounds.size.height) {
                return true
            }
        }

        return false
    }

}

EDIT: Ich habe gerade gesehen, dass meine Antwort positiv bewertet wurde, aber das von mir angegebene Code-Snippet ist veraltet.
Der beste Weg, dies zu tun, ist (ARC):

NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
paragraph.lineBreakMode = mylabel.lineBreakMode;
NSDictionary *attributes = @{NSFontAttributeName : mylabel.font,
                             NSParagraphStyleAttributeName : paragraph};
CGSize constrainedSize = CGSizeMake(mylabel.bounds.size.width, NSIntegerMax);
CGRect rect = [mylabel.text boundingRectWithSize:constrainedSize
                                         options:(NSStringDrawingUsesLineFragmentOrigin|NSStringDrawingUsesFontLeading)
                                      attributes:attributes context:nil];
if (rect.size.height > mylabel.bounds.size.height) {
    NSLog(@"TOO MUCH");
}

Beachten Sie, dass die berechnete Größe kein ganzzahliger Wert ist. Wenn Sie also Dinge wie tun int height = rect.size.height, verlieren Sie etwas Gleitkommapräzision und haben möglicherweise falsche Ergebnisse.

Alte Antwort (veraltet):

Wenn Ihr Etikett mehrzeilig ist, können Sie diesen Code verwenden:

CGSize perfectSize = [mylabel.text sizeWithFont:mylabel.font constrainedToSize:CGSizeMake(mylabel.bounds.size.width, NSIntegerMax) lineBreakMode:mylabel.lineBreakMode];
if (perfectSize.height > mylabel.bounds.size.height) {
    NSLog(@"TOO MUCH");
}

Sie können mit UILabel eine Kategorie erstellen

- (BOOL)isTextTruncated

{
    CGRect testBounds = self.bounds;
    testBounds.size.height = NSIntegerMax;
    CGRect limitActual = [self textRectForBounds:[self bounds] limitedToNumberOfLines:self.numberOfLines];
    CGRect limitTest = [self textRectForBounds:testBounds limitedToNumberOfLines:self.numberOfLines + 1];
    return limitTest.size.height>limitActual.size.height;
}

Verwenden Sie diese Kategorie, um festzustellen, ob ein Label unter iOS 7 und höher abgeschnitten ist.

// UILabel+Truncation.h
@interface UILabel (Truncation)

@property (nonatomic, readonly) BOOL isTruncated;

@end


// UILabel+Truncation.m
@implementation UILabel (Truncation)

- (BOOL)isTruncated
{
    CGSize sizeOfText =
      [self.text boundingRectWithSize:CGSizeMake(self.bounds.size.width, CGFLOAT_MAX)
                               options:(NSStringDrawingUsesLineFragmentOrigin | NSStringDrawingUsesFontLeading)
                            attributes:@{ NSFontAttributeName : label.font } 
                               context: nil].size;

    if (self.frame.size.height < ceilf(sizeOfText.height))
    {
        return YES;
    }
    return NO;
}

@end

Swift 3

Sie können die Anzahl der Zeilen nach dem Zuweisen der Zeichenfolge zählen und mit der maximalen Anzahl der Zeilen des Etiketts vergleichen.

import Foundation
import UIKit

extension UILabel {

    func countLabelLines() -> Int {
        // Call self.layoutIfNeeded() if your view is uses auto layout
        let myText = self.text! as NSString
        let attributes = [NSFontAttributeName : self.font]

        let labelSize = myText.boundingRect(with: CGSize(width: self.bounds.width, height: CGFloat.greatestFiniteMagnitude), options: NSStringDrawingOptions.usesLineFragmentOrigin, attributes: attributes, context: nil)
        return Int(ceil(CGFloat(labelSize.height) / self.font.lineHeight))
    }

    func isTruncated() -> Bool {

        if (self.countLabelLines() > self.numberOfLines) {
            return true
        }
        return false
    }
}

Um die Antwort von iDev zu ergänzen , sollten Sie intrinsicContentSizestattdessen verwenden frame, damit es für Autolayout funktioniert

- (BOOL)isTruncated:(UILabel *)label{
        CGSize sizeOfText = [label.text boundingRectWithSize: CGSizeMake(label.intrinsicContentSize.width, CGFLOAT_MAX)
                                                     options: (NSStringDrawingUsesLineFragmentOrigin|NSStringDrawingUsesFontLeading)
                                                  attributes: [NSDictionary dictionaryWithObject:label.font forKey:NSFontAttributeName] context: nil].size;

        if (self.intrinsicContentSize.height < ceilf(sizeOfText.height)) {
        return YES;
    }
    return NO;
}

Das ist es. Dies funktioniert mit attributedText, bevor textwir auf die Ebene zurückgreifen , was für uns Leute, die sich mit mehreren Schriftfamilien, -größen und sogar NSTextAttachments befassen, sehr sinnvoll ist!

Funktioniert gut mit Autolayout, aber offensichtlich müssen die Einschränkungen definiert und festgelegt werden, bevor wir sie überprüfen isTruncated. Andernfalls weiß das Etikett selbst nicht einmal, wie es sich selbst anordnen soll, sodass es auf keinen Fall wissen würde, ob es abgeschnitten ist.

Es funktioniert nicht, dieses Problem nur mit einem einfachen NSStringund zu lösen sizeThatFits. Ich bin mir nicht sicher, wie die Leute so positive Ergebnisse erzielt haben. Übrigens, wie bereits mehrfach erwähnt, ist die Verwendung überhaupt sizeThatFitsnicht ideal, da sie numberOfLinesdie resultierende Größe berücksichtigt , die den gesamten Zweck unseres Versuchs zunichte macht, da isTruncatedsie immer zurückkehren würde, falseunabhängig davon, ob sie abgeschnitten ist oder nicht.

extension UILabel {
    var isTruncated: Bool {
        layoutIfNeeded()

        let rectBounds = CGSize(width: bounds.width, height: .greatestFiniteMagnitude)
        var fullTextHeight: CGFloat?

        if attributedText != nil {
            fullTextHeight = attributedText?.boundingRect(with: rectBounds, options: .usesLineFragmentOrigin, context: nil).size.height
        } else {
            fullTextHeight = text?.boundingRect(with: rectBounds, options: .usesLineFragmentOrigin, attributes: [NSAttributedString.Key.font: font], context: nil).size.height
        }

        return (fullTextHeight ?? 0) > bounds.size.height
    }
}

Hier ist die ausgewählte Antwort in Swift 3 (als Erweiterung). Das OP fragte nach 1-Zeilen-Beschriftungen. Viele der schnellen Antworten, die ich hier ausprobiert habe, beziehen sich speziell auf mehrzeilige Beschriftungen und werden auf einzeiligen Beschriftungen nicht korrekt gekennzeichnet.

extension UILabel {
    var isTruncated: Bool {
        guard let labelText = text as? NSString else {
            return false
        }
        let size = labelText.size(attributes: [NSFontAttributeName: font])
        return size.width > self.bounds.width
    }
}

Dies funktioniert für iOS 8:

CGSize size = [label.text boundingRectWithSize:CGSizeMake(label.bounds.size.width, NSIntegerMax) options:NSStringDrawingUsesLineFragmentOrigin attributes:@{NSFontAttributeName : label.font} context:nil].size;

if (size.height > label.frame.size.height) {
    NSLog(@"truncated");
}

Ich habe eine Kategorie für die Arbeit mit UILabels Kürzung geschrieben. Funktioniert unter iOS 7 und höher. Ich hoffe es hilft ! uilabel Schwanzkürzung

@implementation UILabel (Truncation)

- (NSRange)truncatedRange
{
    NSTextStorage *textStorage = [[NSTextStorage alloc] initWithAttributedString:[self attributedText]];

    NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init];
    [textStorage addLayoutManager:layoutManager];

    NSTextContainer *textContainer = [[NSTextContainer alloc] initWithSize:[self bounds].size];
    textContainer.lineFragmentPadding = 0;
    [layoutManager addTextContainer:textContainer];

    NSRange truncatedrange = [layoutManager truncatedGlyphRangeInLineFragmentForGlyphAtIndex:0];
    return truncatedrange;
}

- (BOOL)isTruncated
{
    return [self truncatedRange].location != NSNotFound;
}

- (NSString *)truncatedText
{
    NSRange truncatedrange = [self truncatedRange];
    if (truncatedrange.location != NSNotFound)
    {
        return [self.text substringWithRange:truncatedrange];
    }

    return nil;
}

@end

extension UILabel {

public func resizeIfNeeded() -> CGFloat? {
    guard let text = text, !text.isEmpty else { return nil }

    if isTruncated() {
        numberOfLines = 0
        sizeToFit()
        return frame.height
    }
    return nil
}

func isTruncated() -> Bool {
    guard let text = text, !text.isEmpty else { return false }

    let size: CGSize = text.size(withAttributes: [NSAttributedStringKey.font: font])
    return size.width > self.bounds.size.width
    }
}

Sie können die Breite der Zeichenfolge berechnen und feststellen, ob die Breite größer als die Beschriftungsbreite ist.

Um zu dem hinzuzufügen, was @iDev getan hat, habe ich das self.frame.size.heightzu verwenden geändert label.frame.size.heightund auch nicht verwendet NSStringDrawingUsesLineFontLeading. Nach diesen Änderungen konnte ich perfekt berechnen, wann die Kürzung erfolgen würde (zumindest für meinen Fall).

- (BOOL)isTruncated:(UILabel *)label {
    CGSize sizeOfText = [label.text boundingRectWithSize: CGSizeMake(label.bounds.size.width, CGFLOAT_MAX)
                                                 options: (NSStringDrawingUsesLineFragmentOrigin)
                                              attributes: [NSDictionary dictionaryWithObject:label.font forKey:NSFontAttributeName] context: nil].size;

    if (label.frame.size.height < ceilf(sizeOfText.height)) {
        return YES;
    }
    return NO;
}

Ich hatte Probleme mit der boundingRect(with:options:attributes:context:)Verwendung von Autolayout (um eine maximale Höhe festzulegen) und einem zugeordneten Text mitNSParagraph.lineSpacing

Der Abstand zwischen den Zeilen wurde ignoriert (auch wenn er an attributesdie boundingRectMethode übergeben wurde), sodass die Beschriftung möglicherweise als nicht abgeschnitten betrachtet wird, wenn sie vorhanden war.

Die Lösung, die ich gefunden habe, ist zu verwenden UIView.sizeThatFits:

extension UILabel {
    var isTruncated: Bool {
        layoutIfNeeded()
        let heightThatFits = sizeThatFits(bounds.size).height
        return heightThatFits > bounds.size.height
    }
}

Da alle oben genannten Antworten veraltete Methoden verwenden, hielt ich dies für nützlich:

- (BOOL)isLabelTruncated:(UILabel *)label
{
    BOOL isTruncated = NO;

    CGRect labelSize = [label.text boundingRectWithSize:CGSizeFromString(label.text) options:NSStringDrawingUsesLineFragmentOrigin attributes:@{NSFontAttributeName : label.font} context:nil];

    if (labelSize.size.width / labelSize.size.height > label.numberOfLines) {

        isTruncated = YES;
    }

    return isTruncated;
}

Um mit iOS 6 fertig zu werden (ja, einige von uns müssen es noch), gibt es noch eine weitere Erweiterung der Antwort von @ iDev. Der Schlüssel zum Erfolg ist, dass Sie für iOS 6 sicherstellen müssen, dass die numberOfLines Ihres UILabels auf 0 gesetzt ist, bevor Sie sizeThatFits aufrufen. Wenn nicht, erhalten Sie ein Ergebnis, das besagt, dass "die Punkte zum Zeichnen von numberOfLines im Wert der Höhe" zum Zeichnen des Beschriftungstextes erforderlich sind.

- (BOOL)isTruncated
{
    CGSize sizeOfText;

    // iOS 7 & 8
    if([self.text respondsToSelector:@selector(boundingRectWithSize:options:attributes:context:)])
    {
        sizeOfText = [self.text boundingRectWithSize:CGSizeMake(self.bounds.size.width,CGFLOAT_MAX)
                                             options:(NSStringDrawingUsesLineFragmentOrigin|NSStringDrawingUsesFontLeading)
                                          attributes:@{NSFontAttributeName:self.font}
                                             context:nil].size;
    }
    // iOS 6
    else
    {
        // For iOS6, set numberOfLines to 0 (i.e. draw label text using as many lines as it takes)
        //  so that siteThatFits works correctly. If we leave it = 1 (for example), it'll come
        //  back telling us that we only need 1 line!
        NSInteger origNumLines = self.numberOfLines;
        self.numberOfLines = 0;
        sizeOfText = [self sizeThatFits:CGSizeMake(self.bounds.size.width,CGFLOAT_MAX)];
        self.numberOfLines = origNumLines;
    }

    return ((self.bounds.size.height < sizeOfText.height) ? YES : NO);
}

Stellen Sie sicher, dass Sie eine dieser Optionen in viewDidLayoutSubviews aufrufen.

public extension UILabel {

    var isTextTruncated: Bool {
        layoutIfNeeded()
        return text?.boundingRect(with: CGSize(width: bounds.width, height: .greatestFiniteMagnitude), options: .usesLineFragmentOrigin, attributes: [NSAttributedString.Key.font: font!], context: nil).size.height ?? 0 > bounds.size.height
    }

    var isAttributedTextTruncated: Bool {
        layoutIfNeeded()
        return attributedText?.boundingRect(with: CGSize(width: bounds.width, height: .greatestFiniteMagnitude), options: .usesLineFragmentOrigin, context: nil).size.height ?? 0 > bounds.size.height
    }

}

SWIFT 5

Beispiel für ein mehrzeiliges UILabel, das nur 3 Zeilen anzeigt.

    let labelSize: CGSize = myLabel.text!.size(withAttributes: [.font: UIFont.systemFont(ofSize: 14, weight: .regular)])

    if labelSize.width > myLabel.intrinsicContentSize.width * 3 {
        // your label will truncate
    }

Obwohl der Benutzer die Eingabetaste auswählen kann, um eine zusätzliche Zeile hinzuzufügen, ohne die "Textbreite" zu erhöhen, kann in diesem Fall auch so etwas nützlich sein.

func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool {

    if text == "\n" {
        // return pressed 

    }
}

Swift 3-Lösung

Ich denke, die beste Lösung besteht darin, (1) ein UILabelmit den gleichen Eigenschaften wie das Etikett zu erstellen, das Sie auf Kürzung prüfen, (2) aufzurufen .sizeToFit(), (3) die Attribute des Dummy-Etiketts mit Ihrem tatsächlichen Etikett zu vergleichen.

Wenn Sie beispielsweise überprüfen möchten, ob ein einzeiliges Etikett mit unterschiedlicher Breite abgeschnitten ist oder nicht, können Sie diese Erweiterung verwenden:

extension UILabel {
    func isTruncated() -> Bool {
        let label = UILabel(frame: CGRect(x: 0, y: 0, width: CGFloat.greatestFiniteMagnitude, height: self.bounds.height))
        label.numberOfLines = 1
        label.font = self.font
        label.text = self.text
        label.sizeToFit()
        if label.frame.width > self.frame.width {
            return true
        } else {
            return false
        }
    }
}

... aber auch hier können Sie den obigen Code leicht an Ihre Bedürfnisse anpassen. Nehmen wir also an, Ihr Etikett ist mehrzeilig und hat eine unterschiedliche Höhe. Dann würde die Erweiterung ungefähr so ​​aussehen:

extension UILabel {
    func isTruncated() -> Bool {
        let label = UILabel(frame: CGRect(x: 0, y: 0, width: self.bounds.width, height: CGFloat.greatestFiniteMagnitude))
        label.numberOfLines = 0
        label.font = self.font
        label.text = self.text
        label.sizeToFit()
        if label.frame.height > self.frame.height {
            return true
        } else {
            return false
        }
    }
}

Wäre es nicht einfach, das title-Attribut für die Beschriftung festzulegen? Wenn Sie dies festlegen, wird beim Bewegen des Mauszeigers die vollständige Beschriftung angezeigt.

Sie können die Länge des Etiketts und die Div-Breite berechnen (in Länge konvertieren - jQuery / Javascript - Wie konvertiere ich einen Pixelwert (20px) in einen Zahlenwert (20) ).

Setzen Sie jquery, um den Titel festzulegen, wenn die Länge größer als die div-Breite ist.

var divlen = parseInt(jQuery("#yourdivid").width,10);
var lablen =jQuery("#yourlabelid").text().length;
if(lablen < divlen){
jQuery("#yourlabelid").attr("title",jQuery("#yourlabelid").text());
}