Comprehensive Analysis of Dynamic UILabel Size Calculation Based on String in Swift

In iOS application development, UILabel serves as the most fundamental text display control, and dynamic calculation of its dimensions is a crucial technique for achieving adaptive layouts. When text content length is uncertain, developers need to precisely calculate the required height or width of UILabel based on the actual string content to ensure accurate and aesthetically pleasing interface layouts.

Core Calculation Principles

The size calculation of UILabel primarily relies on the boundingRect(with:options:attributes:context:) method. This method belongs to the NSString class and can be called in Swift by converting String to NSString or through direct extension methods. Its core parameters include:

• Constrained Size: Specifies maximum width or height limits during calculation via CGSize
• Calculation Options: Typically uses .usesLineFragmentOrigin to ensure correct calculation of multi-line text
• Text Attributes: The most important attribute is the font, passed as a dictionary [NSFontAttributeName: font]

Swift 3 Implementation

The following extension implementation for String type provides both height and width calculation methods:

extension String {
    func height(withConstrainedWidth width: CGFloat, font: UIFont) -> CGFloat {
        let constraintRect = CGSize(width: width, height: .greatestFiniteMagnitude)
        let boundingBox = self.boundingRect(with: constraintRect, 
                                          options: .usesLineFragmentOrigin, 
                                          attributes: [NSFontAttributeName: font], 
                                          context: nil)
        return ceil(boundingBox.height)
    }

    func width(withConstrainedHeight height: CGFloat, font: UIFont) -> CGFloat {
        let constraintRect = CGSize(width: .greatestFiniteMagnitude, height: height)
        let boundingBox = self.boundingRect(with: constraintRect, 
                                          options: .usesLineFragmentOrigin, 
                                          attributes: [NSFontAttributeName: font], 
                                          context: nil)
        return ceil(boundingBox.width)
    }
}

Rich Text Support

For text containing complex formatting, NSAttributedString extensions are equally important:

extension NSAttributedString {
    func height(withConstrainedWidth width: CGFloat) -> CGFloat {
        let constraintRect = CGSize(width: width, height: .greatestFiniteMagnitude)
        let boundingBox = boundingRect(with: constraintRect, 
                                     options: .usesLineFragmentOrigin, 
                                     context: nil)
        return ceil(boundingBox.height)
    }

    func width(withConstrainedHeight height: CGFloat) -> CGFloat {
        let constraintRect = CGSize(width: .greatestFiniteMagnitude, height: height)
        let boundingBox = boundingRect(with: constraintRect, 
                                     options: .usesLineFragmentOrigin, 
                                     context: nil)
        return ceil(boundingBox.width)
    }
}

Swift 4/5 Adaptation

In Swift 4 and later versions, the key name for font attributes has changed, requiring replacement of NSFontAttributeName with .font:

// Attribute dictionary in Swift 4/5
[.font: font]

Key Considerations

Several important details should be noted in practical usage:

1. Rounding Operations: Use the ceil() function to round up calculation results, avoiding pixel deviations due to floating-point precision issues
2. Constraint Value Selection: .greatestFiniteMagnitude indicates no restriction in that dimension, ensuring calculations are based on actual content
3. Performance Considerations: Frequent size calculations may impact performance; it's recommended to calculate when needed and cache results
4. Multi-line Text: Ensure UILabel's numberOfLines property is set to 0 to support multi-line display

Practical Application Example

Below is a complete example of UILabel size calculation and layout:

func configureLabel(with text: String, maxWidth: CGFloat) {
    let font = UIFont.systemFont(ofSize: 16)
    let labelHeight = text.height(withConstrainedWidth: maxWidth, font: font)
    
    let label = UILabel()
    label.font = font
    label.text = text
    label.numberOfLines = 0
    label.frame = CGRect(x: 20, y: 20, width: maxWidth, height: labelHeight)
    
    self.view.addSubview(label)
}

Through these methods, developers can precisely control UILabel dimensions and achieve flexible adaptive layouts. This technique is not only applicable to UILabel but can also be extended to other text controls like UITextView, providing powerful support for iOS application interface development.