Introduction

A UITableView does not automatically shrink or grow to exactly match its content height when embedded inside another view. If you want the table to fit its rows instead of scrolling internally, you usually need either a height constraint that tracks contentSize.height or a custom subclass that exposes an intrinsic content size based on the current content.

Know What You Want the Table to Do

There are two common use cases that look similar but should be solved differently:

• the table should expand to show all rows with no internal scrolling
• the table should have a fixed area and scroll inside itself

If you choose the first behavior, disable internal scrolling and make the surrounding layout responsible for the overall height.

tableView.isScrollEnabled = false

Without that, the table may keep its own scrolling behavior and your height updates can feel inconsistent.

The Simple Approach: Update a Height Constraint

If the table view already has a height constraint, the most direct pattern is to update that constraint after the content has been laid out.

1import UIKit
2
3final class ItemsViewController: UIViewController, UITableViewDataSource {
4    @IBOutlet private weak var tableView: UITableView!
5    @IBOutlet private weak var tableHeightConstraint: NSLayoutConstraint!
6
7    private let items = ["A", "B", "C", "D"]
8
9    override func viewDidLoad() {
10        super.viewDidLoad()
11        tableView.dataSource = self
12        tableView.isScrollEnabled = false
13    }
14
15    override func viewDidLayoutSubviews() {
16        super.viewDidLayoutSubviews()
17        tableHeightConstraint.constant = tableView.contentSize.height
18    }
19
20    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
21        items.count
22    }
23
24    func tableView(_ tableView: UITableView,
25                   cellForRowAt indexPath: IndexPath) -> UITableViewCell {
26        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell")
27            ?? UITableViewCell(style: .default, reuseIdentifier: "Cell")
28        cell.textLabel?.text = items[indexPath.row]
29        return cell
30    }
31}

This works well when the table is embedded in another controller view or stack-like layout.

Reload Then Recalculate

If the data changes at runtime, update the height after reloading the table.

tableView.reloadData()
tableView.layoutIfNeeded()
tableHeightConstraint.constant = tableView.contentSize.height

layoutIfNeeded() matters because contentSize may not be final immediately after reloadData().

A Cleaner Reusable Approach: Subclass with Intrinsic Content Size

If you need this behavior in several places, a subclass is often cleaner than manually synchronizing constraints everywhere.

1import UIKit
2
3final class ContentSizedTableView: UITableView {
4    override var contentSize: CGSize {
5        didSet {
6            invalidateIntrinsicContentSize()
7        }
8    }
9
10    override var intrinsicContentSize: CGSize {
11        layoutIfNeeded()
12        return CGSize(width: UIView.noIntrinsicMetric, height: contentSize.height)
13    }
14}

With this subclass, Auto Layout can size the table based on its content height more naturally.

This is especially useful when the table lives inside a UIStackView or another view that respects intrinsic sizes.

Self-Sizing Cells Change the Timing

If the table uses UITableView.automaticDimension, the final height depends on Auto Layout inside each cell. In that case, make sure your cell constraints are complete and avoid reading contentSize too early.

Typical setup:

tableView.rowHeight = UITableView.automaticDimension
tableView.estimatedRowHeight = 60

This helps the table calculate row heights, but the final content height still becomes reliable only after layout has happened.

Embedded Table Views Are Often a Design Smell

A table view that fully expands to fit all rows is often used inside another scroll view or container. That can be valid, but it is also worth asking whether a stack view or a static vertical layout would be simpler.

If the content is small and non-recyclable, a full table view may be more machinery than the UI actually needs.

That is not a rule against table views. It is just a reminder to choose the smallest UI abstraction that matches the job.

Avoid Infinite Layout Loops

Be careful not to trigger layout changes in a way that recursively causes more layout passes forever. For example, repeatedly changing constraints from the wrong callback can create jitter or layout warnings.

A stable pattern is:

• reload data
• force layout if needed
• update the height once

That is usually enough.

Common Pitfalls

• Expecting UITableView to size itself to content automatically in every layout.
• Reading contentSize before the table has completed layout.
• Forgetting to disable internal scrolling when the goal is full expansion.
• Using self-sizing cells without complete Auto Layout constraints inside the cell.
• Embedding a table view in another scrolling layout without being clear which view should own scrolling.

Summary

• To make a table view fit its content, either update a height constraint or use a subclass with intrinsic content size.
• Disable internal scrolling if the table should expand instead of scroll.
• Recalculate height after layout, not immediately after reloadData() alone.
• Self-sizing cells make timing more important because final heights depend on Auto Layout.
• If the content is small and static, consider whether a simpler view hierarchy would be better than an embedded table.