Supprimer toutes les contraintes affectant une UIView

Cette approche a fonctionné pour moi:

@interface UIView (RemoveConstraints)

- (void)removeAllConstraints;

@end


@implementation UIView (RemoveConstraints)

- (void)removeAllConstraints
{
    UIView *superview = self.superview;
    while (superview != nil) {
        for (NSLayoutConstraint *c in superview.constraints) {
            if (c.firstItem == self || c.secondItem == self) {
                [superview removeConstraint:c];
            }
        }
        superview = superview.superview;
    }

    [self removeConstraints:self.constraints];
    self.translatesAutoresizingMaskIntoConstraints = YES;
}

@end

La suite de l'exécution de votre point de vue, où il était parce qu'il crée d'un redimensionnement automatique des contraintes. Quand je ne fais pas ce que la vue disparaît. En outre, il ne fait pas que supprimer les contraintes de superview mais traversant tout le chemin jusqu'à comme il peut y avoir des contraintes dans ancêtre vues.

Swift 4 Version

extension UIView {

    public func removeAllConstraints() {
        var _superview = self.superview

        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
    }
}

Vous pouvez supprimer toutes les contraintes dans une vue en faisant ceci:

[_cell.contentView removeConstraints:_cell.contentView.constraints];

EDIT: Pour supprimer les contraintes de tous les sous-vues, utilisez l'extension suivante dans Swift:

extension UIView {
    func clearConstraints() {
        for subview in self.subviews {
            subview.clearConstraints()
        }
        self.removeConstraints(self.constraints)
    }
}

Il y a deux façons de le réaliser selon Apple Developer Documentation

1. NSLayoutConstraint.deactivateConstraints

C'est une méthode pratique qui fournit un moyen simple de désactiver un
l'ensemble des contraintes à un appel. L'effet de cette méthode est l'
de même que le réglage de l'est actif de propriété de chaque contrainte à false.
Généralement, l'utilisation de cette méthode est plus efficace que la désactivation de chaque
contrainte individuellement.

//Declaration
class func deactivate(_ constraints: [NSLayoutConstraint])

//Usage
NSLayoutConstraint.deactivate(yourView.constraints)

2. UIView.removeConstraints (Déconseillé pour >= iOS 8.0)

Le développement pour iOS 8.0 ou version ultérieure, utilisez la NSLayoutConstraint
la classe deactivateConstraints: méthode au lieu d'appeler la
removeConstraints: méthode directement. Le deactivateConstraints: méthode
supprime automatiquement les contraintes de la bonne vue.

//Declaration
func removeConstraints(_ constraints: [NSLayoutConstraint])`

//Usage
yourView.removeConstraints(yourView.constraints)

Conseils

À l'aide de Storyboards ou XIBs peut être une douleur à la configuration de contraintes comme mentionné sur votre scénario, vous devez créer IBOutlets pour chacun de ceux que vous souhaitez supprimer. Même si, la plupart du temps Interface Builder crée plus de problèmes qu'elle n'en résout.

Par conséquent, lorsque, ayant très dynamique, le contenu et les différents états de la vue, je dirais:

1. De la création de votre point de vue par programme
2. La disposition et l'utilisation de NSLayoutAnchor
3. Ajouter chaque contrainte qui pourraient être supprimés plus tard à un tableau
4. Les effacer à chaque fois avant d'appliquer le nouvel état

Simple Code

private var customConstraints = [NSLayoutConstraint]()

private func activate(constraints: [NSLayoutConstraint]) {
    customConstraints.append(contentsOf: constraints)
    customConstraints.forEach { $0.isActive = true }
}

private func clearConstraints() {
    customConstraints.forEach { $0.isActive = false }
    customConstraints.removeAll()
}

private func updateViewState() {
    clearConstraints()

    let constraints = [
        view.leadingAnchor.constraint(equalTo: parentView.leadingAnchor),
        view.trailingAnchor.constraint(equalTo: parentView.trailingAnchor),
        view.topAnchor.constraint(equalTo: parentView.topAnchor),
        view.bottomAnchor.constraint(equalTo: parentView.bottomAnchor)
    ]

    activate(constraints: constraints)

    view.layoutIfNeeded()
}

Références

1. NSLayoutConstraint
2. UIView

Basées sur des réponses précédentes (swift 4)

Vous pouvez utiliser immediateConstraints lorsque vous ne voulez pas de ramper à l'ensemble de hiérarchies.

extension UIView {
/**
 * Deactivates immediate constraints that target this view (self + superview)
 */
func deactivateImmediateConstraints(){
    NSLayoutConstraint.deactivate(self.immediateConstraints)
}
/**
 * Deactivates all constrains that target this view
 */
func deactiveAllConstraints(){
    NSLayoutConstraint.deactivate(self.allConstraints)
}
/**
 * Gets self.constraints + superview?.constraints for this particular view
 */
var immediateConstraints:[NSLayoutConstraint]{
    let constraints = self.superview?.constraints.filter{
        $0.firstItem as? UIView === self || $0.secondItem as? UIView === self
        } ?? []
    return self.constraints + constraints
}
/**
 * Crawls up superview hierarchy and gets all constraints that affect this view
 */
var allConstraints:[NSLayoutConstraint] {
    var view: UIView? = self
    var constraints:[NSLayoutConstraint] = []
    while let currentView = view {
        constraints += currentView.constraints.filter {
            return $0.firstItem as? UIView === self || $0.secondItem as? UIView === self
        }
        view = view?.superview
    }
    return constraints
}
}

Une solution Swift:

extension UIView {
  func removeAllConstraints() {
    var view: UIView? = self
    while let currentView = view {
      currentView.removeConstraints(currentView.constraints.filter {
        return $0.firstItem as? UIView == self || $0.secondItem as? UIView == self
      })
      view = view?.superview
    }
  }
}

Il est important de passer par tous les parents, car les contraintes entre les deux éléments sont dit, par l'ancêtre commun, donc il suffit de compensation de la superview comme détaillé dans cette réponse n'est pas assez bon, et vous pourriez avoir la mauvaise surprise plus tard.

Vous pouvez utiliser quelque chose comme ceci:

[viewA.superview.constraints enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
    NSLayoutConstraint *constraint = (NSLayoutConstraint *)obj;
    if (constraint.firstItem == viewA || constraint.secondItem == viewA) {
        [viewA.superview removeConstraint:constraint];
    }
}];

[viewA removeConstraints:viewA.constraints];

En gros, c'est énumère plus de toutes les contraintes sur le superview de viewA et supprime toutes les contraintes qui sont liées à viewA.

Ensuite, la deuxième partie supprime les contraintes de viewA à l'aide de la matrice de viewA contraintes.

Le plus simple et efficace est de supprimer le point de vue de superView et re ajouter en tant que sous-vue de nouveau.
ceci permet à tous les sous-vue les contraintes sont supprimés automatiquement.