Constraints by Code: The right way

Written By Author One

All code below is written in XCode: 16.1

It’s 2025, and you are still using UIKit, and you finally managed to move away from Storyboards and have started making your app’s UI using code. Well, congrats on the transition, and this guide should help you trim down your UIKit-related code to a bare minimum.
 I’m going to assume that you already know how to add constraints to UIView with code and that you are here to find out the most optimized way to write this code. The objective here is to create an extension to UIView, where we will define a method which can accept any number of constraints as parameters. In this method, we are going to assign these constraint relations to the said view. What we need before we begin writing this method is to define which all constraints we are planning to support in this implementation. Why not all the constraints applicable to a UIView? Sure, we can do that, but to make this guide short, I’m going to make this method support the below constraints: 

enum Constraints {
    case top(NSLayoutYAxisAnchor, CGFloat)
    case leading(NSLayoutXAxisAnchor, CGFloat)
    case bottom(NSLayoutYAxisAnchor, CGFloat)
    case trailing(NSLayoutXAxisAnchor, CGFloat)
    case width(NSLayoutDimension?, CGFloat)
    case height(NSLayoutDimension?, CGFloat)
    case centerX(NSLayoutXAxisAnchor, CGFloat)
    case centerY(NSLayoutYAxisAnchor, CGFloat)
}
We define the above enum which contains the most common constraints that are used while creating a UI using UIKit. You may add more constraint types as you wish, after completing this guide. Now, let us define a method through which we can add a few of these Constraints to a view. 

extension UIView {
    func addConstraints(_ constraints: Constraints...) { }
}




The addConstraints(_ constraints: Constraints...) methods is a variadic function. This means, when we call this method, we may add any number of Constraints objects as the method’s parameters. We can now, loop through these Constraints and use a switch case statement to determine what type of Constraint this is. 

func addConstraints(_ constraints: Constraints...) {
        self.translatesAutoresizingMaskIntoConstraints = false
        for constraint in constraints {
            switch constraint {
            case .top(let anchor, let constant):
                break
            case .leading(let anchor, let constant):
                break
            case .bottom(let anchor, let constant):
                break
            case .trailing(let anchor, let constant):
                break
            case .width(let anchor, let constant):
                break
            case .height(let anchor, let constant):
                break
            case .centerX(let anchor, let constant):
                break
            case .centerY(let anchor, let constant):
            }
        }
    }
This is where the associated values that we added to the Constraints enum come in handy. These associated values can hold a NSLayoutAnchor value and a constant value. These associated values can now be used to construct a constraint relation to the current UIView.



Our UIView extension can now be written as:
 

extension UIView {
    func addConstraints(_ constraints: Constraints...) {
        self.translatesAutoresizingMaskIntoConstraints = false
        for constraint in constraints {
            switch constraint {
            case .top(let anchor, let constant):
                self.topAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                break
            case .leading(let anchor, let constant):
                self.leadingAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                break
            case .bottom(let anchor, let constant):
                self.bottomAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                break
            case .trailing(let anchor, let constant):
                self.trailingAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                break
            case .width(let anchor, let constant):
                if let anchor = anchor {
                    self.widthAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                } else {
                    self.widthAnchor.constraint(equalToConstant: constant).isActive = true
                }
            case .height(let anchor, let constant):
                if let anchor = anchor {
                    self.heightAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                } else {
                    self.heightAnchor.constraint(equalToConstant: constant).isActive = true
                }
            case .centerX(let anchor, let constant):
                self.centerXAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
                break
            case .centerY(let anchor, let constant):
                self.centerYAnchor.constraint(equalTo: anchor, constant: constant).isActive = true
            }
        }
    }
}




How to use this? Here is the sample code: 

private func initViews() {
        let guide = view.safeAreaLayoutGuide
        view.addSubview(myLabel)
        myLabel.addConstraints(.centerX(guide.centerXAnchor, 0),
                               .centerY(guide.centerYAnchor, 0))
        view.addSubview(myCustomView)
        myCustomView.addConstraints(.centerX(myLabel.centerXAnchor, 0),
                                    .bottom(myLabel.topAnchor, -20),
                                    .width(nil, 100),
                                    .height(nil, 200))
    }
Author One