如何通过代码实现基于父视图宽高的Auto Layout条件约束？

这是个很常见的动态布局需求，核心就是根据父视图的宽高关系，切换子视图的约束规则。下面我用两种主流iOS开发语言给出完整的实现方案，采用约束激活/失活的方式，逻辑直观，也容易维护：

Swift 实现方案 #

我们可以自定义一个父视图类，在内部管理两组约束，每次布局时根据父视图的宽高比激活对应的约束组：

import UIKit

class DynamicParentView: UIView {
    // 子视图，这里可以换成你实际需要的视图类型
    private let childView = UIView()
    
    // 存储两组约束：一组对应宽≥高的情况，一组对应宽<高的情况
    private var widthPriorityConstraints: [NSLayoutConstraint] = []
    private var heightPriorityConstraints: [NSLayoutConstraint] = []
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupUI()
    }
    
    required init?(coder: NSCoder) {
        super.init(coder: coder)
        setupUI()
    }
    
    private func setupUI() {
        // 配置子视图样式（方便调试查看效果，可根据需求修改）
        childView.backgroundColor = .systemBlue
        childView.translatesAutoresizingMaskIntoConstraints = false
        addSubview(childView)
        
        // 固定居中约束：不管哪种布局情况，子视图都居中显示
        let centerX = childView.centerXAnchor.constraint(equalTo: centerXAnchor)
        let centerY = childView.centerYAnchor.constraint(equalTo: centerYAnchor)
        NSLayoutConstraint.activate([centerX, centerY])
        
        // 第一组约束：父视图宽≥高时生效，子视图宽为父视图75%，高固定15pt
        let childWidth = childView.widthAnchor.constraint(equalTo: widthAnchor, multiplier: 0.75)
        let childHeight = childView.heightAnchor.constraint(equalToConstant: 15)
        widthPriorityConstraints = [childWidth, childHeight]
        
        // 第二组约束：父视图宽<高时生效，子视图宽固定15pt，高为父视图75%
        let childWidthAlt = childView.widthAnchor.constraint(equalToConstant: 15)
        let childHeightAlt = childView.heightAnchor.constraint(equalTo: heightAnchor, multiplier: 0.75)
        heightPriorityConstraints = [childWidthAlt, childHeightAlt]
        
        // 初始化时就判断一次，激活正确的约束组
        updateActiveConstraints()
    }
    
    override func layoutSubviews() {
        super.layoutSubviews()
        // 每次父视图大小变化（比如旋转屏幕、父视图被调整）时，更新约束
        updateActiveConstraints()
    }
    
    private func updateActiveConstraints() {
        let isWidthDominant = bounds.width >= bounds.height
        
        // 先失活不需要的约束组，再激活目标约束组（避免约束冲突）
        NSLayoutConstraint.deactivate(isWidthDominant ? heightPriorityConstraints : widthPriorityConstraints)
        NSLayoutConstraint.activate(isWidthDominant ? widthPriorityConstraints : heightPriorityConstraints)
    }
}

Objective-C 实现方案 #

如果你的项目用的是Objective-C，逻辑和Swift完全一致，只是语法不同：

#import <UIKit/UIKit.h>

@interface DynamicParentView : UIView
@property (nonatomic, strong) UIView *childView;
@property (nonatomic, strong) NSArray<NSLayoutConstraint *> *widthPriorityConstraints;
@property (nonatomic, strong) NSArray<NSLayoutConstraint *> *heightPriorityConstraints;
@end

@implementation DynamicParentView

- (instancetype)initWithFrame:(CGRect)frame {
    self = [super initWithFrame:frame];
    if (self) {
        [self setupUI];
    }
    return self;
}

- (instancetype)initWithCoder:(NSCoder *)coder {
    self = [super initWithCoder:coder];
    if (self) {
        [self setupUI];
    }
    return self;
}

- (void)setupUI {
    self.childView = [[UIView alloc] init];
    self.childView.backgroundColor = [UIColor systemBlueColor];
    self.childView.translatesAutoresizingMaskIntoConstraints = NO;
    [self addSubview:self.childView];
    
    // 固定居中约束
    NSLayoutConstraint *centerX = [self.childView.centerXAnchor constraintEqualToAnchor:self.centerXAnchor];
    NSLayoutConstraint *centerY = [self.childView.centerYAnchor constraintEqualToAnchor:self.centerYAnchor];
    [NSLayoutConstraint activateConstraints:@[centerX, centerY]];
    
    // 宽主导约束组
    NSLayoutConstraint *childWidth = [self.childView.widthAnchor constraintEqualToAnchor:self.widthAnchor multiplier:0.75];
    NSLayoutConstraint *childHeight = [self.childView.heightAnchor constraintEqualToConstant:15];
    self.widthPriorityConstraints = @[childWidth, childHeight];
    
    // 高主导约束组
    NSLayoutConstraint *childWidthAlt = [self.childView.widthAnchor constraintEqualToConstant:15];
    NSLayoutConstraint *childHeightAlt = [self.childView.heightAnchor constraintEqualToAnchor:self.heightAnchor multiplier:0.75];
    self.heightPriorityConstraints = @[childWidthAlt, childHeightAlt];
    
    // 初始化激活正确约束组
    [self updateActiveConstraints];
}

- (void)layoutSubviews {
    [super layoutSubviews];
    [self updateActiveConstraints];
}

- (void)updateActiveConstraints {
    BOOL isWidthDominant = CGRectGetWidth(self.bounds) >= CGRectGetHeight(self.bounds);
    
    [NSLayoutConstraint deactivateConstraints:isWidthDominant ? self.heightPriorityConstraints : self.widthPriorityConstraints];
    [NSLayoutConstraint activateConstraints:isWidthDominant ? self.widthPriorityConstraints : self.heightPriorityConstraints];
}

@end

关键注意事项 #

• 必须关闭自动转换约束：一定要给子视图设置translatesAutoresizingMaskIntoConstraints = false，否则系统会自动生成约束，和我们手动添加的约束冲突，导致布局异常。
• 布局时机：我们在layoutSubviews中更新约束，是因为这个方法会在父视图大小发生任何变化时被调用，能保证约束始终和父视图的当前状态匹配。如果是在ViewController中使用，也可以在viewWillLayoutSubviews方法中调用更新约束的逻辑。
• 替代方案（优先级方式）：你也可以通过设置约束优先级来实现，比如给两组约束设置不同的优先级，动态调整优先级高低。但这种方式不如直接激活/失活直观，容易出现约束冲突警告，所以更推荐上面的方案。

内容的提问来源于stack exchange，提问作者Deepak Sharma