经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » iOS » 查看文章
使用SnapKit遇到的问题
来源：cnblogs　　作者：小雨37　　时间：2018/9/26 19:09:58　　对本文有异议

最近在使用snapkit过程中遇到一个问题，在github上搜索之后发现另外一个有趣的问题 问题链接

  1. frameImageContainer.snp.makeConstraints({ (make) in 
  2.     make.width.equalTo(295).multipliedBy(0.2) 
  3.     make.height.equalTo(355).multipliedBy(0.2) 
  4.     make.top.equalToSuperview().offset(self.view.frame.height/8) 
  5.     make.centerX.equalToSuperview(); 
  6. })

看起来很理所当然的，明显不可以这样写，但是具体是什么原因呢，明明没有报任何错误和警告，但是.multipliedBy()方法却没有效果，那我们来看一下snapkit源码。

1.首先点进equalTo()方法，代码是这样的：

  1. @discardableResult
  2.     public func equalTo(_ other: ConstraintRelatableTarget, _ file: String = #file, _ line: UInt = #line) -> ConstraintMakerEditable {
  3.         return self.relatedTo(other, relation: .equal, file: file, line: line)
  4.     }

再点进relatedTo()方法：

  1. internal func relatedTo(_ other: ConstraintRelatableTarget, relation: ConstraintRelation, file: String, line: UInt) -> ConstraintMakerEditable {
  2.         let related: ConstraintItem
  3.         let constant: ConstraintConstantTarget
  4.         
  5.         if let other = other as? ConstraintItem {
  6.             guard other.attributes == ConstraintAttributes.none ||
  7.                   other.attributes.layoutAttributes.count <= 1 ||
  8.                   other.attributes.layoutAttributes == self.description.attributes.layoutAttributes ||
  9.                   other.attributes == .edges && self.description.attributes == .margins ||
  10.                   other.attributes == .margins && self.description.attributes == .edges else {
  11.                 fatalError("Cannot constraint to multiple non identical attributes. (\(file), \(line))");
  12.             }
  13.             
  14.             related = other
  15.             constant = 0.0
  16.         } else if let other = other as? ConstraintView {
  17.             related = ConstraintItem(target: other, attributes: ConstraintAttributes.none)
  18.             constant = 0.0
  19.         } else if let other = other as? ConstraintConstantTarget {
  20.             related = ConstraintItem(target: nil, attributes: ConstraintAttributes.none)
  21.             constant = other
  22.         } else if #available(iOS 9.0, OSX 10.11, *), let other = other as? ConstraintLayoutGuide {
  23.             related = ConstraintItem(target: other, attributes: ConstraintAttributes.none)
  24.             constant = 0.0
  25.         } else {
  26.             fatalError("Invalid constraint. (\(file), \(line))")
  27.         }
  28.         
  29.         let editable = ConstraintMakerEditable(self.description)
  30.         editable.description.sourceLocation = (file, line)
  31.         editable.description.relation = relation
  32.         editable.description.related = related
  33.         editable.description.constant = constant
  34.         return editable
  35.     }

可以看到上面红色部分，此时other可以转换为ConstraintConstantTarget类型，设置related的target为nil，attributes为none，constant设置为other，最后将这些变量赋值给description属性保存。

2.multipliedBy()方法：

  1. @discardableResult
  2.     public func multipliedBy(_ amount: ConstraintMultiplierTarget) -> ConstraintMakerEditable {
  3.         self.description.multiplier = amount
  4.         return self
  5.     }

可以看到，multipliedBy方法中只是简单的赋值，将amout值复制到description中保存。

3.再来看一下makeConstraints()方法：

  1. internal static func makeConstraints(item: LayoutConstraintItem, closure: (_ make: ConstraintMaker) -> Void) {
  2.         let maker = ConstraintMaker(item: item)
  3.         closure(maker)
  4.         var constraints: [Constraint] = []
  5.         for description in maker.descriptions {
  6.             guard let constraint = description.constraint else {
  7.                 continue
  8.             }
  9.             constraints.append(constraint)
  10.         }
  11.         for constraint in constraints {
  12.             constraint.activateIfNeeded(updatingExisting: false)
  13.         }
  14.     }

首先将要添加约束的对象封装成ConstraintMaker对象，再把它作为参数调用closure，开始添加约束。closure中的每条语句会先被解析ConstraintDescription对象，添加到maker的descriptions属性中。 在第一个for循环中可以看到，每次循环从descriptions中取出一条description，判断是否改description是否有constraint属性；

constraint属性使用的懒加载，值为：

  1. internal lazy var constraint: Constraint? = {
  2.         guard let relation = self.relation,
  3.               let related = self.related,
  4.               let sourceLocation = self.sourceLocation else {
  5.             return nil
  6.         }
  7.         let from = ConstraintItem(target: self.item, attributes: self.attributes)
  8.         
  9.         return Constraint(
  10.             from: from,
  11.             to: related,
  12.             relation: relation,
  13.             sourceLocation: sourceLocation,
  14.             label: self.label,
  15.             multiplier: self.multiplier,
  16.             constant: self.constant,
  17.             priority: self.priority
  18.         )
  19.     }()

先判断relation，related，sourceLocation的值是否为nil，若为nil则返回nil，否则就根据description属性创建一个Constraint对象并返回。

Constraint的构造方法：

  1.     internal init(from: ConstraintItem,
  2.                   to: ConstraintItem,
  3.                   relation: ConstraintRelation,
  4.                   sourceLocation: (String, UInt),
  5.                   label: String?,
  6.                   multiplier: ConstraintMultiplierTarget,
  7.                   constant: ConstraintConstantTarget,
  8.                   priority: ConstraintPriorityTarget) {
  9.         self.from = from
  10.         self.to = to
  11.         self.relation = relation
  12.         self.sourceLocation = sourceLocation
  13.         self.label = label
  14.         self.multiplier = multiplier
  15.         self.constant = constant
  16.         self.priority = priority
  17.         self.layoutConstraints = []
  19.         // get attributes
  20.         let layoutFromAttributes = self.from.attributes.layoutAttributes
  21.         let layoutToAttributes = self.to.attributes.layoutAttributes
  23.         // get layout from
  24.         let layoutFrom = self.from.layoutConstraintItem!
  25.  
  26.         // get relation
  27.         let layoutRelation = self.relation.layoutRelation
  29.         for layoutFromAttribute in layoutFromAttributes {
  30.             // get layout to attribute
  31.             let layoutToAttribute: LayoutAttribute
  32.             #if os(iOS) || os(tvOS)
  33.                 if layoutToAttributes.count > 0 {
  34.                     if self.from.attributes == .edges && self.to.attributes == .margins {
  35.                         switch layoutFromAttribute {
  36.                         case .left:
  37.                             layoutToAttribute = .leftMargin
  38.                         case .right:
  39.                             layoutToAttribute = .rightMargin
  40.                         case .top:
  41.                             layoutToAttribute = .topMargin
  42.                         case .bottom:
  43.                             layoutToAttribute = .bottomMargin
  44.                         default:
  45.                             fatalError()
  46.                         }
  47.                     } else if self.from.attributes == .margins && self.to.attributes == .edges {
  48.                         switch layoutFromAttribute {
  49.                         case .leftMargin:
  50.                             layoutToAttribute = .left
  51.                         case .rightMargin:
  52.                             layoutToAttribute = .right
  53.                         case .topMargin:
  54.                             layoutToAttribute = .top
  55.                         case .bottomMargin:
  56.                             layoutToAttribute = .bottom
  57.                         default:
  58.                             fatalError()
  59.                         }
  60.                     } else if self.from.attributes == self.to.attributes {
  61.                         layoutToAttribute = layoutFromAttribute
  62.                     } else {
  63.                         layoutToAttribute = layoutToAttributes[0]
  64.                     }
  65.                 } else {
  66.                     if self.to.target == nil && (layoutFromAttribute == .centerX || layoutFromAttribute == .centerY) {
  67.                         layoutToAttribute = layoutFromAttribute == .centerX ? .left : .top
  68.                     } else {
  69.                         layoutToAttribute = layoutFromAttribute
  70.                     }
  71.                 }
  72.             #else
  73.                 if self.from.attributes == self.to.attributes {
  74.                     layoutToAttribute = layoutFromAttribute
  75.                 } else if layoutToAttributes.count > 0 {
  76.                     layoutToAttribute = layoutToAttributes[0]
  77.                 } else {
  78.                     layoutToAttribute = layoutFromAttribute
  79.                 }
  80.             #endif
  81.  
  82.             // get layout constant
  83.             let layoutConstant: CGFloat = self.constant.constraintConstantTargetValueFor(layoutAttribute: layoutToAttribute)
  85.             // get layout to
  86.             var layoutTo: AnyObject? = self.to.target
  88.             // use superview if possible
  89.             if layoutTo == nil && layoutToAttribute != .width && layoutToAttribute != .height {
  90.                 layoutTo = layoutFrom.superview
  91.             }
  93.             // create layout constraint
  94.             let layoutConstraint = LayoutConstraint(
  95.                 item: layoutFrom,
  96.                 attribute: layoutFromAttribute,
  97.                 relatedBy: layoutRelation,
  98.                 toItem: layoutTo,
  99.                 attribute: layoutToAttribute,
  100.                 multiplier: self.multiplier.constraintMultiplierTargetValue,
  101.                 constant: layoutConstant
  102.             )
  104.             // set label
  105.             layoutConstraint.label = self.label
  107.             // set priority
  108.             layoutConstraint.priority = LayoutPriority(rawValue: self.priority.constraintPriorityTargetValue)
  110.             // set constraint
  111.             layoutConstraint.constraint = self
  113.             // append
  114.             self.layoutConstraints.append(layoutConstraint)
  115.         }
  116.     }

重点看红色部分，遍历layoutAttributes，并根据layoutAttribute的值生成一个LayoutConstraint对象添加到layoutConstraints数组中。LayoutConstraint继承自系统类NSLayoutConstraint。

4.最后再看3中的第二个for循环，使用activeIfNeeded()方法激活约束：

  1.  internal func activateIfNeeded(updatingExisting: Bool = false) {
  2.         guard let item = self.from.layoutConstraintItem else {
  3.             print("WARNING: SnapKit failed to get from item from constraint. Activate will be a no-op.")
  4.             return
  5.         }
  6.         let layoutConstraints = self.layoutConstraints
  8.         if updatingExisting {
  9.             var existingLayoutConstraints: [LayoutConstraint] = []
  10.             for constraint in item.constraints {
  11.                 existingLayoutConstraints += constraint.layoutConstraints
  12.             }
  14.             for layoutConstraint in layoutConstraints {
  15.                 let existingLayoutConstraint = existingLayoutConstraints.first { $0 == layoutConstraint }
  16.                 guard let updateLayoutConstraint = existingLayoutConstraint else {
  17.                     fatalError("Updated constraint could not find existing matching constraint to update: \(layoutConstraint)")
  18.                 }
  20.                 let updateLayoutAttribute = (updateLayoutConstraint.secondAttribute == .notAnAttribute) ? updateLayoutConstraint.firstAttribute : updateLayoutConstraint.secondAttribute
  21.                 updateLayoutConstraint.constant = self.constant.constraintConstantTargetValueFor(layoutAttribute: updateLayoutAttribute)
  22.             }
  23.         } else {
  24.             NSLayoutConstraint.activate(layoutConstraints)
  25.             item.add(constraints: [self])
  26.         }
  27.     }

当updatingExisting为false时，进入else语句，使用的系统类NSLayoutConstraint的方法激活约束：

  1. /* Convenience method that activates each constraint in the contained array, in the same manner as setting active=YES. This is often more efficient than activating each constraint individually. */
  2.     @available(iOS 8.0, *)
  3.     open class func activate(_ constraints: [NSLayoutConstraint])

并将设置过的约束添加到item的constraintSet这个私有属性中：

  1. internal var constraints: [Constraint] {
  2.         return self.constraintsSet.allObjects as! [Constraint]
  3.     }
  4.     
  5.     internal func add(constraints: [Constraint]) {
  6.         let constraintsSet = self.constraintsSet
  7.         for constraint in constraints {
  8.             constraintsSet.add(constraint)
  9.         }
  10.     }
  11.     
  12.     internal func remove(constraints: [Constraint]) {
  13.         let constraintsSet = self.constraintsSet
  14.         for constraint in constraints {
  15.             constraintsSet.remove(constraint)
  16.         }
  17.     }
  18.     
  19.     private var constraintsSet: NSMutableSet {
  20.         let constraintsSet: NSMutableSet
  21.         
  22.         if let existing = objc_getAssociatedObject(self, &constraintsKey) as? NSMutableSet {
  23.             constraintsSet = existing
  24.         } else {
  25.             constraintsSet = NSMutableSet()
  26.             objc_setAssociatedObject(self, &constraintsKey, constraintsSet, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
  27.         }
  28.         return constraintsSet
  29.         
  30.     }

5.通过这个过程不难发现，使用make.width.equalTo(295).multipliedBy(0.2) 这种方式不能得到想要的结果。在3中Constraint的构造方法的红色部分，其实构造LayoutConstraint对象时调用的NSLayoutConstraint的便利构造器方法：

  1.     /* Create constraints explicitly.  Constraints are of the form "view1.attr1 = view2.attr2 * multiplier + constant" 
  2.      If your equation does not have a second view and attribute, use nil and NSLayoutAttributeNotAnAttribute.
  3.      */
  4.     public convenience init(item view1: Any, attribute attr1: NSLayoutConstraint.Attribute, relatedBy relation: NSLayoutConstraint.Relation, toItem view2: Any?, attribute attr2: NSLayoutConstraint.Attribute, multiplier: CGFloat, constant c: CGFloat)

注意上面注释 view1.attr1 = view2.attr2 * multiplier + constant 如果只设置为数字，则相当于view2为nil，所以view1的属性值只能等于constant的值，不会乘以multiplier。

6.终于写完了，哈哈。  demo工程地址，对应的方法已打断点，可以跟着代码一步步调试，有助于理解。

 

 

疑问：在4中最后一部分红色字体的内容，私有属性constraintsSet为啥不直接使用，还要使用runtime给当前对象绑定一个同名的属性，每次使用时获取绑定的属性的值，不懂，希望知道的同学不吝赐教。

 

 

 

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

iOS热门文章

  • snapkit更新约束崩溃的问题
  • iOS 14 UDP收不到广播处理
  • iOS开发用如何用类&quot;SKStoreProductViewController&quot;跳转AppStore点赞评分？
  • Charles抓包iPhone注意点以及SSL Proxying enabled for this host
  • 笔记：long、longlong、int、float、NSString相互转换
  • ios开发UI篇—UITextfield
  • 自定义相机碰到的问题，比如常见的拍照录制视频方向，镜像左右颠倒等问题
  • C 和 Object-C中的 #ifdef #ifndef
  • 使用Hbuilder将自己app发布到App Store（一）
  • iOS开发 - 超级签名实现之描述文件

    • iOS推荐文章

  • iOS开发基础135-Core Data
  • uniapp-vue3-oadmin手机后台实例|vite5.x+uniapp多端仿ios管理系统
  • 苹果支付有哪些坑，为什么苹果支付比支付宝和微信容易丢单？
  • 带你走进灵动岛
  • vue3+ts Axios封装—重复请求拦截
  • axios详解以及完整封装方法
  • 关于 axios 是什么？以及怎么用？
  • iOS气泡提示工具BubblePopup的使用
  • 一篇文章带你详细了解axios的封装 - 公众号-web前端进阶
  • [MAUI]模仿iOS多任务切换卡片滑动的交互实现

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号