尝试这个优雅的UIView扩展约束。你可以简单地做约束:

 - firstView.coverWholeSuperview()
 - firstView.constraints(size: CGSize(width: 44, height: 44), centerX: view.centerXAnchor, centerY: view.centerXAnchor)
 - firstView.constraints(top: view.topAnchor, 
                         leading: secondView.leadingAnchor, 
                         bottom: view.bottomAnchor, 
                         trailing: secondView.trailingAnchor, 
                         padding: UIEdgeInsets(top: 12, left: 12, bottom: 12, right: 12))

这里是扩展，只需复制到您的项目。

extension UIView {
    /// Attaches all sides of the receiver to its parent view
    func coverWholeSuperview(margin: CGFloat = 0.0) {
        let view = superview
        layoutAttachTop(to: view, margin: margin)
        layoutAttachBottom(to: view, margin: margin)
        layoutAttachLeading(to: view, margin: margin)
        layoutAttachTrailing(to: view, margin: margin)

    }

    /// Attaches the top of the current view to the given view's top if it's a superview of the current view
    /// or to it's bottom if it's not (assuming this is then a sibling view).
    @discardableResult
    func layoutAttachTop(to: UIView? = nil, margin: CGFloat = 0.0) -> NSLayoutConstraint {

        let view: UIView? = to ?? superview
        let isSuperview = view == superview
        let constraint = NSLayoutConstraint(item: self, attribute: .top, relatedBy: .equal,
                                            toItem: view, attribute: isSuperview ? .top : .bottom, multiplier: 1.0,
                                            constant: margin)
        superview?.addConstraint(constraint)

        return constraint
    }

    /// Attaches the bottom of the current view to the given view
    @discardableResult
    func layoutAttachBottom(to: UIView? = nil, margin: CGFloat = 0.0, priority: UILayoutPriority? = nil) -> NSLayoutConstraint {

        let view: UIView? = to ?? superview
        let isSuperview = (view == superview) || false
        let constraint = NSLayoutConstraint(item: self, attribute: .bottom, relatedBy: .equal,
                                            toItem: view, attribute: isSuperview ? .bottom : .top, multiplier: 1.0,
                                            constant: -margin)
        if let priority = priority {
            constraint.priority = priority
        }
        superview?.addConstraint(constraint)

        return constraint
    }

    /// Attaches the leading edge of the current view to the given view
    @discardableResult
    func layoutAttachLeading(to: UIView? = nil, margin: CGFloat = 0.0) -> NSLayoutConstraint {

        let view: UIView? = to ?? superview
        let isSuperview = (view == superview) || false
        let constraint = NSLayoutConstraint(item: self, attribute: .leading, relatedBy: .equal,
                                            toItem: view, attribute: isSuperview ? .leading : .trailing, multiplier: 1.0,
                                            constant: margin)
        superview?.addConstraint(constraint)

        return constraint
    }

    /// Attaches the trailing edge of the current view to the given view
    @discardableResult
    func layoutAttachTrailing(to: UIView? = nil, margin: CGFloat = 0.0, priority: UILayoutPriority? = nil) -> NSLayoutConstraint {

        let view: UIView? = to ?? superview
        let isSuperview = (view == superview) || false
        let constraint = NSLayoutConstraint(item: self, attribute: .trailing, relatedBy: .equal,
                                            toItem: view, attribute: isSuperview ? .trailing : .leading, multiplier: 1.0,
                                            constant: -margin)
        if let priority = priority {
            constraint.priority = priority
        }
        superview?.addConstraint(constraint)

        return constraint
    }

    // For anchoring View
    struct AnchoredConstraints {
        var top, leading, bottom, trailing, width, height, centerX, centerY: NSLayoutConstraint?
    }

    @discardableResult
    func constraints(top: NSLayoutYAxisAnchor? = nil, leading: NSLayoutXAxisAnchor? = nil, bottom: NSLayoutYAxisAnchor? = nil,
                trailing: NSLayoutXAxisAnchor? = nil, padding: UIEdgeInsets = .zero, size: CGSize = .zero,
                centerX: NSLayoutXAxisAnchor? = nil, centerY: NSLayoutYAxisAnchor? = nil,
                centerXOffset: CGFloat = 0, centerYOffset: CGFloat = 0) -> AnchoredConstraints {

        translatesAutoresizingMaskIntoConstraints = false
        var anchoredConstraints = AnchoredConstraints()

        if let top = top {
            anchoredConstraints.top = topAnchor.constraint(equalTo: top, constant: padding.top)
        }

        if let leading = leading {
            anchoredConstraints.leading = leadingAnchor.constraint(equalTo: leading, constant: padding.left)
        }

        if let bottom = bottom {
            anchoredConstraints.bottom = bottomAnchor.constraint(equalTo: bottom, constant: -padding.bottom)
        }

        if let trailing = trailing {
            anchoredConstraints.trailing = trailingAnchor.constraint(equalTo: trailing, constant: -padding.right)
        }

        if size.width != 0 {
            anchoredConstraints.width = widthAnchor.constraint(equalToConstant: size.width)
        }

        if size.height != 0 {
            anchoredConstraints.height = heightAnchor.constraint(equalToConstant: size.height)
        }

        if let centerX = centerX {
            anchoredConstraints.centerX = centerXAnchor.constraint(equalTo: centerX, constant: centerXOffset)
        }

        if let centerY = centerY {
            anchoredConstraints.centerY = centerYAnchor.constraint(equalTo: centerY, constant: centerYOffset)
        }

        [anchoredConstraints.top, anchoredConstraints.leading, anchoredConstraints.bottom,
         anchoredConstraints.trailing, anchoredConstraints.width,
         anchoredConstraints.height, anchoredConstraints.centerX,
         anchoredConstraints.centerY].forEach { $0?.isActive = true }

        return anchoredConstraints
    }
}

想在Imanou Petit的回答中添加一些理论概念，这样人们就可以了解自动布局是如何工作的。

要理解自动布局，请将您的视图视为橡胶的对象，最初是收缩的。

要在屏幕上放置一个对象，我们需要4件强制性的事情:

物体的X坐标(水平位置)。 物体的Y坐标(垂直位置) 对象的宽度 物体的高度。

X坐标:有多种方式给视图X坐标。

如前向约束，后向约束，水平中心 等。

2 Y坐标:给视图Y坐标有多种方式:

如顶部约束，底部约束，垂直中心等。

有两种方法来限制一个视图的宽度:

a.添加固定宽度约束(将此约束视为固定宽度的铁棒，并与橡胶对象水平挂钩，使橡胶对象不会收缩或膨胀)

b.不要添加任何宽度约束，而是在视图的前端和前端添加x坐标约束，这两个约束将通过从前端和前端拉动橡胶对象来扩展/收缩。

对象的高度:类似于宽度，有两种方法来限制视图的高度:

a.添加固定高度约束(将此约束视为固定高度的铁棒，并与橡胶物体垂直挂钩，使橡胶物体不会收缩或膨胀)

b.不要添加任何高度约束，但在视图的顶部和底部两端添加x坐标约束，这两个约束将从两端、顶部和底部拉伸/推动橡胶对象。

基本上有3个步骤

fileprivate func setupName() { 

    lblName.text = "Hello world"

    // Step 1
    lblName.translatesAutoresizingMaskIntoConstraints = false

    //Step 2
    self.view.addSubview(lblName)

    //Step 3
    NSLayoutConstraint.activate([
        lblName.centerXAnchor.constraint(equalTo: self.view.centerXAnchor),
        lblName.centerYAnchor.constraint(equalTo: self.view.centerYAnchor)
    ])
}

这将把标签“hello world”置于屏幕中心。

请参考链接自动布局约束编程

您可以使用Snapkit以编程方式设置约束。

class ViewController: UIViewController {
    
    let rectView: UIView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupViews()
    }
    
    private func setupViews() {
        rectView.backgroundColor = .red
        view.addSubview(rectView)

        rectView.snp.makeConstraints {
          $0.center.equalToSuperview()
        }
    }
}

我们可以很容易地在swift 5.1中做到这一点

设置1

子视图对齐到视图中心 子视图宽度高度设置使用浮动 view.addSubview (myView1) myView1。translatesAutoresizingMaskIntoConstraints = false NSLayoutConstraint.activate ([ myView1.centerXAnchor。约束(等于:view.centerXAnchor), myView1.centerYAnchor。约束(等于:view.centerYAnchor), myView1.widthAnchor。约束(equalToConstant: 100), myView1.heightAnchor。约束(equalToConstant: 100), ])

设置2

subview align to view leading and top anchor subview width set using view width height view.addSubview(myView2) myView2.translatesAutoresizingMaskIntoConstraints = false NSLayoutConstraint.activate([ myView2.leadingAnchor.constraint(equalTo: view.leadingAnchor,constant: 16), myView2.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor,constant: 16), myView2.widthAnchor.constraint(equalTo: view.widthAnchor, multiplier: 0.3), myView2.heightAnchor.constraint(equalTo: view.heightAnchor, multiplier: 0.3) ])

您正在向self添加所有已定义的约束。视图的宽度和高度限制应该添加到你的newView。

另外，据我所知，你想要设置恒定的宽度和高度100:100。 在这种情况下，您应该将代码更改为:

var constW = NSLayoutConstraint(item: newView, 
    attribute: .Width, 
    relatedBy: .Equal, 
    toItem: nil, 
    attribute: .NotAnAttribute, 
    multiplier: 1, 
    constant: 100)
newView.addConstraint(constW)

var constH = NSLayoutConstraint(item: newView, 
    attribute: .Height, 
    relatedBy: .Equal, 
    toItem: nil, 
    attribute: .NotAnAttribute, 
    multiplier: 1, 
    constant: 100)
newView.addConstraint(constH)