1、Views

作者: smalldu | 来源:发表于2016-05-12 11:50 被阅读400次

概述

UIView或者它的子类知道怎样将自己绘制在一个矩形区域中。我们app所有可视的的界面来自于视图。创建和配置一个view非常的简单。比如你可以在Xib编辑器中拖一个UIButton或者其他view到一个View上，你也可以使用代码来操作所有的绘制。你可以控制view显示和消失、移动、改变大小或者在它上面显示其他view、给它做动画等。

UIView是UIResponder的子类，所以也能相应事件（和用户交互，这也是UIView和CALayer本质区别）。

视图层次是视图组织的主要模式。一个view可以拥有很多子视图，一个子视图只能拥有一个直接父视图，这样就形成一个视图的层级树。如果一个视图从界面上remove，它所有子视图也会被remove掉。如果一个view隐藏（hidden）它所有子视图hidden。其他变化同样也会共享给他的子视图。

我们应该选择xib还是code创建视图，两者没有好坏这分，这取决于你的需求、习惯和你的app的整体架构。

Window

app的window是视图层级最顶部的view。它是一个UIWindow对象（或者UIWindow的子类），UIWindow是UIView的子类。我们app拥有一个主window，在app运行期间创建，而且不会被销毁或者替换。其他所有可见的视图都是它的子视图。

如果你的app可以在外部屏幕展示视图，你将需要创建一个额外的UIWindow，但是在本章节，我们假设只有一个屏幕，只有一个window

初始化一个window必须充满设备的屏幕，确保设置window的frame等于屏幕的bounds，如果你使用的是main.storyboard,在app加载的时候会自动帮你创建，AppDelegate顶部的那个注解@UIApplicationMain 。如果你需要自己创建可以通过以下方式:

// 创建window iOS 9 之前
let w = UIWindow(frame: UIScreen.mainScreen().bounds)
// iOS 9 之后
let w = UIWindow()

window必须在app的整个生命周期都被持有。所以AppDelegate拥有window的强引用，我们一般不会将一个view直接放在主window上，而是通过将一个ViewController付给window的rootViewController属性，
如果你使用的是main.stroyboard 这个事情也是系统做好的，rootViewController 会直接指向main.stroyboard的initial view controller 。一个VC成为window的rootViewController 后，它的view也会变成UIWindow的直接子视图。你的app将会在调用window?.makeKeyAndVisible()时显示。

总结下初始化、创建、配置显示主窗口的过程：（应该考虑两种情况）

通过main storyboard 创建
- storyboard 文件在 Info.plist 的键为 Main storyboard file base name 中指定(UIMainStoryboardFile)
- UIapplicationMain 实例化 UIWindow 并设置好 frame
- 把设置好的 UIWindow 的实例指定给 app delegate 的 window 属性
- 实例化 view controller 并指定给 window 的 rootViewController 属性
- 这些都发生在 app delegate 的 application:didFinishLaunchingWithOptions: 被调用之前
不使用 main storyboard
- 因为项目模板都会自带 storyboard，所以需要做以下步骤来获得一个纯净的空白项目
  - 在 General pane，选择 Main 并且删除
  - 删除 Main.storyboard 以及 ViewController.swift
  - 删掉 AppDelegate.swift 中的所有内容
  - 然后替换为以下代码

import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?
    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        
        self.window = UIWindow()
        self.window!.rootViewController = UIViewController()  // 也可以是自定义的子类
        self.window!.backgroundColor = UIColor.whiteColor()
        self.window!.makeKeyAndVisible()
        return true
    }
}

上面是app运行最少需要的代码，运行指挥得到一个白板。

如何使用window的子类：

main storyboard

在app运行时，在UIApplicationMain初始化完appDelegate后，就会询问appDelegate的window属性是否有值，如果为nil，UIApplicationMain就会创建一个UIWindow的实例，如果不为nil，直接使用其值作为main window。
🌰:

lazy var window : UIWindow? = {
    return MyWindow()
}()

不使用main storyboard

这个就简单了，window本来就是自己初始化的，直接 window = MyWondow()

app一运行，会有很多方法来引用主window

如果一个 UIView 在界面中，它自动会有一个 window 属性，里面有对 window 的引用
- 也可以使用 UIView 的 window 属性来检查这个 view 是不是被嵌入到了 window 中。如果不是，那么 window 属性为 nil。一个 window 属性为 nil 的 UIView 对用户来说是不可见的.(self.view.window)
app delegate 实例会维护一个指向 window 的引用(window 属性)，可以通过 shared application 来获取
- let w = UIApplication.sharedApplication().delegate!.window
- 如果想要不那么通用的方法，可以显式转换成 app delegate 类
- let w = (UIApplication.sharedApplication().delegate as! AppDelegate).window
shared application 会在 keyWindow 属性中维护一个指向 window 的引用
- let w = UIApplication.sharedApplication().keyWindow
- 这个引用不是很稳定，因为系统可能会创建临时的 window 并且把它们当做 key window,所以最好还是用第二种

Single View Application 模板

本章节重点是view，所以暂且不介绍ViewController相关内容，后面章节会介绍

新建的Single View Application会自动创建一个Main.storyboard 和 ViewController.swift作为window的rootViewController。

现在我们可以在ViewController.swift中通过代码添加一个view上去
就在viewDidLoad方法中

 override func viewDidLoad() {
        super.viewDidLoad()

        let mainview = self.view
        let v = UIView(frame:CGRectMake(100,100,50,50))
        v.backgroundColor = UIColor.redColor() // 红色小块
        mainview.addSubview(v) // 添加到mainview
        
    }

不包含main storyboard的实现方式

func application(application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?)
        -> Bool {
            self.window = UIWindow()
            self.window!.rootViewController = UIViewController()
            // here we can add subviews
            let mainview = self.window!.rootViewController!.view
            let v = UIView(frame:CGRectMake(100,100,50,50))
            v.backgroundColor = UIColor.redColor() // small red square
            mainview.addSubview(v) // add it to main view
            // and the rest is as before...
            self.window!.backgroundColor = UIColor.whiteColor()
            self.window!.makeKeyAndVisible()
            return true
    }

Subview and Superview (子视图和父视图)

在iOS中，一个subview的一部分或者全部都可以出现在其superview的外部。一个 view 可以和另一个 view 重叠，即使不是其 subview 也可以绘制部分或全部绘制在另一个 view 之前。

测试了下，在interface Builder中拖拽的时候是被挡住的

配图

但是运行结果是没有挡住的

配图

View 层级的特点

如果一个 view 被移出或者引入它的 superview，它的 subview 会跟着
一个 view 的透明度会被其 subview 继承
一个 view 可以限制 subview 的显示范围，比如不让 subview 超出 view 本身的范围，这叫做 clipping，被设置在 clipsToBounds
属性中
一个 superview 拥有它的 subview
如果一个 view 的尺寸变化了，它的 subview 也会自动被重新设置尺寸

一个UIView有一个superview属性和一个subviews（数组）属性（都是可空类型）。可以据此来判断视图层级。另外也有一个 isDescendantOfView: 方法来检查一个 view 是不是另一个 view 的 subview (可以不是直接子视图)。View 还有一个 tag 属性，可以通过 viewWithTag: 来进行引用。我们最好给所有subviews设置不同的tag

使用代码操作视图层级：（可以直接操作，也可以配合动画）

addSubview: 方法添加一个 subview
removeFromSuperview 移除一个 subview
insertSubview:atIndex: 指定index层级
insertSubview:belowSubview: 在某个view下面添加一个subview
insertSubview:aboveSubview: 在某个view上面添加一个subview
exchangeSubviewAtIndex:withSubviewAtIndex: 交换两个subview的位置
bringSubviewToFront: 将某个subview移动到最前面
sendSubviewToBack: 将某个subview放到最后面

没有一个方法可以直接移除一个 view 的所有 subview。然而，因为一个 view 的 subview 数组是一个不可变的数组，所以可以用如下方法一次移除全部：

myView.subviews.forEach {$0.removeFromSuperview}

重写下列方法就可以根据需要在不同的情况下进行不同的操作：

didAddSubview:, willRemoveSubview:
didMoveToSuperview, willMoveToSuperview:
didMoveToWindow, willMoveToWindow:

Visibility and Opacity（可见性和透明度）

视图的可见性可以通过设置 hidden 属性来更改。一个隐藏的 view 无法接收触摸事件，所以对于用户来说相当于不存在，但实际上是存在的，所以仍然可以在代码中对其操作

View 的背景颜色可以通过其 backgroundColor 属性来设置，颜色属于 UIColor 类。如果 backgroundColor 为 nil(默认值) 那么背景就是透明的。

可以通过设置 view 的 alpha 属性来修改透明程度，1.0 是完全不透明，0.0 是透明。假设一个 view 的 alpha 是 0.5，那么它的 subview 的 alpha 都是以 0.5 为基准的，不可能高于 0.5。而 UIColor 也有 alpha 这个属性，所以即使一个 view 的 alpha 是 1.0，它仍旧可能是透明的，因为其 backgroundColor 可以是透明的。一个 alpha 为 0.0 的 view 是完全透明的所以是不可见的，通常来说也不可能被点击。

View 的 alpha 属性不仅影响背景颜色，也会影响其内容的透明度。（比如一个背景色将会渗透图片）

我大概实验了下，应该是下面这个🌰 的意思：

配图

view的opaque（不透明度）,并不会影响view的样子，更多的是对于系统绘制时的提示。如果一个 view 的 opaque 设为 true，因为不用考虑透明的绘制，所以效率会高一点，并且再设置透明的背景颜色或者 alpha 属性都无效。可能会让人吃惊，它的默认值是 true

但是我设置了view的alpha=0.3 还是有不透明的效果(或者是叠加),在设置前后都打印了opaque的值都是true

配图

然后还手动把opaque设置为false,但是也没有什么用，懂的解释下??

Frame

View 的 frame属性(CGRect类) 是它本身的长方形在 superview 中的位置，注意是在 superview 的坐标系中的位置。默认来说，superview 的坐标系原点在左上，向右 x 增加，向下 y 增加。

看一个frame使用的简单的例子：

let mainview = self.view
let v1 = UIView(frame:CGRectMake(113, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:CGRectMake(41, 56, 132, 194))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
let v3 = UIView(frame:CGRectMake(43, 197, 160, 230))
v3.backgroundColor = UIColor(red: 1, green: 0, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
mainview.addSubview(v3)

以上很基础的代码，不赘述了。

Bounds and Center

bounds 属性对应的是一个 view 在自己的坐标系统中的矩形尺寸（注意，frame 是在 superview 的坐标系下的）

let v1 = UIView(frame:CGRectMake(113, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:v1.bounds.insetBy(dx: 10, dy: 10))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)

这是一种很常见的 bounds 的用法，当你需要往一个 view 里放东西的时候，无论是手动绘制还是放置一个 subview，通常都要使用 view 的 bounds

配图

当你改变一个 view 的 bounds 时，它的 frame 也会对应改变，frame 的改变是基于其中心点的（中心点不会变），下面的代码描述了这个情况：

let v1 = UIView(frame:CGRectMake(113, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:v1.bounds.insetBy(dx: 10, dy: 10))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
v2.bounds.size.height += 20
v2.bounds.size.width += 20\

效果就是从上图变成了下图，增加的 20 会被均匀分布在上下左右，正好抵消了之前的设置。

配图

当创建一个 UIView 时，其 bounds 的坐标原点是 (0.0, 0.0)，也就是左上角，如果改变了 bounds 的原点，也就改变了其坐标系，其 subview 一般也会有变化，下面代码描述了这种情况

let v1 = UIView(frame:CGRectMake(113, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:v1.bounds.insetBy(dx: 10, dy: 10))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
v1.bounds.origin.x += 10
v1.bounds.origin.y += 10

配图

如果你把那两个10改成20 效果如图

配图

我们并没有设置subview的任何属性，然而subview移动了，可以看到 subviw 向着原点移动方向的反方向进行了移动，这是因为一个 view 的原点与其 frame 的左上角一致

我们看到改变 bounds 的 size 会影响其 frame 的 size ，改变 frame 的 size 会影响其 bounds 的 size 。只有 view 的 center 不会影响 bounds 的 size 。这个属性代表了 subview 在 superview 中的 position 。

书中给出获取一个view的center的方法

let c = CGPointMake(theView.bounds.midX,theView.bounds.midY)

但是经过我验证，这个方法获得的是view相对于自己坐标的，我自己测试代码如下，或许应该加上x ， y 坐标

let v3 = UIView(frame:CGRectMake(113, 111, 132, 194))
print(v3.center)    // (179.0, 208.0)
let c = CGPointMake(v3.bounds.midX, v3.bounds.midY)
print(c)    // (66.0, 97.0)
let c1 = CGPoint(x: v3.bounds.midX+113, y: v3.bounds.midY+111)
print(c1)   // (179.0, 208.0)

view的bounds和center互不影响，相互独立的。frame是center和bounds便捷的表达。大多数情况我们只需要使用frame就可以了。一般会通过init(frame:) 来创建一个view。注意有些情况下 frame 会没有什么意义，但是 bounds 和 center 总是有效的，所以建议多用 bounds 和 center 的组合，也比较容易理解。

bounds: 一个 view 自己的坐标系统
center: 一个 view 的坐标系统和其 superview 的坐标系统的关系

可以用如下方法来进行不同 view 之间的坐标转换

convertPoint:fromView:, convertPoint:toView:
convertRect:fromView:, convertRect:toView:

如果第二个参数是nil，系统自动填补为window

比如我们上面算center的例子也可以这样转换下

print(v3.center)    // (179.0, 208.0)
let c = CGPointMake(v3.bounds.midX, v3.bounds.midY)
let c2 = v3.convertPoint(c, toView: self.view)
print(c)    // (66.0, 97.0)
print(c2)   // (179.0, 208.0)

注意，通过改变 center 来设置 view 的位置时，如果高或宽不是偶数，那么可能会导致 misaligned(错位)。可以通过打开模拟器的 Debug -> Color Misaligned Images 来进行检测。一个简单的方法是调整好位置之后调用 makeIntegralInPlace 来设置 view 的 frame

Window Coordinates and Screen Coordinates(窗口坐标和屏幕坐标)

设备屏幕是没有 frame 的，但是有 bounds。Main window 也没有 superview，不过其 frame 被设置为屏幕的 bounds，如：

let w = UIWindow(frame: UIScreen.mainScreen().bounds)
//iOS 9
let w = UIWindow() //系统自动设置为上面代码

大多数情况下，window是充满整个屏幕的，所以大多数情况下window的坐标和screen的坐标是一样的。

现在的 iOS 中坐标系和手机是否选择是有关的，有如下两个属性：（在实际开发中基本不会碰到）

UIScreen 的 coordinateSpace 属性
- 这个坐标空间会旋转，就是高和宽在设备旋转时会呼唤，(0.0, 0.0) 是这个 app 本身的左上方
UIScreen 的 fixedCoordinateSpace 属性
- 这个坐标空间不会变化，就是物理上的左上角，从用户来看，这里的 (0.0, 0.0) 可能是 app 本身的任何一个角

可以用下面的方法来对不同坐标空间进行转换：

convertPoint:fromCoordinateSpace:,convertPoint:toCoordinateSpace:
convertRect:fromCoordinateSpace:, convertRect:toCoordinateSpace:

假设界面中有一个 UIView v，我们想知道它的实际设备坐标，可以用下面的代码：

let r = v.superview!convertRect(v.frame, toCoordinateSpace: UIScreen.mainScreen().fixedCoordinateSpace)

但实际上你需要这种信息的机会非常少(反正我是没遇到过需要使用的)，或者其实几乎都不用担心 window 坐标，因为所有的可见操作都会在 root view contoller 的 main view 中进行，它的 bounds 是会自动调整的。

Transform ( 变换 )

一个 view 的 transform 属性改变这个 view 是如何被绘制的，实际上就是一个 CGAffineTransform类的 3x3 矩阵（线性代数中的概念）。所有的变换都是以这个 view 的 center 做基准的。

🌰

let v1 = UIView(frame:CGRectMake(113, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:v1.bounds.insetBy(dx: 10, dy: 10))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
v1.transform = CGAffineTransformMakeRotation(45 * CGFloat(M_PI)/180.0)

旋转

上面代码的例子只是对前面例子的v1做了45度的旋转。

我们如果打印下v1旋转前后的三个属性：

print("frame : \(v1.frame) , bounds:\(v1.bounds) , center:\(v1.center)")
//        frame : (113.0, 111.0, 132.0, 194.0) , bounds:(0.0, 0.0, 132.0, 194.0) , center:(179.0, 208.0)
 v1.transform = CGAffineTransformMakeRotation(45 * CGFloat(M_PI)/180.0)
print("frame : \(v1.frame) , bounds:\(v1.bounds) , center:\(v1.center)")
//        frame : (63.7415946665928, 92.7415946665928, 230.516810666815, 230.516810666815) , bounds:(0.0, 0.0, 132.0, 194.0) , center:(179.0, 208.0)

发现只有frame变了，center和bounds都没有变，但是 frame 的数值已经没有意义，因为现在它的尺寸是能够覆盖当前 view 的最小的矩形，并不会随着 view 的旋转而选择。

如果我们把旋转换成缩放

       print("frame : \(v1.frame) , bounds:\(v1.bounds) , center:\(v1.center)")
       v1.transform = CGAffineTransformMakeScale(1.8, 1)
       print("frame : \(v1.frame) , bounds:\(v1.bounds) , center:\(v1.center)")
//        frame : (113.0, 111.0, 132.0, 194.0) , bounds:(0.0, 0.0, 132.0, 194.0) , center:(179.0, 208.0)
//        frame : (60.2, 111.0, 237.6, 194.0) , bounds:(0.0, 0.0, 132.0, 194.0) , center:(179.0, 208.0)

还是只有frame发生了改变。因为他的位置并没有变只是被拉长了。bouds并不会因此而改变

变换矩阵的计算可以连接的，所以不同的变换是可以叠加的，并且顺序是重要的（矩阵乘法不满足交换律）

🌰

let v1 = UIView(frame:CGRectMake(20, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:v1.bounds)
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
        
v2.transform = CGAffineTransformMakeTranslation(100, 0)
v2.transform = CGAffineTransformRotate(v2.transform, 45 * CGFloat(M_PI)/180.0)

这个例子我们先在主view上放了两个完全重叠的view，然后对v2做了平移和旋转的变换，两个叠加起来的

效果：

先平移后旋转

v2.transform = CGAffineTransformMakeRotation(45 * CGFloat(M_PI)/180.0)
v2.transform = CGAffineTransformTranslate(v2.transform, 100, 0)

先旋转后平移

也可以使用这个方法CGAffineTransformConcat:

 let r = CGAffineTransformMakeRotation(45 * CGFloat(M_PI)/180.0)
 let t = CGAffineTransformMakeTranslation(100, 0)
 v2.transform = CGAffineTransformConcat(t,r)

这个也需要注意顺序

Trait Collections and Size Classes

界面上的每个 view(或者ViewController) 都有一个 traitCollection 属性 , 值是一个 UITraitCollection，包含下面四个属性：

displayScale 由当前屏幕决定的缩放尺寸，1 4以前的机型基本没有了应该 2 、（4，5，6 3） 3、 (iPhone 6 plus/6s Plus) 。（和UIScreen的scale值是一样的）
userInterfaceIdiom 一个 UserIterfaceIdiom 值，可能是 .Phone 或 .Pad，来标志不同的设备，默认来说和 UIDevice 的 userInterfaceIdiom 属性一致
horizontalSizeClass, verticalSizeClass，是 UIUserInterfaceSizeClass 值，可能是 .Regular 或 .Compact
- 水平和竖直都是 .Regular -> iPad
- 水平是 .Compact 竖直是 .Regular -> iPhone 在垂直方向，或者 iPad 的分屏应用
- 水平和竖直都是 .Compact -> iPhone 在水平方向(iPhone 6/6s plus除外)
- 水平是 .Regular 竖直是 .Compact -> iPhone 6/6s Plus 在水平方向

当应用运行时如果 trait collection 发生改变，会调用traitCollectionDidChange 方法

traitCollectionDidChange传入的参数是旧的traitCollection值：

override func traitCollectionDidChange(previousTraitCollection: UITraitCollection?) {
    print("old----\(previousTraitCollection?.verticalSizeClass.rawValue)")
    print("old----\(previousTraitCollection?.horizontalSizeClass.rawValue)")
    print("new----\(self.view.traitCollection.verticalSizeClass.rawValue)")
    print("new----\(self.view.traitCollection.horizontalSizeClass.rawValue)")
}

切换几次横竖屏的结果：

配图

traitCollection还可以自己设定，这个特性将在后面章节讲到

Layout

superview 移动的时候 subview 就会移动。subview 大小和位置会随着 superview改变，这就是layout。

一些superview动态改变的例子：

屏幕旋转的时候，左上角会发生变化，长宽也要对调
我们的app需要等比例匹配不同的设备尺寸
universal app需要运行在iPad和iPhone上，所以自己需要知道自己运行的环境来适应不同的屏幕
从xib初始化的view，需要resize去适应所在的view
view需要适应别的view的变化对自己的影响，比如navagationBar隐藏和显示
。。。

在以上的任何情况下其他view可能需要Layout

Layout 有三种主要的执行方式

手动 layout:superview 在被更改尺寸会会发送 layoutSubviews 消息，如果你新建自己的子类并且重写 layoutSubviews 就可以手动进行更改，这很麻烦，但是可以做任何你想做的事情
Autoresizing： iOS 6 之前的方式，主要是通过自己的 autoresizingMask 属性来变化
Autolayout：根据 view 的 constraints(NSLayoutConstraint) 来进行变化，是很强大的功能，不用写代码就可以进行复杂的定制

Autoresizing（自动调整大小）

Autoresizing 是一种自动拉伸和固定大小的一种概念，view有一个autoresizingMask 属性，这个属性是一个UIViewAutoresizing 的值。默认是.None 。下面举例来看看它的用法：

let mainview = self.view
let v1 = UIView(frame:CGRectMake(100, 111, 132, 194))
v1.backgroundColor = UIColor(red: 1, green: 0.4, blue: 1, alpha: 1)
let v2 = UIView(frame:CGRectMake(0, 0, 132, 10))
v2.backgroundColor = UIColor(red: 0.5, green: 1, blue: 0, alpha: 1)
let v3 = UIView(frame:CGRectMake(v1.bounds.width-20, v1.bounds.height-20, 20, 20))
v3.backgroundColor = UIColor(red: 1, green: 0, blue: 0, alpha: 1)
mainview.addSubview(v1)
v1.addSubview(v2)
v1.addSubview(v3)

v2 和 v1 宽度相等

执行结果：

配图

如果我加上一句代码，改变了v1的宽度呢？

v1.bounds.size.width += 40

结果如图：

就变成这样了

这时候就可以利用autoresizingMask属性来指定v2的宽度可伸缩。

v2.autoresizingMask = .FlexibleWidth

结果：

配图

这里注定一点，要先指定可伸缩，再改变大小

同理v3也可以：

v2.autoresizingMask = .FlexibleWidth
v3.autoresizingMask = [.FlexibleTopMargin, .FlexibleLeftMargin]

v1.bounds.size.width += 40
v1.bounds.size.height -= 50

v3就相当于在左边和上边放了弹簧

配图

其实这种类似于约束布局，现在大部分会选择使用Autolayout，下面小结看下Autolayout的用法。
Autolayout部分请戳：Views - AutoLayout

1、Views

概述

Window

Single View Application 模板

Subview and Superview (子视图和父视图)

Visibility and Opacity（可见性和透明度）

Frame

Bounds and Center

Window Coordinates and Screen Coordinates(窗口坐标和屏幕坐标)

Transform ( 变换 )

Trait Collections and Size Classes

Layout

Autoresizing（自动调整大小）

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

程序员

首页投稿（暂停使用，暂停投稿）

iOS Developer

编程学习

Swifty Coding