如何检查 UILabel 是否被截断？

Question

我有一个 UILabel，它的长度可能会有所不同，具体取决于我的应用程序在 iPhone 或 iPad 上以纵向还是横向模式运行。当文本太长而无法在一行上显示并且它被截断时，我希望用户能够按下它并获得全文的弹出窗口。

如何检查 UILabel 是否截断文本？有可能吗？现在我只是根据我所处的模式检查不同的长度，但效果不是很好。

Answer 1

您可以计算字符串的宽度并查看宽度是否为大于 label.bounds.size.width

NSString UIKit Additions 有几种方法来计算具有特定字体的字符串的大小。但是，如果您的标签有一个最小字体大小，允许系统将文本缩小到该大小。您可能需要使用 sizeWithFont:minFontSize:actualFontSize:forWidth:lineBreakMode: 在这种情况下。

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

Answer 2

Swift (作为扩展) - 适用于多行 uilabel:

swift4: (boundingRect 的 attributes 参数略有改变)

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
    }

}

Answer 3

编辑：我刚刚看到我的答案被赞成，但我给出的代码片段已被弃用。
现在最好的方法是（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");
}

注意计算的大小不是整数值。因此，如果您执行诸如 int height = rect.size.height 之类的操作，您将丢失一些浮点精度，并且可能会得到错误的结果。

旧答案（已弃用）：

如果您的标签是多行的，您可以使用以下代码：

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

Answer 4

看起来 intrinsicContentSize 可以完成使用 attributedText 和 text 设置文本的标签的工作。考虑到这一点，我认为我们可以安全地放弃所有边界框簿记并简化如下：

Swift 5.x

extension UILabel {
    var isTruncated: Bool {
       frame.width < intrinsicContentSize.width
    }

    var isClipped: Bool {
        frame.height < intrinsicContentSize.height
    }
}

Answer 5

Swift 3

您可以在分配字符串后计算行数，并与标签的最大行数进行比较。

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 {
        guard numberOfLines > 0 else { return false }
        return countLabelLines() > numberOfLines
    }
}

Answer 6

你可以用 UILabel 创建一个类别

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

Answer 7

要添加到 iDev 的答案，您应该使用 intrinsicContentSize 而不是 frame< /code>，使其适用于自动布局

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

Answer 8

使用此类别可查找标签在 iOS 7 及更高版本上是否被截断。

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

Answer 9

就是这样。这适用于 attributedText，然后返回到纯 text，这对于我们处理多种字体系列、大小甚至 NSTextAttachments 的人来说非常有意义！

与自动布局一起工作得很好，但显然在我们检查 isTruncated 之前必须定义和设置约束，否则标签本身甚至不知道如何布局自己，所以它甚至不知道它是否被截断。

仅使用简单的 NSString 和 sizeThatFits 无法解决此问题。我不确定人们是如何获得这样的积极结果的。顺便说一句，正如多次提到的，使用 sizeThatFits 根本不理想，因为它考虑了 numberOfLines 来计算结果大小，这违背了我们想要的整个目的。这样做，因为无论是否被截断，isTruncated 总是返回 false。

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

Answer 10

这是 Swift 3 中选定的答案（作为扩展）。 OP 正在询问 1 行标签。我在这里尝试的许多快速答案都是特定于多行标签的，并且在单行标签上没有正确标记。

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

Answer 11

这适用于 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");
}

Answer 12

我编写了一个用于处理 UILabel 截断的类别。适用于 iOS 7 及更高版本。希望有帮助！
uilabel 尾部截断

@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

Answer 13

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

您可以计算字符串的宽度，看看宽度是否大于标签宽度。

Answer 14

为了添加 @iDev 所做的，我将 self.frame.size.height 修改为使用label.frame.size.height并且也没有使用NSStringDrawingUsesLineFontLeading。经过这些修改后，我完美地计算了截断何时发生（至少对于我的情况）。

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

Answer 15

我遇到了 boundingRect(with:options:attributes:context:) 问题 当使用自动布局（设置最大高度）和带有 NSParagraph.lineSpacing

行之间的间距被忽略（即使将 attributes 传递给 boundingRect 方法）因此标签在被截断时可能被认为没有被截断。

我找到的解决方案是使用 UIView.sizeThatFits< /a>：

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

Answer 16

确保在 viewDidLayoutSubviews 中调用其中一个。

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
    }

}

Answer 17

SWIFT 5

设置为仅显示 3 行的多行 UILabel 示例。

    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
    }

尽管用户可以选择返回键添加额外的行而不添加“文本宽度”，但在这种情况下类似的东西也可能有用。

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

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

    }
}

Answer 18

在 Swift 5.x 中

let size = label.text?.size(withAttributes: [NSAttributedString.Key.font: label.font!])
if size!.width > label.bounds.size.width {
    debugPrint("Size increased", size?.width ?? 0, label.bounds.size.width, label.text ?? "")
}

Answer 19

因为上面的所有答案都使用折旧方法，所以我认为这可能有用：

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

Answer 20

使用 numberOfLines 并不总是有用，因为它可能为零，并且标签可能由于高度限制而被截断。另外，在我的情况下，intrinsicContentSize 没有返回正确的大小。您可以使用此扩展：

extension UILabel {

    var currentContentSize: CGSize {
      layoutIfNeeded()
      let myText = text! as NSString
      let attributes: [NSAttributedString.Key: Any] = [.font: font!]

      let labelRect = myText.boundingRect(with: CGSize(width: bounds.width,
                                                       height: .greatestFiniteMagnitude),
                                          options: .usesLineFragmentOrigin,
                                          attributes: attributes,
                                          context: nil)
      return CGSize(width: labelRect.width, height: labelRect.height)
    }

    var isTruncated: Bool {
      layoutIfNeeded()
      return frame.width < currentContentSize.width || frame.height < currentContentSize.height
    }
}

Answer 21

为了处理 iOS 6（是的，我们中的一些人仍然必须这样做），这是对 @iDev 答案的另一个扩展。关键要点是，对于 iOS 6，在调用 sizeThatFits 之前确保 UILabel 的 numberOfLines 设置为 0；如果没有，它会给你一个结果，显示“绘制标签文本需要绘制 numberOfLines 高度的点”。

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

Answer 22

Swift 3 解决方案

我认为最好的解决方案是(1)创建一个与您要检查是否有截断的标签，(2)调用.sizeToFit()，(3)将虚拟标签的属性与您的标签进行比较实际标签。

例如，如果您想检查具有不同宽度的单行标签是否被截断，那么您可以使用此扩展：

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

...但同样，您可以轻松修改上述代码以满足您的需求。假设您的标签是多行的并且具有不同的高度。然后扩展看起来像这样：

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

Answer 23

设置标签的标题属性是不是很容易，设置此属性将在悬停时显示完整的标签。

您可以计算标签的长度和div宽度（转换为长度 - jQuery / Javascript - 如何将像素值 (20px) 转换为数字值 (20))。

如果长度大于 div 宽度，则设置 jquery 设置标题。

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