[英]Using Auto Layout in UITableView for dynamic cell layouts & variable row heights
如何在表格视图中的UITableViewCell使用 Auto Layout 来让每个单元格的内容和子视图确定行高（本身/自动），同时保持平滑的滚动性能？
TL;DR：不喜欢阅读？ 直接跳转到 GitHub 上的示例项目：
无论您为哪个 iOS 版本开发，下面的前 2 个步骤都适用。
在你UITableViewCell子类，添加约束，使细胞的子视图具有其边缘固定到该单元的内容查看的（最重要的顶部和底部边缘）的边缘。 注意：不要将子视图固定到单元格本身； 仅到单元格的contentView ！ 通过确保每个子视图的垂直维度的内容压缩阻力和内容拥抱约束不会被您添加的更高优先级约束覆盖，让这些子视图的内在内容大小驱动表格视图单元格内容视图的高度。 （ 嗯？点这里。 ）
请记住，这个想法是让单元格的子视图垂直连接到单元格的内容视图，以便它们可以“施加压力”并使内容视图扩展以适应它们。 使用带有几个子视图的示例单元格，以下是一些（不是全部！）约束条件的可视化说明：
您可以想象，随着更多文本添加到上面示例单元格中的多行正文标签，它需要垂直增长以适应文本，这将有效地迫使单元格高度增长。 （当然，您需要正确设置约束才能使其正常工作！）
获得正确的约束绝对是使用自动布局获得动态单元格高度的最困难和最重要的部分。 如果你在这里犯了一个错误，它可能会阻止其他一切工作——所以慢慢来！ 我建议在代码中设置你的约束，因为你确切地知道在何处添加了哪些约束，并且在出现问题时更容易调试。 在代码中添加约束与使用布局锚点的 Interface Builder 或 GitHub 上可用的出色开源 API 之一一样简单，而且功能明显更强大。
updateConstraints方法中执行一次。 请注意， updateConstraints可能会被多次调用，因此为了避免多次添加相同的约束，请确保将添加约束的代码包装在updateConstraints中，以检查是否存在诸如didSetupConstraints类的布尔属性（在执行后将其设置为 YES）运行一次添加约束的代码）。 另一方面，如果您有更新现有约束的代码（例如调整某些约束的constant属性），请将其放在updateConstraints但在didSetupConstraints检查之外，以便每次调用该方法时都可以运行。对于单元中每组唯一的约束，使用唯一的单元重用标识符。 换句话说，如果您的单元格有多个独特的布局，则每个独特的布局都应该收到自己的重用标识符。 （当您的单元格变体具有不同数量的子视图，或者子视图以不同的方式排列时，您需要使用新的重用标识符的一个很好的提示。）
例如，如果您在每个单元格中显示一封电子邮件，您可能有 4 种独特的布局：只有一个主题的邮件、一个主题和一个正文的邮件、一个主题和一个照片附件的邮件以及一个主题的邮件，身体和照片附件。 每个布局都有完全不同的约束来实现它，因此一旦单元被初始化并为这些单元类型之一添加了约束，单元应该获得特定于该单元类型的唯一重用标识符。 这意味着当您将单元出列以供重用时，约束已经添加并准备好用于该单元类型。
请注意，由于内在内容大小的差异，具有相同约束（类型）的单元格可能仍具有不同的高度！ 由于内容的大小不同，不要将根本不同的布局（不同的约束）与不同的计算视图框架（从相同的约束解决）混淆。
要启用自调整表格视图单元格，您必须将表格视图的 rowHeight 属性设置为 UITableViewAutomaticDimension。 您还必须为estimatedRowHeight 属性分配一个值。 一旦设置了这两个属性，系统就会使用自动布局来计算行的实际高度
Apple： 使用自适应表格视图单元格
在 iOS 8 中，Apple 已经内化了之前必须由您在 iOS 8 之前实现的大部分工作。为了允许自调整单元格机制起作用，您必须首先将 table view 上的rowHeight属性设置为常量UITableView.automaticDimension 。 然后，您只需要通过将表视图的estimatedRowHeight属性设置为非零值来启用行高估计，例如：
self.tableView.rowHeight = UITableView.automaticDimension;
self.tableView.estimatedRowHeight = 44.0; // set to whatever your "average" cell height is
这样做是为表格视图提供一个临时估计/占位符，用于尚未出现在屏幕上的单元格的行高。 然后，当这些单元格即将在屏幕上滚动时，将计算实际行高。 为了确定每一行的实际高度，表格视图会根据内容视图的已知固定宽度（基于表格视图的宽度，减去任何其他内容，如部分）自动询问每个单元格的contentView需要什么高度索引或附件视图）以及您添加到单元格内容视图和子视图的自动布局约束。 一旦确定了该实际单元格高度，该行的旧估计高度将更新为新的实际高度（并且根据您的需要对表格视图的 contentSize/contentOffset 进行任何调整）。
一般来说，您提供的估计不必非常准确——它仅用于正确调整表格视图中滚动指示器的大小，并且表格视图可以很好地调整滚动指示器以适应不正确的估计在屏幕上滚动单元格。 您应该将表视图（在viewDidLoad或类似的）上的estimatedRowHeight属性设置为一个常量值，即“平均”行高。 只有当您的行高具有极大的可变性（例如，相差一个数量级）并且您在滚动时注意到滚动指示器“跳跃”时，您才应该费心实施tableView:estimatedHeightForRowAtIndexPath:以进行返回更准确估计所需的最少计算每一行。
首先，实例化一个表格视图单元的屏幕外实例，每个重用标识符一个实例，严格用于高度计算。 （离屏意味着单元格引用存储在视图控制器的属性/ivar 中，并且永远不会从tableView:cellForRowAtIndexPath:返回，以便表格视图实际呈现在屏幕上。）接下来，单元格必须配置准确的内容（例如文本，图像等），如果它要显示在表格视图中，它将保留。
然后，强制单元格立即布局其子视图，然后使用UITableViewCell的contentView上的systemLayoutSizeFittingSize:方法找出单元格所需的高度。 使用UILayoutFittingCompressedSize获得适合单元格所有内容所需的最小尺寸。 然后可以从tableView:heightForRowAtIndexPath:委托方法返回高度。
如果你的 table view 有几十行，你会发现在第一次加载 table view 时，做 Auto Layout 约束求解会很快卡住主线程，因为tableView:heightForRowAtIndexPath:会在每一行上调用在第一次加载时（为了计算滚动指示器的大小）。
从 iOS 7 开始，您可以（并且绝对应该）在 table view 上使用estimatedRowHeight属性。 这样做是为表格视图提供一个临时估计/占位符，用于尚未出现在屏幕上的单元格的行高。 然后，当这些单元格即将在屏幕上滚动时，将计算实际行高（通过调用tableView:heightForRowAtIndexPath: ），并使用实际行更新估计高度。
一般来说，您提供的估计不必非常准确——它仅用于正确调整表格视图中滚动指示器的大小，并且表格视图可以很好地调整滚动指示器以适应不正确的估计在屏幕上滚动单元格。 您应该将表视图（在viewDidLoad或类似的）上的estimatedRowHeight属性设置为一个常量值，即“平均”行高。 只有当您的行高具有极大的可变性（例如，相差一个数量级）并且您在滚动时注意到滚动指示器“跳跃”时，您才应该费心实施tableView:estimatedHeightForRowAtIndexPath:以进行返回更准确估计所需的最少计算每一行。
如果您已完成上述所有操作，但仍然发现在tableView:heightForRowAtIndexPath:进行约束求解时性能慢得令人无法接受，那么不幸的是，您将需要为单元格高度实现一些缓存。 （这是 Apple 工程师建议的方法。）一般的想法是让 Autolayout 引擎第一次解决约束，然后缓存该单元格的计算高度，并将缓存的值用于该单元格高度的所有未来请求。 当然，诀窍是确保在发生任何可能导致单元格高度发生变化的情况时清除单元格的缓存高度——主要是当该单元格的内容发生变化或其他重要事件发生时（例如用户调整动态类型文本大小滑块）。
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Determine which reuse identifier should be used for the cell at this
// index path, depending on the particular layout required (you may have
// just one, or may have many).
NSString *reuseIdentifier = ...;
// Dequeue a cell for the reuse identifier.
// Note that this method will init and return a new cell if there isn't
// one available in the reuse pool, so either way after this line of
// code you will have a cell with the correct constraints ready to go.
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:reuseIdentifier];
// Configure the cell with content for the given indexPath, for example:
// cell.textLabel.text = someTextForThisCell;
// ...
// Make sure the constraints have been set up for this cell, since it
// may have just been created from scratch. Use the following lines,
// assuming you are setting up constraints from within the cell's
// updateConstraints method:
[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];
// If you are using multi-line UILabels, don't forget that the
// preferredMaxLayoutWidth needs to be set correctly. Do it at this
// point if you are NOT doing it within the UITableViewCell subclass
// -[layoutSubviews] method. For example:
// cell.multiLineLabel.preferredMaxLayoutWidth = CGRectGetWidth(tableView.bounds);
return cell;
}
- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Determine which reuse identifier should be used for the cell at this
// index path.
NSString *reuseIdentifier = ...;
// Use a dictionary of offscreen cells to get a cell for the reuse
// identifier, creating a cell and storing it in the dictionary if one
// hasn't already been added for the reuse identifier. WARNING: Don't
// call the table view's dequeueReusableCellWithIdentifier: method here
// because this will result in a memory leak as the cell is created but
// never returned from the tableView:cellForRowAtIndexPath: method!
UITableViewCell *cell = [self.offscreenCells objectForKey:reuseIdentifier];
if (!cell) {
cell = [[YourTableViewCellClass alloc] init];
[self.offscreenCells setObject:cell forKey:reuseIdentifier];
}
// Configure the cell with content for the given indexPath, for example:
// cell.textLabel.text = someTextForThisCell;
// ...
// Make sure the constraints have been set up for this cell, since it
// may have just been created from scratch. Use the following lines,
// assuming you are setting up constraints from within the cell's
// updateConstraints method:
[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];
// Set the width of the cell to match the width of the table view. This
// is important so that we'll get the correct cell height for different
// table view widths if the cell's height depends on its width (due to
// multi-line UILabels word wrapping, etc). We don't need to do this
// above in -[tableView:cellForRowAtIndexPath] because it happens
// automatically when the cell is used in the table view. Also note,
// the final width of the cell may not be the width of the table view in
// some cases, for example when a section index is displayed along
// the right side of the table view. You must account for the reduced
// cell width.
cell.bounds = CGRectMake(0.0, 0.0, CGRectGetWidth(tableView.bounds), CGRectGetHeight(cell.bounds));
// Do the layout pass on the cell, which will calculate the frames for
// all the views based on the constraints. (Note that you must set the
// preferredMaxLayoutWidth on multiline UILabels inside the
// -[layoutSubviews] method of the UITableViewCell subclass, or do it
// manually at this point before the below 2 lines!)
[cell setNeedsLayout];
[cell layoutIfNeeded];
// Get the actual height required for the cell's contentView
CGFloat height = [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
// Add an extra point to the height to account for the cell separator,
// which is added between the bottom of the cell's contentView and the
// bottom of the table view cell.
height += 1.0;
return height;
}
// NOTE: Set the table view's estimatedRowHeight property instead of
// implementing the below method, UNLESS you have extreme variability in
// your row heights and you notice the scroll indicator "jumping"
// as you scroll.
- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath
{
// Do the minimal calculations required to be able to return an
// estimated row height that's within an order of magnitude of the
// actual height. For example:
if ([self isTallCellAtIndexPath:indexPath]) {
return 350.0;
} else {
return 40.0;
}
}
由于表格视图单元格包含 UILabels 中的动态内容，这些项目是具有可变行高的表格视图的完整工作示例。
如果您使用的是 Xamarin，请查看由@KentBoogaart 整理的这个示例项目。
对于上面的 iOS 8，它真的很简单：
override func viewDidLoad() {
super.viewDidLoad()
self.tableView.estimatedRowHeight = 80
self.tableView.rowHeight = UITableView.automaticDimension
}
或者
func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
return UITableView.automaticDimension
}
但是对于iOS 7，关键是计算autolayout后的高度：
func calculateHeightForConfiguredSizingCell(cell: GSTableViewCell) -> CGFloat {
cell.setNeedsLayout()
cell.layoutIfNeeded()
let height = cell.contentView.systemLayoutSizeFittingSize(UILayoutFittingExpandedSize).height + 1.0
return height
}
重要的
如果有多行标签，不要忘记将numberOfLines设置为0 。
不要忘记label.preferredMaxLayoutWidth = CGRectGetWidth(tableView.bounds)
完整的示例代码在这里。
为 Swift 3 更新
William Hu 的 Swift 回答很好，但它帮助我在第一次学习做某事时有一些简单而详细的步骤。 下面的示例是我在学习制作具有可变单元格高度的UITableView时的测试项目。 我基于Swift 的这个基本 UITableView 示例。
完成的项目应该是这样的：
它可以只是一个单一视图应用程序。
将一个新的 Swift 文件添加到您的项目中。 将其命名为 MyCustomCell。 这个类将保存您添加到故事板中单元格的视图的出口。 在这个基本示例中，我们将在每个单元格中只有一个标签。
import UIKit
class MyCustomCell: UITableViewCell {
@IBOutlet weak var myCellLabel: UILabel!
}
我们稍后会连接这个插座。
打开 ViewController.swift 并确保您有以下内容：
import UIKit
class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
// These strings will be the data for the table view cells
let animals: [String] = [
"Ten horses: horse horse horse horse horse horse horse horse horse horse ",
"Three cows: cow, cow, cow",
"One camel: camel",
"Ninety-nine sheep: sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep baaaa sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep",
"Thirty goats: goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat "]
// Don't forget to enter this in IB also
let cellReuseIdentifier = "cell"
@IBOutlet var tableView: UITableView!
override func viewDidLoad() {
super.viewDidLoad()
// delegate and data source
tableView.delegate = self
tableView.dataSource = self
// Along with auto layout, these are the keys for enabling variable cell height
tableView.estimatedRowHeight = 44.0
tableView.rowHeight = UITableViewAutomaticDimension
}
// number of rows in table view
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return self.animals.count
}
// create a cell for each table view row
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell:MyCustomCell = self.tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as! MyCustomCell
cell.myCellLabel.text = self.animals[indexPath.row]
return cell
}
// method to run when table view cell is tapped
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
print("You tapped cell number \(indexPath.row).")
}
}
重要的提示：
以下两行代码（以及自动布局）使可变单元格高度成为可能：
tableView.estimatedRowHeight = 44.0 tableView.rowHeight = UITableViewAutomaticDimension将一个 Table View 添加到您的视图控制器并使用自动布局将其固定到四个边。 然后将表视图单元格拖到表视图上。 并在原型单元格上拖动一个标签。 使用自动布局将标签固定到表格视图单元格内容视图的四个边缘。
重要的提示：
自定义类名和标识符
选择Table View Cell，设置自定义类为MyCustomCell （我们添加的Swift文件中的类名）。 cellReuseIdentifier标识符设置为cell （与我们在上面代码中用于cellReuseIdentifier字符串相同。
标签的零线
在标签中将行数设置为0 。 这意味着多行并允许标签根据其内容调整自身大小。
连接插座
ViewController代码中的tableView变量。myCellLabel对MyCustomCell类中的myCellLabel变量执行相同的myCellLabel 。您现在应该能够运行您的项目并获得具有可变高度的单元格。
如果您没有固定前缘和后缘（左右），您可能还需要设置标签的preferredMaxLayoutWidth以便它知道何时换行。 例如，如果您在上面的项目中为标签添加了水平居中约束而不是固定前缘和后缘，那么您需要将此行添加到tableView:cellForRowAtIndexPath方法：
cell.myCellLabel.preferredMaxLayoutWidth = tableView.bounds.width我决定将@smileyborg 的这个聪明的解决方案包装到UICollectionViewCell+AutoLayoutDynamicHeightCalculation类别中。
该类别还纠正了@wildmonkey 的回答中概述的问题（从笔尖和systemLayoutSizeFittingSize:加载单元格systemLayoutSizeFittingSize:返回CGRectZero ）
它没有考虑任何缓存，但适合我现在的需求。 随意复制、粘贴和破解它。
#import <UIKit/UIKit.h>
typedef void (^UICollectionViewCellAutoLayoutRenderBlock)(void);
/**
* A category on UICollectionViewCell to aid calculating dynamic heights based on AutoLayout contraints.
*
* Many thanks to @smileyborg and @wildmonkey
*
* @see stackoverflow.com/questions/18746929/using-auto-layout-in-uitableview-for-dynamic-cell-layouts-variable-row-heights
*/
@interface UICollectionViewCell (AutoLayoutDynamicHeightCalculation)
/**
* Grab an instance of the receiving type to use in order to calculate AutoLayout contraint driven dynamic height. The method pulls the cell from a nib file and moves any Interface Builder defined contrainsts to the content view.
*
* @param name Name of the nib file.
*
* @return collection view cell for using to calculate content based height
*/
+ (instancetype)heightCalculationCellFromNibWithName:(NSString *)name;
/**
* Returns the height of the receiver after rendering with your model data and applying an AutoLayout pass
*
* @param block Render the model data to your UI elements in this block
*
* @return Calculated constraint derived height
*/
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block collectionViewWidth:(CGFloat)width;
/**
* Directly calls `heightAfterAutoLayoutPassAndRenderingWithBlock:collectionViewWidth` assuming a collection view width spanning the [UIScreen mainScreen] bounds
*/
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block;
@end
#import "UICollectionViewCell+AutoLayout.h"
@implementation UICollectionViewCell (AutoLayout)
#pragma mark Dummy Cell Generator
+ (instancetype)heightCalculationCellFromNibWithName:(NSString *)name
{
UICollectionViewCell *heightCalculationCell = [[[NSBundle mainBundle] loadNibNamed:name owner:self options:nil] lastObject];
[heightCalculationCell moveInterfaceBuilderLayoutConstraintsToContentView];
return heightCalculationCell;
}
#pragma mark Moving Constraints
- (void)moveInterfaceBuilderLayoutConstraintsToContentView
{
[self.constraints enumerateObjectsUsingBlock:^(NSLayoutConstraint *constraint, NSUInteger idx, BOOL *stop) {
[self removeConstraint:constraint];
id firstItem = constraint.firstItem == self ? self.contentView : constraint.firstItem;
id secondItem = constraint.secondItem == self ? self.contentView : constraint.secondItem;
[self.contentView addConstraint:[NSLayoutConstraint constraintWithItem:firstItem
attribute:constraint.firstAttribute
relatedBy:constraint.relation
toItem:secondItem
attribute:constraint.secondAttribute
multiplier:constraint.multiplier
constant:constraint.constant]];
}];
}
#pragma mark Height
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block
{
return [self heightAfterAutoLayoutPassAndRenderingWithBlock:block
collectionViewWidth:CGRectGetWidth([[UIScreen mainScreen] bounds])];
}
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block collectionViewWidth:(CGFloat)width
{
NSParameterAssert(block);
block();
[self setNeedsUpdateConstraints];
[self updateConstraintsIfNeeded];
self.bounds = CGRectMake(0.0f, 0.0f, width, CGRectGetHeight(self.bounds));
[self setNeedsLayout];
[self layoutIfNeeded];
CGSize calculatedSize = [self.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];
return calculatedSize.height;
}
@end
- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout sizeForItemAtIndexPath:(NSIndexPath *)indexPath
{
MYSweetCell *cell = [MYSweetCell heightCalculationCellFromNibWithName:NSStringFromClass([MYSweetCell class])];
CGFloat height = [cell heightAfterAutoLayoutPassAndRenderingWithBlock:^{
[(id<MYSweetCellRenderProtocol>)cell renderWithModel:someModel];
}];
return CGSizeMake(CGRectGetWidth(self.collectionView.bounds), height);
}
谢天谢地，我们不必在 iOS8 中做这种爵士乐，但现在就可以了！
这是我的解决方案：
您需要在加载视图之前告诉TableView estimatedHeight TableView 。 否则它将无法像预期的那样运行。
目标-C
- (void)viewWillAppear:(BOOL)animated {
_messageField.delegate = self;
_tableView.estimatedRowHeight = 65.0;
_tableView.rowHeight = UITableViewAutomaticDimension;
}
更新到Swift 4.2
override func viewWillAppear(_ animated: Bool) {
tableView.rowHeight = UITableView.automaticDimension
tableView.estimatedRowHeight = 65.0
}
@smileyborg 提出的解决方案几乎是完美的。 如果您有一个自定义单元格并且您想要一个或多个具有动态高度的UILabel ，那么systemLayoutSizeFittingSize方法与启用AutoLayout相结合将返回一个CGSizeZero除非您将所有单元格约束从单元格移动到它的 contentView （如@TomSwift 在这里建议的如何调整大小）超级视图以适合所有具有自动布局的子视图？ ）。
为此，您需要在自定义 UITableViewCell 实现中插入以下代码（感谢@Adrian）。
- (void)awakeFromNib{
[super awakeFromNib];
for (NSLayoutConstraint *cellConstraint in self.constraints) {
[self removeConstraint:cellConstraint];
id firstItem = cellConstraint.firstItem == self ? self.contentView : cellConstraint.firstItem;
id seccondItem = cellConstraint.secondItem == self ? self.contentView : cellConstraint.secondItem;
NSLayoutConstraint *contentViewConstraint =
[NSLayoutConstraint constraintWithItem:firstItem
attribute:cellConstraint.firstAttribute
relatedBy:cellConstraint.relation
toItem:seccondItem
attribute:cellConstraint.secondAttribute
multiplier:cellConstraint.multiplier
constant:cellConstraint.constant];
[self.contentView addConstraint:contentViewConstraint];
}
}
将@smileyborg 的答案与此混合应该有效。
一个足够重要的问题，我刚刚遇到并作为答案发布。
@smileyborg 的回答大部分是正确的。 但是，如果您在自定义单元格类的layoutSubviews方法中有任何代码，例如设置preferredMaxLayoutWidth ，则不会使用以下代码运行：
[cell.contentView setNeedsLayout];
[cell.contentView layoutIfNeeded];
这让我困惑了一段时间。 然后我意识到这是因为那些只触发contentView上的 layoutSubviews ，而不是单元格本身。
我的工作代码如下所示：
TCAnswerDetailAppSummaryCell *cell = [self.tableView dequeueReusableCellWithIdentifier:@"TCAnswerDetailAppSummaryCell"];
[cell configureWithThirdPartyObject:self.app];
[cell layoutIfNeeded];
CGFloat height = [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
return height;
请注意，如果您正在创建一个新单元格，我很确定您不需要调用setNeedsLayout因为它应该已经设置好了。 在保存对单元格的引用的情况下，您可能应该调用它。 无论哪种方式，它都不应该伤害任何东西。
另一个提示，如果您使用单元格子类来设置诸如preferredMaxLayoutWidth 。 正如@smileyborg 提到的，“您的表格视图单元格的宽度尚未固定为表格视图的宽度”。 这是真的，如果你在你的子类中而不是在视图控制器中做你的工作，那就麻烦了。 但是，此时您可以使用表格宽度简单地设置单元格框架：
例如在计算高度时：
self.summaryCell = [self.tableView dequeueReusableCellWithIdentifier:@"TCAnswerDetailDefaultSummaryCell"];
CGRect oldFrame = self.summaryCell.frame;
self.summaryCell.frame = CGRectMake(oldFrame.origin.x, oldFrame.origin.y, self.tableView.frame.size.width, oldFrame.size.height);
（我碰巧缓存了这个特定的单元以供重用，但这无关紧要）。
万一人们仍然有这个问题。 我写了一篇关于将 Autolayout 与 UITableViews 结合使用的快速博客文章， 利用 Autolayout For Dynamic Cell Heights以及一个开源组件来帮助使其更抽象和更容易实现。 https://github.com/Raizlabs/RZCellSizeManager
（对于 Xcode 8.x / Xcode 9.x 在底部读取）
请注意 Xcode 7.x 中的以下问题，这可能会引起混淆：
Interface Builder 无法正确处理自动调整大小的单元格设置。 即使你的约束是绝对有效的，IB 仍然会抱怨并给你混乱的建议和错误。 原因是 IB 不愿意按照您的约束要求更改行的高度（以便单元格适合您的内容）。 相反，它保持行的高度固定并开始建议您更改您的约束，您应该忽略。
例如，假设您已经设置好一切，没有警告，没有错误，一切正常。
现在，如果您更改字体大小（在本示例中，我将描述标签字体大小从 17.0 更改为 18.0）。
因为字体变大了，标签现在要占据 3 行（之前它是占据 2 行）。
如果 Interface Builder 按预期工作，它将调整单元格的高度以适应新的标签高度。 然而，实际发生的是 IB 显示红色自动布局错误图标并建议您修改拥抱/压缩优先级。
您应该忽略这些警告。 您可以*做的是手动更改行的高度（选择单元格>大小检查器>行高）。
我一次单击一次（使用向上/向下步进器）更改此高度，直到红色箭头错误消失！ （您实际上会收到黄色警告，此时只需继续执行“更新帧”，它应该都能正常工作）。
* 请注意，您实际上不必在 Interface Builder 中解决这些红色错误或黄色警告 - 在运行时，一切都会正常工作（即使 IB 显示错误/警告）。 只需确保在运行时在控制台日志中您没有收到任何 AutoLayout 错误。
事实上，试图总是在 IB 中更新行高是非常烦人的，有时几乎不可能（因为小数值）。
为了防止烦人的 IB 警告/错误，您可以选择所涉及的视图并在Size Inspector为属性Ambiguity选择Verify Position Only
Xcode 8.x / Xcode 9.x 似乎（有时）做的事情与 Xcode 7.x 不同，但仍然不正确。 例如，即使compression resistance priority / hugging priority设置为 required (1000)，Interface Builder 也可能会拉伸或剪裁标签以适合单元格（而不是调整单元格高度以适合标签周围）。 在这种情况下，它甚至可能不会显示任何 AutoLayout 警告或错误。 或者有时它完全符合 Xcode 7.x 所做的，如上所述。
只要您在单元格中的布局良好。
-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
UITableViewCell *cell = [self tableView:tableView cellForRowAtIndexPath:indexPath];
return [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
}
更新：您应该使用 iOS 8 中引入的动态调整大小。
要为行高和估计行高设置自动尺寸，请确保按照以下步骤使自动尺寸对单元格/行高布局有效。
UITableViewAutomaticDimension分配给 rowHeight &estimatedRowHeightheightForRowAt并返回一个值UITableViewAutomaticDimension给它）——
目标 C：
// in ViewController.h
#import <UIKit/UIKit.h>
@interface ViewController : UIViewController <UITableViewDelegate, UITableViewDataSource>
@property IBOutlet UITableView * table;
@end
// in ViewController.m
- (void)viewDidLoad {
[super viewDidLoad];
self.table.dataSource = self;
self.table.delegate = self;
self.table.rowHeight = UITableViewAutomaticDimension;
self.table.estimatedRowHeight = UITableViewAutomaticDimension;
}
-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
return UITableViewAutomaticDimension;
}
迅速：
@IBOutlet weak var table: UITableView!
override func viewDidLoad() {
super.viewDidLoad()
// Don't forget to set dataSource and delegate for table
table.dataSource = self
table.delegate = self
// Set automatic dimensions for row height
// Swift 4.2 onwards
table.rowHeight = UITableView.automaticDimension
table.estimatedRowHeight = UITableView.automaticDimension
// Swift 4.1 and below
table.rowHeight = UITableViewAutomaticDimension
table.estimatedRowHeight = UITableViewAutomaticDimension
}
// UITableViewAutomaticDimension calculates height of label contents/text
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
// Swift 4.2 onwards
return UITableView.automaticDimension
// Swift 4.1 and below
return UITableViewAutomaticDimension
}
对于 UITableviewCell 中的标签实例
注意：如果您有多个具有动态长度的标签（UIElements），应根据其内容大小进行调整：为您希望以更高优先级展开/压缩的标签调整“内容拥抱和压缩阻力优先级”。
就像@Bob-Spryn 一样，我遇到了一个足够重要的问题，因此我将其发布为答案。
我在@smileyborg 的回答中挣扎了一段时间。 我遇到的问题是，如果您在 IB 中使用其他元素（ UILabels 、 UIButtons等）在 IB 中定义了原型单元格，当您使用 [ [YourTableViewCellClass alloc] init]实例化单元格时，它不会实例化所有其他[YourTableViewCellClass alloc] init]除非您编写了代码来执行此操作，否则该单元格中的元素。 （我对initWithStyle有类似的经历。）
要让故事板实例化所有附加元素，请使用[tableView dequeueReusableCellWithIdentifier:@"DoseNeeded"] （不是[tableView dequeueReusableCellWithIdentifier:forIndexPath:]因为这会导致有趣的问题。） IB 将被实例化。
一个解决storyboard Auto Layout问题的好方法：
- (CGFloat)heightForImageCellAtIndexPath:(NSIndexPath *)indexPath {
static RWImageCell *sizingCell = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sizingCell = [self.tableView dequeueReusableCellWithIdentifier:RWImageCellIdentifier];
});
[sizingCell setNeedsLayout];
[sizingCell layoutIfNeeded];
CGSize size = [sizingCell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];
return size.height;
}
另一个“解决方案”：跳过所有这些挫折并使用 UIScrollView 来获得与 UITableView 外观和感觉相同的结果。
这对我来说是一个痛苦的“解决方案”，在我总共投入了 20 多个非常令人沮丧的小时试图构建类似 Smileyborg 建议的东西并且失败了几个月和三个版本的 App Store 发布之后。
我的看法是，如果你真的需要 iOS 7 支持（对我们来说，这是必不可少的），那么这项技术太脆弱了，你会费力去尝试。 而且 UITableView 通常是完全矫枉过正的，除非您使用一些高级行编辑功能和/或确实需要支持 1000 多个“行”（在我们的应用程序中，它实际上永远不会超过 20 行）。
额外的好处是，与 UITableView 附带的所有委托废话和来回相比，代码变得非常简单。 它只是 viewOnLoad 中的一个单循环代码，看起来优雅且易于管理。
以下是有关如何执行此操作的一些提示：
使用 Storyboard 或 nib 文件，创建一个 ViewController 和关联的根视图。
将 UIScrollView 拖到您的根视图上。
将约束顶部、底部、左侧和右侧约束添加到顶级视图，以便 UIScrollView 填充整个根视图。
在 UIScrollView 中添加一个 UIView 并将其称为“容器”。 向 UIScrollView（其父级）添加顶部、底部、左侧和右侧约束。 关键技巧：还要添加一个“等宽”约束来链接 UIScrollView 和 UIView。
注意：您将收到错误消息“滚动视图具有不明确的可滚动内容高度”，并且您的容器 UIView 的高度应为 0 像素。 当应用程序运行时，这两个错误似乎都不重要。
为每个“单元”创建 nib 文件和控制器。 使用 UIView 而不是 UITableViewCell。
在您的根 ViewController 中，您基本上将所有“行”添加到容器 UIView 并以编程方式添加约束，将它们的左右边缘链接到容器视图，将它们的顶部边缘链接到容器视图顶部（对于第一项）或前一个细胞。 然后将最后一个单元格链接到容器底部。
对我们来说，每一“行”都在一个 nib 文件中。 所以代码看起来像这样：
class YourRootViewController {
@IBOutlet var container: UIView! //container mentioned in step 4
override func viewDidLoad() {
super.viewDidLoad()
var lastView: UIView?
for data in yourDataSource {
var cell = YourCellController(nibName: "YourCellNibName", bundle: nil)
UITools.addViewToTop(container, child: cell.view, sibling: lastView)
lastView = cell.view
//Insert code here to populate your cell
}
if(lastView != nil) {
container.addConstraint(NSLayoutConstraint(
item: lastView!,
attribute: NSLayoutAttribute.Bottom,
relatedBy: NSLayoutRelation.Equal,
toItem: container,
attribute: NSLayoutAttribute.Bottom,
multiplier: 1,
constant: 0))
}
///Add a refresh control, if you want - it seems to work fine in our app:
var refreshControl = UIRefreshControl()
container.addSubview(refreshControl!)
}
}
这是 UITools.addViewToTop 的代码：
class UITools {
///Add child to container, full width of the container and directly under sibling (or container if sibling nil):
class func addViewToTop(container: UIView, child: UIView, sibling: UIView? = nil)
{
child.setTranslatesAutoresizingMaskIntoConstraints(false)
container.addSubview(child)
//Set left and right constraints so fills full horz width:
container.addConstraint(NSLayoutConstraint(
item: child,
attribute: NSLayoutAttribute.Leading,
relatedBy: NSLayoutRelation.Equal,
toItem: container,
attribute: NSLayoutAttribute.Left,
multiplier: 1,
constant: 0))
container.addConstraint(NSLayoutConstraint(
item: child,
attribute: NSLayoutAttribute.Trailing,
relatedBy: NSLayoutRelation.Equal,
toItem: container,
attribute: NSLayoutAttribute.Right,
multiplier: 1,
constant: 0))
//Set vertical position from last item (or for first, from the superview):
container.addConstraint(NSLayoutConstraint(
item: child,
attribute: NSLayoutAttribute.Top,
relatedBy: NSLayoutRelation.Equal,
toItem: sibling == nil ? container : sibling,
attribute: sibling == nil ? NSLayoutAttribute.Top : NSLayoutAttribute.Bottom,
multiplier: 1,
constant: 0))
}
}
到目前为止，我发现这种方法唯一的“问题”是 UITableView 有一个很好的功能，即滚动时视图顶部的“浮动”部分标题。 除非您添加更多编程，否则上述解决方案不会这样做，但对于我们的特殊情况，此功能不是 100% 必不可少的，并且当它消失时没有人注意到。
如果您想在单元格之间设置分隔线，只需在自定义“单元格”底部添加一个 1 像素高的 UIView，看起来像分隔线。
一定要打开“反弹”和“垂直反弹”以使刷新控件工作，因此它看起来更像是一个表格视图。
TableView 会在您的内容下显示一些空行和分隔符，如果它没有填满全屏，而这个解决方案没有。 但就我个人而言，我更喜欢那些空行不存在的情况 - 可变单元格高度在我看来总是“有问题”，在那里有空行。
希望其他程序员在浪费 20 多个小时试图在他们自己的应用程序中使用 Table View 解决问题之前阅读我的帖子。 :)
tableView.estimatedRowHeight = 343.0
tableView.rowHeight = UITableViewAutomaticDimension
我不得不使用动态视图（通过代码设置视图和约束），当我想设置 preferredMaxLayoutWidth 标签的宽度为 0 时。所以我得到了错误的单元格高度。
然后我加了
[cell layoutSubviews];
执行前
[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];
在该标签的宽度符合预期并且动态高度计算正确之后。
假设您有一个带有子视图的单元格，并且您希望单元格的高度足够高以包含子视图 + 填充。
1) 设置子视图的底部约束等于 cell.contentView 减去你想要的填充。 不要对单元格或 cell.contentView 本身设置约束。
2) 将 tableView 的rowHeight属性或tableView:heightForRowAtIndexPath:为UITableViewAutomaticDimension 。
3）无论是设置的tableView的estimatedRowHeight财产或tableView:estimatedHeightForRowAtIndexPath:以高度的最佳猜测。
就是这样。
如果您以编程方式进行布局，以下是在 Swift 中使用锚点的 iOS 10 需要考虑的事项。
有三个规则/步骤
NUMBER 1：在 viewDidLoad 上设置 tableview 的这两个属性，第一个是告诉 tableview 应该期望其单元格上的动态大小，第二个只是让应用程序计算滚动条指示器的大小，因此它有助于表现。
tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = 100
数字 2：这很重要，您需要将子视图添加到单元格的 contentView 而不是视图，并且还使用它的 layoutsmarginguide 将子视图锚定到顶部和底部，这是如何做到这一点的工作示例。
override init(style: UITableViewCellStyle, reuseIdentifier: String?) {
super.init(style: style, reuseIdentifier: reuseIdentifier)
setUpViews()
}
private func setUpViews() {
contentView.addSubview(movieImageView)
contentView.addSubview(descriptionLabel)
let marginGuide = contentView.layoutMarginsGuide
NSLayoutConstraint.activate([
movieImageView.heightAnchor.constraint(equalToConstant: 80),
movieImageView.widthAnchor.constraint(equalToConstant: 80),
movieImageView.leftAnchor.constraint(equalTo: marginGuide.leftAnchor),
movieImageView.topAnchor.constraint(equalTo: marginGuide.topAnchor, constant: 20),
descriptionLabel.leftAnchor.constraint(equalTo: movieImageView.rightAnchor, constant: 15),
descriptionLabel.rightAnchor.constraint(equalTo: marginGuide.rightAnchor),
descriptionLabel.bottomAnchor.constraint(equalTo: marginGuide.bottomAnchor, constant: -15),
descriptionLabel.topAnchor.constraint(equalTo: movieImageView.topAnchor)
])
}
创建一个方法来添加子视图并执行布局，在 init 方法中调用它。
数字 3：不要调用方法：
override func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
}
如果你这样做，你将覆盖你的实现。
在 tableviews 中遵循这 3 条动态单元格规则。
这是一个有效的实现https://github.com/jamesrochabrun/MinimalViewController
如果你有一个很长的字符串。 例如一个没有换行符的。 那么你可能会遇到一些问题。
接受的答案和其他几个答案都提到了“所谓的”修复。 你只需要添加
cell.myCellLabel.preferredMaxLayoutWidth = tableView.bounds.width
我发现苏拉格的回答最完整和简洁，因此不会令人困惑。
虽然没有解释为什么需要这些改变。 让我们这样做。
将以下代码放入项目中。
import UIKit
class ViewController: UIViewController {
lazy var label : UILabel = {
let lbl = UILabel()
lbl.translatesAutoresizingMaskIntoConstraints = false
lbl.backgroundColor = .red
lbl.textColor = .black
return lbl
}()
override func viewDidLoad() {
super.viewDidLoad()
// step0: (0.0, 0.0)
print("empty Text intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step1: (29.0, 20.5)
label.text = "hiiiii"
print("hiiiii intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step2: (328.0, 20.5)
label.text = "translatesAutoresizingMaskIntoConstraints"
print("1 translate intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step3: (992.0, 20.5)
label.text = "translatesAutoresizingMaskIntoConstraints translatesAutoresizingMaskIntoConstraints translatesAutoresizingMaskIntoConstraints"
print("3 translate intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step4: (328.0, 20.5)
label.text = "translatesAutoresizingMaskIntoConstraints\ntranslatesAutoresizingMaskIntoConstraints\ntranslatesAutoresizingMaskIntoConstraints"
print("3 translate w/ line breaks (but the line breaks get ignored, because numberOfLines is defaulted to `1` and it will force it all to fit into one line! intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step5: (328.0, 61.0)
label.numberOfLines = 0
print("3 translate w/ line breaks and '0' numberOfLines intrinsicContentSize: \(label.intrinsicContentSize)")
// ----------
// step6: (98.5, 243.5)
label.preferredMaxLayoutWidth = 100
print("3 translate w/ line breaks | '0' numberOfLines | preferredMaxLayoutWidth: 100 intrinsicContentSize: \(label.intrinsicContentSize)")
setupLayout()
}
func setupLayout(){
view.addSubview(label)
label.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
label.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true
}
}
请注意，我没有添加任何大小限制。 我只添加了 centerX、centerY 约束。 但是标签的尺寸仍然正确，为什么？
因为contentSize 。
为了更好地处理这个问题，首先保留 step0，然后注释掉步骤 1-6。 让setupLayout()留下来。 观察行为。
然后取消注释step1，并观察。
然后取消注释 step2 并观察。
这样做直到您取消了所有 6 个步骤的注释并观察了它们的行为。
contenSize ？\\n则内在内容大小的宽度将是所有行的最大宽度。 如果一行有 25 个字符，另一行有 2 个字符，另一行有 21 个字符，那么您的宽度将根据 25 个字符计算numberOfLines设置为0否则您将不会有多行。 您的numberOfLines将调整您的内在内容大小的高度进行调整：想象一下，根据您的文本，您的内在内容大小的宽度为200 ，高度为100 ，但您想将宽度限制为标签的容器，您打算怎么做？ 解决方案是将其设置为所需的宽度。 您可以通过将preferredMaxLayoutWidth设置为130来做到这一点，然后您的新内在内容大小将具有大约130的宽度。 高度显然会超过100因为您需要更多的线条。 话虽如此，如果您的约束设置正确，那么您根本不需要使用它！ 有关更多信息，请参阅此答案及其评论。 如果您没有限制宽度/高度的约束，您只需要使用preferredMaxLayoutWidth ，因为有人可能会说“除非文本超过preferredMaxLayoutWidth否则不要换行”。 但是，如果您将前导/尾随和numberOfLines为0则可以 100% 确定，那么您就很好！ 长话短说，这里推荐使用它的大多数答案都是错误的！ 你不需要它。 需要它表明您的约束设置不正确或您只是没有约束
字体大小：另请注意，如果您增加 fontSize，那么 internalContentSize 的高度将增加。 我没有在我的代码中显示这一点。 你可以自己试试。
所以回到你的 tableViewCell 示例：
您需要做的就是：
numberOfLines设置为0preferredMaxLayoutWidth 。在我的情况下，我必须创建一个带有来自服务器的图像的自定义单元格，并且可以是任何宽度和高度。 和两个具有动态大小（宽度和高度）的 UILabels
我在我的回答中通过自动布局和以编程方式实现了同样的目标：
基本上高于@smileyBorg 的回答有帮助，但 systemLayoutSizeFittingSize 从来没有为我工作过，在我的方法中：
1. 没有使用自动行高计算属性。 2. 不使用估计高度 3. 不需要不必要的更新约束。 4.不使用自动首选最大布局宽度。 5. 不使用systemLayoutSizeFittingSize （应该有用但对我不起作用，我不知道它在内部做什么），而是我的方法 -(float)getViewHeight 工作，我知道它在内部做什么。
在我的情况下，填充是因为 sectionHeader 和 sectionFooter 高度，故事板允许我将其更改为最小 1。所以在 viewDidLoad 方法中：
tableView.sectionHeaderHeight = 0
tableView.sectionFooterHeight = 0
我只是做了一些愚蠢的尝试和错误使用的2个值rowHeight和estimatedRowHeight ，只是认为它可能提供一些见解调试：
如果您同时设置它们或仅设置estimatedRowHeight您将获得所需的行为：
tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = 1.00001 // MUST be greater than 1
建议您尽最大努力获得正确的估计，但最终结果并没有什么不同。 它只会影响你的表现。
如果你只设置 rowHeight 即只做：
tableView.rowHeight = UITableViewAutomaticDimension
你的最终结果不会如你所愿：
如果设置estimatedRowHeight为1或更小，那么你会不管的崩溃rowHeight 。
tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = 1
我因以下错误消息而崩溃：
Terminating app due to uncaught exception
'NSInternalInconsistencyException', reason: 'table view row height
must not be negative - provided height for index path (<NSIndexPath:
0xc000000000000016> {length = 2, path = 0 - 0}) is -1.000000'
...some other lines...
libc++abi.dylib: terminating with uncaught exception of type
NSException
关于@smileyborg 接受的答案，我发现
[cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize]
在某些约束不明确的情况下不可靠。 通过使用下面 UIView 上的辅助类别，最好强制布局引擎计算一个方向的高度：
-(CGFloat)systemLayoutHeightForWidth:(CGFloat)w{
[self setNeedsLayout];
[self layoutIfNeeded];
CGSize size = [self systemLayoutSizeFittingSize:CGSizeMake(w, 1) withHorizontalFittingPriority:UILayoutPriorityRequired verticalFittingPriority:UILayoutPriorityFittingSizeLevel];
CGFloat h = size.height;
return h;
}
其中 w: 是 tableview 的宽度
只需在您的视图控制器中添加这两个函数即可解决您的问题。 在这里， list 是一个字符串数组，其中包含您的每一行的字符串。
func tableView(_ tableView: UITableView,
estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
tableView.rowHeight = self.calculateHeight(inString: list[indexPath.row])
return (tableView.rowHeight)
}
func calculateHeight(inString:String) -> CGFloat
{
let messageString = input.text
let attributes : [NSAttributedStringKey : Any] = [NSAttributedStringKey(rawValue: NSAttributedStringKey.font.rawValue) : UIFont.systemFont(ofSize: 15.0)]
let attributedString : NSAttributedString = NSAttributedString(string: messageString!, attributes: attributes)
let rect : CGRect = attributedString.boundingRect(with: CGSize(width: 222.0, height: CGFloat.greatestFiniteMagnitude), options: .usesLineFragmentOrigin, context: nil)
let requredSize:CGRect = rect
return requredSize.height
}
swift 4
@IBOutlet weak var tableViewHeightConstraint: NSLayoutConstraint!
@IBOutlet weak var tableView: UITableView!
private var context = 1
override func viewDidLoad() {
super.viewDidLoad()
self.tableView.addObserver(self, forKeyPath: "contentSize", options: [.new,.prior], context: &context)
}
// Added observer to adjust tableview height based on the content
override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
if context == &self.context{
if let size = change?[NSKeyValueChangeKey.newKey] as? CGSize{
print("-----")
print(size.height)
tableViewHeightConstraint.constant = size.height + 50
}
}
}
//Remove observer
deinit {
NotificationCenter.default.removeObserver(self)
}
如果单元格高度是由内容动态变化的，您应该精确地将其计算出来，然后在呈现单元格之前返回高度值。 一个简单的方法是在表格视图单元格代码中定义计数方法，以便控制器在表格单元格高度委托方法时调用。 如果高度依赖于表格或屏幕的宽度，请不要忘记计算实际单元格框架宽度（默认为 320）。 即在表格单元格高度委托方法中，先使用cell.frame对单元格宽度进行修正，然后调用单元格中定义的计数高度方法获取合适的值并返回。
附注。 生成单元格对象的代码可以定义在另一种方法中，供不同的表视图单元格委托方法调用。
UITableView.automaticDimension可以通过 Interface Builder 设置：
Xcode > 故事板 > 尺寸检查器
表格视图单元格 > 行高 >自动
Swift 中的另一个 iOs7+iOs8 解决方案
var cell2height:CGFloat=44
override func viewDidLoad() {
super.viewDidLoad()
theTable.rowHeight = UITableViewAutomaticDimension
theTable.estimatedRowHeight = 44.0;
}
func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
let cell = tableView.dequeueReusableCellWithIdentifier("myTableViewCell", forIndexPath: indexPath) as! myTableViewCell
cell2height=cell.contentView.height
return cell
}
func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
if #available(iOS 8.0, *) {
return UITableViewAutomaticDimension
} else {
return cell2height
}
}
iOS 7/8 UITableView Cell：两个UILabel，动态高度，自动布局，可变行高
[英]iOS 7/8 UITableView Cell: Two UILabels with dynamic height with auto layout for variable row height
将自动布局与动态UITextView，UIImageView和UILabel Heights一起使用
[英]Using Auto Layout with Dynamic UITextView, UIImageView, and UILabel Heights
带有动态单元格高度的UITableView的reloadData不必要的滚动
[英]reloadData of UITableView with Dynamic cell heights unwanted scroll
使用uitableview静态单元格和uitableview动态原型的ios 8布局
[英]ios 8 layout using uitableview static cell & uitableview dynamic prototypes
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.