如果你想要填充你的超级视图，那么我建议快速的方法:

view.translatesAutoresizingMaskIntoConstraints = false
let attributes: [NSLayoutAttribute] = [.top, .bottom, .right, .left]
NSLayoutConstraint.activate(attributes.map {
    NSLayoutConstraint(item: view, attribute: $0, relatedBy: .equal, toItem: view.superview, attribute: $0, multiplier: 1, constant: 0)
})

否则，如果你需要非相等的约束检查NSLayoutAnchor作为iOS 9。使用NSLayoutConstraint直接读取通常要容易得多:

view.translatesAutoresizingMaskIntoConstraints = false
view.topAnchor.constraint(equalTo: view.superview!.topAnchor).isActive = true
view.bottomAnchor.constraint(equalTo: view.superview!.bottomAnchor).isActive = true
view.leadingAnchor.constraint(equalTo: view.superview!.leadingAnchor, constant: 10).isActive = true
view.trailingAnchor.constraint(equalTo: view.superview!.trailingAnchor, constant: 10).isActive = true

Swift 3更新

import UIKit

class ViewController: UIViewController {

let redView: UIView = {

    let view = UIView()
    view.translatesAutoresizingMaskIntoConstraints = false
    view.backgroundColor = .red
    return view
}()

override func viewDidLoad() {
    super.viewDidLoad()

    setupViews()
    setupAutoLayout()
}

func setupViews() {

    view.backgroundColor = .white
    view.addSubview(redView)
}

func setupAutoLayout() {

    // Available from iOS 9 commonly known as Anchoring System for AutoLayout...
    redView.leftAnchor.constraint(equalTo: view.leftAnchor, constant: 20).isActive = true
    redView.rightAnchor.constraint(equalTo: view.rightAnchor, constant: -20).isActive = true

    redView.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true
    redView.heightAnchor.constraint(equalToConstant: 300).isActive = true

    // You can also modified above last two lines as follows by commenting above & uncommenting below lines...
    // redView.topAnchor.constraint(equalTo: view.topAnchor, constant: 20).isActive = true
    // redView.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
 }
}

约束的类型

 /*
// regular use
1.leftAnchor
2.rightAnchor
3.topAnchor
// intermediate use
4.widthAnchor
5.heightAnchor
6.bottomAnchor
7.centerXAnchor
8.centerYAnchor
// rare use
9.leadingAnchor
10.trailingAnchor
etc. (note: very project to project)
*/

操场上多个视图的约束。

斯威夫特 3+

  var yellowView: UIView!
    var redView: UIView!

    override func loadView() {

        // UI

        let view = UIView()
        view.backgroundColor = .white

        yellowView = UIView()
        yellowView.backgroundColor = .yellow
        view.addSubview(yellowView)

        redView = UIView()
        redView.backgroundColor = .red
        view.addSubview(redView)

        // Layout
        redView.translatesAutoresizingMaskIntoConstraints = false
        yellowView.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            yellowView.topAnchor.constraint(equalTo: view.topAnchor, constant: 20),
            yellowView.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
            yellowView.widthAnchor.constraint(equalToConstant: 80),
            yellowView.heightAnchor.constraint(equalToConstant: 80),

            redView.bottomAnchor.constraint(equalTo: view.bottomAnchor, constant: -20),
            redView.trailingAnchor.constraint(equalTo: view.trailingAnchor,constant: -20),
            redView.widthAnchor.constraint(equalToConstant: 80),
            redView.heightAnchor.constraint(equalToConstant: 80)
            ])

        self.view = view
    }

在我看来，xcode游乐场是学习加法最好的地方 通过编程方式约束。

这个错误是由autoresizingmask自动创建的约束引起的，它们的创建是因为UIView属性translatesAutoresizingMaskIntoConstraints默认为true。

考虑使用BoxView来摆脱所有手工约束创建样板，并使您的代码简洁易读。用BoxView做布局是非常简单的:

boxView.items = [
   new_view.boxed.centerX().centerY().relativeWidth(1.0).relativeHeight(1.0)
]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

下面的代码为我工作在这个场景:一个UIImageView强制景观。

    imagePreview!.isUserInteractionEnabled = true
    imagePreview!.isExclusiveTouch = true
    imagePreview!.contentMode = UIView.ContentMode.scaleAspectFit
    
    // Remove all constraints
    imagePreview!.removeAllConstraints()
    
    // Add the new constraints
    let guide = view.safeAreaLayoutGuide
    imagePreview!.translatesAutoresizingMaskIntoConstraints = false
    imagePreview!.leadingAnchor.constraint(equalTo: guide.leadingAnchor).isActive = true
    imagePreview!.trailingAnchor.constraint(equalTo: guide.trailingAnchor).isActive = true
    imagePreview!.heightAnchor.constraint(equalTo: guide.heightAnchor, multiplier: 1.0).isActive = true

哪里removeAllConstraints是一个扩展

extension UIView {
    
    func removeAllConstraints() {
        var _superview = self.superview
        
        func removeAllConstraintsFromView(view: UIView) { for c in view.constraints { view.removeConstraint(c) } }
        
        while let superview = _superview {
            for constraint in superview.constraints {
                
                if let first = constraint.firstItem as? UIView, first == self {
                    superview.removeConstraint(constraint)
                }
                
                if let second = constraint.secondItem as? UIView, second == self {
                    superview.removeConstraint(constraint)
                }
            }
            
            _superview = superview.superview
        }
        
        self.removeConstraints(self.constraints)
        self.translatesAutoresizingMaskIntoConstraints = true
    }
}