作者：姜沂（倾寒）

出品：阿里巴巴新零售淘系技能

苹果在2019年的WWDC的重头戏当然非SwiftUI莫属：全新的声明式语法、绑定式API、和呼应式变成结构Combine。这悉数的悉数都预示着即将在Apple Nativ& 9 $ ) i te布局体系掀起一场革新。2 j ?为此，苹果在许多方面都做了尽力，这才促成了SwiftUI现在的样子。想要了解Swift的新特性、SwiftUI数据流和SwiftUI布局体系等新知识吗？一起来看吧。

Swift 5.1 新语法

单表达式隐式回来值

在 Swift 5.0 之前的语法中，假如一个闭包表达式只要一个表达式，那么能够省略 return 关键字。 现在 Swift 5.1 以后的版别中核算特点和函数句子相同适用。 如：

// bef* ? P C zore swift 5.0
struct Rectangle {
var width = 0.0, height = 0.0
var area1: Double {
retuh 6 rrn width * height
}
func area2() -> Double {
return width * height
}
}
// after switft 5.1
struct Rectangle {
var width = 0.6 y ~ Z % v t 10, height = 0.j c k u0
va9  Yr area1: Double { width * heig- o / eht }
func a{ q i M Y a ! 5rea2() -> Double { width * height }
}

关于这个新特性的完好提案能够参阅（github.comt o c z/apple/Swift…

依据结构体默许成员组N K U . * )成默许初始化器

在 Swift 5.0 之前结构体声明，编译器会默许生成一个逐个成员初始化器，一起假如都有默许值，还会生成一个无参的初始化器。
但假如此刻结构体成员特点过多，且较多都有默许值，则只能运用逐个成N n / y员初始化器，会使{ 9 0 e S C P每处调用的当地写法过于冗余，在传统 OOP 言语中能够运用 Builder 形式处理， 但在 S& f Fwift& 7 9 M | 4 J J 5.1 之后编译器会按需组成初始化器，防止初始化写法的冗余。 如：

struct Dog {
var name = "Generic dog name"
var an F 2 t l a )ge = 0
}
let boltNewborn = Dog()
let daisyNewborn = Dog(name: "Daisy", age: 0)
// before swift 5.0 ❎
let benjiNewborn = Dog(name: "Benji")
// after switft 5.1 ✅
let benjiNewo F D ,born = Dog(name: "Benji")

关于这个新特性的完好提案能够参阅（github.com/apple/Swift…

字符串刺进| 0 5 z j ? , @运算符新规划

这个特性首要扩大了字符串刺进运算符的运用范围，以前咱们只能用在 String 的初始化中，可是不能在参数处理中运用字符串刺进运算符。 在以前的语法中只能分隔书写，尽管没什么大问题，但总归要G d , L多一行代码，现在能够直接运用了， 尤其是关于 SwiftUI，Text 控件就运用到了这种新语法，能够使咱们在单行表达式中即可初始化 Tetx。

// before swift 5.0 ❎
let quantity = 10
label.text = NSLocalizedString(
"You have \(qu# = d T X Z p hantity) apples,
comment: "NumbS  F R Ter of apples"
)
label.text = String(format: formatString, quantity)
// after switft 5.1 ✅
let quaO k z  H 1 7 Wntity = 10
return Text(.
"You have \(quantity) apples"
).
// 实践上编译器会翻译为如下几句
var builder = Loi [ : s F 6caliw a ^ u k h - - NzedStringKeyJ 6 y.StringInterpolation(
literalCap8 o d ) hacity: 16, interpolationCount: 1
)
builder.0 5 zappendLiteral("You have ")
b6 m M } p  5 # builder.appendInterpolation(quantity)
builder.appendLiteral(" apples")
LocalizedStringKey(sti e r 2 z s # bringInterpolation: bui^ I Y E f : _ r Older)

关于这个新特性的完好提案能够参阅（github.com/apple/Swift…

特点包装器

当咱们在一个类型中声明核算特点时，大部分特点的拜访和获取都是有相同的用处，这些代码是可抽取的，如咱们符号一些用户偏好设置，在核算特点的设置和获取中直接代理到 UserDeB h I [ % 3 8fault的完成中，咱们3 m ] 1能够经过声明 @propertyWarpper 来润饰，能够减少许多重a O o K o 2 a O 2复代码。 在 SwiftUI中， @State @EnviromemntObject @bindingObV R F b ; , 8 . iject @Binding 都是经过特点包装1 – 8器代理到 SwiftUI 结构中使其主动呼应事务状况的改变。

// before swift 5.0 ❎
struct User {
static var usesTouchID: Bool {
get {
return UserDefaults.standard.bool(forKey: "USES_TOUCH_ID")
}
set {
UserDefaults.standard.set(newValue, forKey: "USES_TOUCH_ID")
}
}
static var isLoggeg R dIn: Bool {
get {
return UserDefaults.standard.bool(forKey: "LOGGED_IN")
}
set {
UserDefaults.standard.set(newValue, forKey: "LOGGED_IN")
}
}
}
// after switft 5.1 ✅
@propertyWrapper
strucR 6 % 2 :t UserDefault<T> {
let key: String
let defaultValue: T
init(L w @ R H g ~_ key: String, defaultValue: T) {
print("UserDefault init= X $ # Q y $ d u")
self.key = key
self.) J { BdefaultValue =/ P 9 defaultValue
UserDefaults.standard.register(defaults: [key: defaultValue])
}
var value: T {
get {
print("getter")
return UserDefaults.standard.object(forKey: key) as? T ??  defaultValue
}
set {
print("setter"w + 9 4 H / = a)
UserDefaults.standard.set(nV C [ewValue, forKe5 ! P S iy: key)
}
}
}
struct User) 3 f M B X2 {
@UserDefault("USES_TOUCH_ID", defaultValue: false)
static var usesTouchc w b P f U vID: Bool
@UserDefault("LOGGED_IN", defaultValue: false)
var isLoggedIn: Bool
}
print("hello w7 c s Q Mo8 6 ` o W srld")
let user = User2()
User2.usesTouchID = true
let delegate = User2.$uG 4 L H @ AsesTouchID
print("\(delegate)")
let detelate2 = user.$isLogged| f ~ YIn

实践上特点包装器是在编译时期翻译为以下的代码, 而且编译器禁止运用 $ 最初的标识符。

struct User2 {
static var $usesTouchID = UserDefault<Bool>("USES_TOUCH_ID", defaue + # p } P j iltValue: false)
static var usesTouchID: Bool {
set {
$usesTouchID.value = newValue
}
get {
$usesTo, a b ( JuchID.value
}
}
@UserDefault("LOGGED_IN", defaultValue: false)
var isLoggedIn: Bool
}

运用特点包装器的好处除了能够减少重复代码，Swift Runtime 还保证了以Z 8 L J下几点：

1、关于实例的特点包装器是即时加载的

2、关于类特点的特点保证器是懒加载的

3、特点包装+ j Z v W器是线程安全的

4、经过 $ 运算符能够获取到原始的特点包装器实例，这许多运用在 SwiftUI 的数据依赖中

关于这个新特性的完好提案能够参阅（github.com/apple/sB B d owift…

注：在现在的 Beta 版别中 @PropertyDelegate 和 @PropertyWrapper 是共同的，正式版别发布会应该只会保存一种语法。

不透明回来类型

在 Swift 5.0 之前咱们假如想回来笼统类型一般运用 GenerD [ D g C ~ R [ yic Type 或许 Protocol, 运用泛型会显现的露出一些信息给 API 运用者，不是完好的类型笼统。 可K @ / t是运用{ 3 o + ] M q p Protocol 也有几个约束: 泛型回来值在运行时都是一个容器，功率较差，回来值不能调用本身类型的办法，协议不允许拥有关联类型，因为编译时丢掉了类型信息，编译器无法揣度类型，导致无法运用 == 运算符。

在 Swift 5.1 中新增了 opaque result type，这个特性运用 some 润饰协议回来值，具有以下特性：

1、一切的条件分支只能回来一个特定类型，– E 7 1 *不同则会编译报错

2、办法运用者依旧无法知道类型，（运用方不~ x R } l 7 0 ,透明）

3B : W ) Q、编译器知情具体类型，因而能够运用类型揣度。

// before swil + o b . 6ft 5.0 ❎
public protocol View : _View {
associatedtype Body : View
var+ m H body: Self.Body { get }
}
// compile error
func getTeH & V g I z qxt() -> ViewF r $ {
return Text("")
}
func getText<T: Text>() -> T {
return Text("")
}
// after switfH J Yt 5.1 ✅
struct ContentView: View {
var body: some View {
Text("")
}
}

关于这个新特性的[ + ( ( 1 Y完好提案能够参阅（github.com/apple/SwR . L p ; w @ oift…

Swift Style DSL / Function Builder

此项提案是一个比较特别的提案，原因在于现M O 7 . J c 7 #在还在审阅中，并没有正式参加 Swift 言语中，可是 Xcode11 自带的 Swift 5.1 现已集成了这项语法. 运用 Function Builder 能够使表达式句子隐含的回来在函数回来值中， 这样能够在J m i H Y |嵌套逻辑和回来值表达式的 DSL 中十分具有表现力。如下面的句子是同等的：

// Original source code:
@TupleBuilder
func build() -> (Int, Inta C / | v 4 G 4 :, Int) {
1
2
3
}
// This code is interpreted exact~ J X G X Fly as if it were this code:
func build() -&9 H ) Q A |gt; (Int, Int, Int) {
let _a = 1
l^ ~ ? e )et _b = 2: k 5
let _c = 3
return TuD 1 : 8 T u | l 9pleBuilder.buildBlock(_{  O Da, _b, _c)
}

在 SwiftUI 中的一切布局类控件，几乎悉数运用了 Function Builder 特性，可读性要远远大于 Flutter 的 DSL语法，以下是一个苹果 WWDC Session 的比方。

headJ I  i {
meta().cha? t % i r rset("UTF-8")
if cond {
title("Title 1")
} elseq s O B {
title("Title 2")
}
}
实践上会被翻译为
head {
let a: HTML = metd k 8 4 q _ Ea().charset("UTF-8")
let d: HTML
if cond {( A @ E d V
let b: HTML = title("Title 1")
d = HTM! 0 HLBuilder.buildEitheE g ? ) $ p F z =r(first: b)
} else {
let c: HTML = title("Title 2")
d = H? z I i U S 9 STMLBuilder.buildEither(second: c)
}
return HTMLBuilder.buildBlock(a, d)
}

可读性大大加强，但值得注意的是现在在 SwiftUI 中运用 Function BuiR & _ llder 完成的 ViewBuilder 功用( S [ &仅仅支撑 10 个泛型参数，在 Swic R ~ 4ftUI 中9 7 d，假如同等级元素中，超越 10 个则会有古怪的编译错误。

这点官方引荐运用组合下降 View 结构，这点和 Flutter 的引荐写法不同，超越 10 个 则会编译错误 -_-。v ; % J j

现在这份提议function-builders.md，还在草V y I案阶段，所以完成是一份下划线关 p g q D m s q键字。

不扫除苹果会在 9月份正式版别降临之前稍加修正语法，但信任这份功用的放开也会在正式版别发布之期修正结束。

其他新特i ` I J m 9 K ; Q性! F R V

本文首要介绍了9 K ^ ] p & K D一些新的语法c } y . ( @特性，且大部分都和 SwifQ U –tUI 相关，从 WWDC 的Session 演讲者都透露出 Swift 言语组的中心方针，Make Your Swift API Better

首要从以下几个表现。

1、Expressive 有表现力

2、Clear 清晰没二义性

3、Easy to use 简b j i V S略易用

本文还有许多的 Swift 5.1 新特性没有说到，如 @dynamicCallable @dyn} ? z y hamicMemberLookup WritableKeyPa; c s w f Eth 有爱好的读者能够参阅6 / 7 3 5 U Swift的完好演化J K ; j f @ # [ }提案 swift-evolution。（g) 2 ^ Xithub.com/apple/swift…

Swift 从 3.x Attribute

Swift 自g n T 3.0 版别至今增加了许多 特点（Attribut） 符号，这些 Attribute 经过给编译器供给信息，增强了 Swift 的元编程能[ ( V u y ) W 3力，假如读者有爱好能够参阅这份完好的正式版别 Attribute大全。（docs.swift.org/swift-book/…e E e [ + ~

Swift/SwiftUI API Design Guide

Swift 现现已过 9（4年内部孵化） 个年头的开展，言语的规划攻略现已区域问题，其间触及到了许多不同于其他言语的观点，本年的 Session 着重的梳理了以q E T e下几点。

值类型和引证类型

当你规划一个数据结构时，W / G q + u P 1 h优先选择结构体或许枚举，它们都是值类型，值类型具有以下几个有点。U 8 W C ( u

1.值类型在栈上分配，功用要远远大于引证类型，且 Swift Runtime 有 COW 优G 6 – /化。

2.值类型没有引证计数，不会引起古怪的多线程安全问题。

3.值类型的存储特点是扁平化的，防止在类承继情况 d 7 T下L H 3一个子类承继过多的存储特点导致实例在内存中过大，如 SwiftUI 运用 Modifier的结构体优化规划。

那什么时分咱们才需求运用引证类型呢？ 只要当以下几个场景存在时才有必要运用。

1、你需求引证计数和结构和析构的机遇m m 4 1 _ W t。

2、数据需求会集办理或同享，如单例或许数据缓存实例等。

3、ID 语义和 Equal语义冲突的时分。

协议还是泛型

随着 Swift 中 POP 的盛行，许多人触及 API 越来越习惯运用 协议，可是官方指出规划的关键， 规划是演进的而不是u s 6 0 e H f一步到位的，应该恪守以下过程。

1、不要直接声明协议
2、从实践F p ~ H Q o的事务场景动身
3、从中笼统出共用代码
4、从已R : q c &有的协议中组合协议，而不是从头构建一套新的协议结构

DynamicMemberLookup & dynamicCalle z u U a 3 { Zable

这个语法其实是 Swift 4.2 的老语法了，可是在 Xcode11 中， IDE进一步获得了增强，能够轻松获得代码提示，假如运用过 ruby 和 python的开发者，能够容易地了解，把_ b )一个实例当} M ) m 1 ! $办法调用， 静态言语在保证安T j F全的前提下能够经过编译，并能够动态调用，信任未来在和其他言语互通时能够大方光彩。

笼统数据拜访

前面现已介绍过来 Swift 5.k M H , $ a G f L1 新增语法 PropertyWarpper, 在 Swift 中许多核算特X _ ; % ( y *点都围绕着数据拜访如 懒加载，防御性复制，TLS数据区，而它们的形式都是共同的， 多运用 PropertyWarpper 能够笼统共用代码，加强[ [ O 8 x K l API 语义。 在M / _ R SwiftUI 中中心的数据流，均运用 PropertyWarpper 如 @Binding @State @EnviromentObject @Envi{ } r g V X 4 | +roment。

SwiftUI 360 剖析X | e

在 SwiftUI 中咱们不再运用传统的 Cocoa 指令式布局, % 4 l U X a ) &体系，该用声明式布局，那么究竟什么事声明式布局？什么是指令式布局？。 举个比方，假定Y w )你要规划如下布局。

在指令式布局体系中，你要做以下事情，

1、初始化一个 ImageView 实例

2、设置它的方位信息

3、设置它的缩放等级

4、8 T # + p i 7把它增加到当前的视图树中

5、假如有事情，设置下事情的代理或许回掉

开发者要做的事情繁多且易错，开发功率极为原始低下，但在声明式时代你只需求描绘一下信息。

屏幕上有个图片，在什么方位，是什么缩放份额即可， 至于怎样布局，悉数交给结构，Coder do less, Framework do m1 2 & 6 P Xore。

至于声明式编程和指令式编程，能够参阅维基百科 声明式编程M – ` ( 指令式编程。 实践上声明式编程早在上个世纪就现已提出而且演化很久，和指令式不同的是，声明式编程一般要求结构做的事情十分多，在前期核算机功用一般C A } e c _的时代，声明式编程并未大火， 一般多用于解析 DSL (Domain Specific Language) 中，比方前期的 HTML 布局，SQL 言语等。

趁便提下早在 2006 年微软便提出 WPF 结构，其间运用 XAML 言语编写声明式 UI 代码，一起支撑事情/数m O M |据绑定机制，合作世界榜首 IDE Visual Studio 强壮的拖拉拽功用，开发者体会爽到机L w e C 0 p制。 可是遗憾的是 Window Phone 并未在移动操作体系渠道争得一番天地，以至于许多人对声明式 UI 不甚了解。

声明式 UI 会是未来吗y ^ 7？

结合最近多年大火的前端大火的结构 React 移动渠道的@ Z 5 p P Reactive Native Weex 和 Flutter 包括暂时只能编写Native渠道的 SwiftUI 和 JetpacZ p (k Compose.{ V & D 8 v r / O 多方的数据证明和盛F J T / $ 9行度能够阐明，声明式X . x I T # ^编程在 UI 布局方面有得天独厚的优势， 信任未来 UI 布局也会是声明式编程的全国。

SwiftUI 中的 View

关于传统的的 Cocoa 编程中，一个 View 或许是一个 UIView 也或许是一个 NSVieN m W o N * – 6 mw 代表了屏幕; D P f x 上可视的元素，且依赖于对应的渠道。 而在 SwiftUI 的完成中 A View Defines a Piece of UId i + ) y * 一个 Vim A P z I i 3ew 是一个实在屏幕上可见元; | * 1 v ?素的描绘，在不同的渠D ] i u X e ! F `道能够是 UIView 也能够说 NSView 或 其他完成， Vi t p b 4ew 是跨渠道的描绘信息，底层的完成被封% } s G W d C l装在结构内部完成。

SwiftUI View & Modifier

在传统的指令式编程布局体系中，咱们对一些 UI 体系结构是一般Y . L I # .是经过承继完成的，再编写代码时经过对特点的调用来修正视图的外观，如色# U | 5 y { W彩透明度等。 但这会带来导致类承继结构比较复X T #杂，假如规划不行好会形成 OOP 的a x _ 3 ^ Z通病类爆破，而且经过承继来的数据结构，子类会集成父类的存G n Y P T @ h储特点，会导致子类实例在内存占有比较巨大，Q d f ! $ + 4 g即使许多特点都是默许值并不运用。 如图：

在 SwiftUI 中奖视图的润饰期笼统为 Modifier， Modifier一般只含有 1-2 个存储特点，经过原始控件的 Extension 能够在视图界说中增加各种 Modifier，它们在运行时的完成一般是一个闭包，在运行时 SwiftUI 构建出实在的视图s f 9 # i ! e D q。

SwiftL f m } H 7 :UI 元控件^ Y V 0 p

在 SwiftP 8 : M h aUI 体系中咱们运用结构体恪守 View 协议，经过组合现有# N 3 @ o的控件描绘，完成 Body 办法，但 Body 的办法会不会无限递归下去？

在 SwiftUI 体系中界说了 6 个元/主 View Text Color Spacer Ima5 p i u & 6gZ V x / = T $ e ce Shape Divider, 它们都不恪守 View 协议，只是基本的视图数据结构。

其他常见的视图组件都是经过组合元控件和润饰器t a X O $ q e来组合视图结构的。如 Button Toggle 等。

关于 SwiftUI 的视图和润饰器能够参阅 Github 整理的速查表Jinxiansen/SwiftUI。（gith( b s F ; L @ub.co` 5 F A H o y ? (m/Jinxiansen/…

DataFlow in SwiftUI

任何程序都不行能是静态的，充满着数据状况，函数充满着副作用，传统的指令式编程经过成员变o K D量来办理状况，这使得状况的复杂度成指数级增加。举一个最简略的比方。假定一个视图只要 4 种状况，组合起来就有16种， 可是人脑处理状况的复杂度是有限的，状况的复杂度一旦超越人脑的复杂度，就会发生许多的 Bk s 2ug，而且修掉了这个发生了那个* x R，试问哪位同学看见一个类充满着几十上百个成员特点和全局变量不想拍桌子的。

在 Flutter 中控件分为StateLess 和 St` b 9 – ( d d K NateFull 控件，数据流是单向的，随之诞生了 Bloc RxDart Redux 许多结构，尽管作者本人是 SwiftUc B h OI 的粉丝，但不得不说 Flutter 的许多思想十分先进。 这儿8 S ) ? G b & G T简略剖析下 SwiftU( h d [ OI 中怎么处理完们的数据流。 这儿Y $ g c –先放出数据流的原则，咱们重视两个点 Source of Truth 是指咱6 6 T s T + N ; .们真是的事务逻辑数据，DeH [ J z j ? , & drvied Value 是指 SwiftUI 结构中运用的数据。

Constant

一般部分 UI 数据是不行改变的，比方一个 Text 的 Color， 这4 K ;部分咱们能够直接运用 Modifier 的结构器讲特点传递进去即可，这儿就不做多解说了。

Text("Hello world")
.color(.red)

@State

那在: X Z I某些情况下咱们某些 UI 元素会有一系列的呼应事情，会导致视图发现改变，那么 SwiftUI 是怎样做到的？ 便是经过前面的新语法 Property warpper, 对一切运用 Stat` 1 H Xe 符号的特点 都会代理到 SwiftUI 中 State 的办法完成，一起结构，核算Diff，刷新界面。 趁便这儿强调下在 SwiftUI 中 Views area a ff E i vunction of State not of a sequence of Event, VS A t E o q ,iew 是实在视图的状况，并不是一系列改变的事情。

struct PlayerView: View {
let episode: Episode
@State private var isPh X O i Blaying = false
var body: some View {
VStack {
Text(episode.title)
Button(action h T m + z f $n: {
self.isPlaying.toggle()
}) {
Image(sym y ] 1 2 7stemName: isPlaying ? "pause.cicle" : "plaz j 3 { X l Gy.circle")
}
}
}
}

@Binding

再许多时分咱们会总归笼统减少咱们的代码长度，比方将上文中的 Button 笼统为一个 PlayerButton ， 这时分存在一个问题，State 特点咱们是再从头声明一份吗？

struct PlayButton: View { B X Z $ _ _
@Stat ! % {te private var isPlaying = false
var body: some View {
Button(actioL T Z 1n: {
self.isPlaying.toggle()
}) {
Image(systemName: isPlaying ? "pause.cicle" :& $ * a "play.circle")
}
}
}

这样写会有一个问题，咱们会发生两个 Derived Val_ M } Xue，| b D 8 E ^ P g尽管两者都可告诉 SwiftUI 做界面刷新，可是 PlayerView 和 PlayerButton 的数据同步又成了问题! 3 :。

SwiftUI 引荐运用 @Binding 处理，咱们来看下 Binding 的完成。

@prG r lopertyDelegate public struct Binding<Value> {
public var value: Value { get nonmutating set u ` ! n ut }
/// Initializes from functions to read and write the value.
public init(getValue: @escaping () -> Value, setValue: @escr W X D o c .aping (V3 , qalue) -> Void)
}

Binding 结构体运用闭包捕获了原本a – y 3 v C v的P 2 f p =特点值，使得特点能够用引证的办法保存。

struct PlayerView: View {
let episode: Episode
@State private var isPlaying = false
var body: some Vie5 $ % Sw {
VStack {
Text(episode.title)
PlayButton($l / 0 _ ! R D l fisPlaying2 T k q)
}
}
}

这儿 State 完成了 BindingConvertible 协议，使得 State 能够直接转换为 Binding。

**@BiZ u H g 4ngableObject &aC P K $ ! K ∓ Combine **

UI 除了受用户点击影响 有时分还来自于外部的告诉，如一个IM类音讯，收到远程的音讯，或许一个定时器被触发。

在 SwiftUI 中经过最新的 Combine 结构能够_ | K A ` p / F很便利的呼应外部改变，开发者只需完成 Bindab. T a b H 4 ^ o HleObject 协议即C B ] :可。

clasU p s PodcastPlayerStore: BindableObX D f Z G C / h iject {
var didChange = PassthoughSubject<Void, Never>()
func advance() {
// ..
didChange.send()
}
}
struct PlayerView: View {
let episode: Episode
@State private var isPlaying = false
@State private var currentTime: Times @ h Y + y ?  Interval = 0.0
var body: some View {
VStack {
Text(episode.title)
PlayButton($isPll R H _ 7 0 x / Faying)
}
.onReceive(Pod! G q ; % i $ ccastPlayerStore.currentTimePublisher) { newTime in
self.currentTime = newTiJ 9 c ] . + h N 2me
}
}
}

@ObjectBinding

运用 Sta. e +te 的办法能够告诉单个视图的改变，可是有时分咱们需求多个视图同享一个元素信息，而且在数X J 1 &据信息发送改变时告诉 SwiftUI 刷新一4 ! V K切布局，这时分能够X H A ; 1运用

@Obg Y 1jectBinding。

fe Y ) C # J I o Iinal class PodcastPlayer: BindableObject {
var i5 F n  ?sPlaying: Bool = false {
didSet {
didChange.send(self)
}
}
func play() {
isPlQ ! 3 L w .aying = true
}
funcw W # + # e c V S pause() {
isPlaying = false
}
var didChange = PassthrF } Houghc ` # dSubject<PodcastPlayer, Never>()
}
struct EpisodesView: V9 V X [ T } f Hiew {
@ObjectBinding var player: PodcastPlayer
let episodes: [Episode]
var body: some Vie0 N w {
List {
Button(
action: {
if self.player.isPlaying {
self.player.pause()
} e| f = i mlse {
self.] m E ( ^ G L e fplayer.play()
}
}, label: {
Text(player.isPlaying ? "Pause+ L j": "Play")
}
)
ForEach(episodes) { episode in
Text(episode.title)
}
}
}
}

@propertyDelegate public strucM * .t ObjectBinding<BindableObject4 ) - XType> : DynamicViewProperty where BindableObjectType : BindableObject {
@dynamicMemberT c ] ; !L( J h r ( f 7 ookup public struct Wrapper {
puq t Ublic subscript&l5 q b P g h w C }t;Subject>(dynamicMember keyPath: ReferenceWritableKeyPath<BindableObjectType, Subject>) -> Binding&a m : y v f ]lt;Subject> { get }
}
public var value: BindaZ Q D C Y ` v `bleObjectType
public init(initiav t j g / ClValue: BindableObjectType)
public var delegateValue: ObjectBinding<BindableObjectType>.Wrapper { get }
public var storageValue: ObjectBinding<a ( X kBindableObjectType>.Wrapper { get }
}

体系经过 ObjectBz s d o t {inding.WraF n Vpper 感知外部数据的改变。

@EnviromemntObject

有时分一些环境变量是同享的，咱们能够经过 EnviromentObject 获取同享的信息，这些同享的数据信息回沿着 View 树的的结构向下传递。 相似于 Flutter 的 Theme 和 ScopeModel ,比较简略这儿就不多做解说了。

let window = UIWindow(frame: UIScreen.main.bounds)
window.rootVieG T `wControlr k ) b m 9 z G Xler = UIHostingController(rootView: LandmarkList().environmentObject(UserData()))
struct L/ T / O $ 5 d s yandmarkList: View {
@EnvironmentObject private var userData: UserData
var body: some View {
Text("")
}

@EnviromeS y g f O V v Lnt

前面说到的环境信息一般是指用户自界a 9 I o u v说同享信息，可是一起体系存在许多的内置环境信息，如时区，色彩形式等，能+ . P % 0够直接订阅体系的环境信息，使得 SwiftUI 主动获取到环境信息的改变，主动刷新布局。

struct CalendarView: View {
@Environment(\.calendar) var cale4 U D A ?ndar: Calendar8 j E W 3 %
@Env` R ciro] Y 1 G n : ]nmen4 m ct(H e O E B\.locale) var lo5 R $ . f L J /cale: Locale
@EnE E J l 0 6vironment(\.colorSc4 8 T [ s [ ? /heme) var colorScheme: ColorScf H ?heme
var body: some View {
return Text(locale.identifier)
}
}

总结[ [ F ] o `

以上是 SwiftUI 官方在各种教程和 WWDC session 说到的数据流办理计划，总结下来是以下几点：

1、关于@ a U不变的常量直接传递给 SwiftUI 即可。

2、关于控件上需求办理的状况运用 @State 办理。

3、关于外部的事情改变运用 BindableObject 发送告诉。

4、关于需求同享的视图可变数据运用 @ObjectBinding 办理。

5、不要呈现多个8 * 7 q状况同步办理，运用 @Binding 同享一个 Source of truth。

6、关于体系环境运用 @Enviroment 办理。

7、关于需求同享的不行变数据运用 @EnviromemntObject 办理。

8、@Binding 具有引证语义，能6 ~ k n v够很好的和 @Binding @objectBindingE x t [ S [ @State 协作，防止呈现多个数据不同步。

SwiftUI 的布局算法

信任许多人看过 Swift= v , F |UI 后对 SwiftUI 内部G 2 Q N T ?的布局算法是比较猎奇的，在 Session 237 Building Custom ViZ W Lews wi( * K ? 8 H Wth Swt u lifta S w F Z N jUI 摘要介绍了一下。 SwiftUI= / ` _ 会经J d s过 body 的i N #回来值获取描绘视图的控件信息，转换为对应的内部视图信息，交给 24 @ U K ; 0D 绘图引擎 Metal 或许 Open GL 绘制，其间比较复杂的 Toggle 或许引证自原本的UIKit完成。

Content View

关于以下的代码：

import SwiftUI
struct ContenZ # btView : View {
var body: some View {p U F i S
Text("Hello World!")
}
}

它们的结构是如下的 RootView -> ContentView -> T~ ] h Next, 那么 Text 是怎M , % G u _么呈现在屏幕上的？官方的介绍是如下三个过程

1、父视图为子视图供给预估尺度
2、子] v X | [ N视图核算自己的实践尺度
3、父视图依据子视图的尺度将子视图放在本身的坐标系中

比较重要的是第二步，关于一个视图描绘，一G U P v c X 3 / 6般有三种设置尺度的办$ e g 4法。

1、无需核算，依据内容揣度，如 Image 是和图片等大，Text 是核算出来的P k l : h !可视范围，相似 NSString 依据字体核算宽高。^ B p 9

2、Frame 强制指定宽高

3、设置缩放份额 如 Image 设置 aspectRatio。

趁便苹果提了一点 SwiftUI 中将核算出{ F g f N p的含糊坐标点) 8 G t d ` 7会对齐到清晰的像素点，防止呈现锯齿感。

那么关于运用 Modifier 的布局结构如下：

import Sw- x ` # [ : QiftUI
struct ContentViewi $ - ] ! V c | o : Vie& a 9 J - yw {
var body: some View {
Text("Hello Worldr V : * ` J 0 V Y!")
.paddiD 7 # A 9 y + ?ng(10)
.background(Color.Green)
}
}
struct Avocado : ViS f ;  2ew {
var body: some View {
ImQ @ oage("20x20_avocado3 P A")
.frame(width: 30, height: 30)
}
}

看上去它们 Frame 和 BackgrounK A F G H 5d Padding 等元素都呈现_ l N 0 R $ Z在了视图结构中，但它们其实都是 View 的约束信息，并不是真正的 View。

HStack/, i Q 3 .VStd $ ;ack

HStaf U 3 j u 7 m # %ck 和 ZStack 的十分相似安卓的 LinerLayout，算法也同 Ff V T 4 , E J ~lex 布局比较相似。 关于如下的布局, 苹果都会在控件之间增加上契合苹果人机交互攻略的距离，保证 UI 的优雅和共同性。

HStack {
VStack {@ 4 0 7 ` u
Text("★★★★★")
Text("5 stars")
}0 O R { M d
.font(.caption)
VStack {
HStack {
Text("AV p N ? L $ b ovocado Toast").font(.title)
Spacer()
Image("20x20_avocado")
}
Text("Ingredients: Avocado, Almond Butter, Bread, Red Pepper Flakes")
.font(.caption)
.lineLimit(1)
}
}

关于如上的 Stack 是怎样核算的？设 Stack 主轴方向长度为 W1。

1、依据人机交互攻略的预留出边距 S, 边距依据元素的摆放或许有多个
2、得到剩余的主轴宽度 W2= W1 - N * S
3、平均分配一个预估宽度
4、核算一些具有清晰宽高的元素 如 Image 设置了 Frame的元素的等。
5、沿主轴方向早年# v ^ ? ? ! I到后核算，，假如核算出来| a W h } % z的宽度小于预估宽度则正常显现，不行则截断l - C a &。
6、最终的元素为剩余y w ~ $ * k & [宽度，假如不行显现则阶段
7、默许的交叉轴对齐办法为 Center，Stack 占有包括最大元素的边x ` g : } +界。

默许的核算是次序核算布局，假如某些元素比较重要，能够运用 Lm * / 6ayoutPriority Modifier 进步布局优先级防止呈现视图截断。

交叉轴对齐办法

许多时分咱们开发布局体系会嵌套许多 HStack 和 ZStack 有时分咱们除了内部对齐，还有按照自界说的对齐份额的对齐。

extension VerticalAlignment {
public static let top: VerticH E ,alAlignment
public static let center: VerticalAlignment
public static let bottom: VerticalAls | 7 t D S ` yignment
pubZ [ [  p `lic static let firstTextBaseline: VerticalAlignment
public static let lastTextBaseli9 x k } [ne: VerticalAlignment
}
extension Horizon4 [ 5 P f o italAlignment {
public static let leading: HorizontalAlignment
public static let center: HorizontalAlignment
public sta$ / , W X Oti% : + = ! $ = k #c let trailing: HorizontalAlignment
}
extension VerticalAlignment {
privp J e = , } . q Iate enum MidStarAndTitle: AlignmentID {
static func defaultValue(in d: ViewDio P y O }mensions+ n 7 q o) -> Length {
return d[.bottom]
}
}
static let midStarAndTitle = VerticalAligT 5  %nment(MidStaX  } . ~ YrAndTitle.self)
}
// 自界说对齐办法
HStack(alignment: .midStarAndTitl+ f K q u m 5 {e) {
VStack {
Text("★★★★★")
Text("5 stars")
}
.font(.caption)
VStack {
HStack {
Text("Avocado Toast")@ y : o : h =.font(.title)
Spacer()
Image("20x20_avocado")
}
Text("II C & V u h h ^ :ngredients: Avocado, Almond Butter, Bread, Red Pepper Flakes")
.font(.caption)
.lineLimit(1)
}
}

ZStack

除了 HStack 和 VStack 还有 ZStack, ZStack 的* o L 8 4 [ 1 C布局办法相似绝对定位， 在 UIKit 中相似 向一个 View 增加不同的 SubView。

VStack {
Text("HellE o $ 2 u U Z o 4o")
Text("World").padding(10)o 2 + % N Q p g;
}

VStack 的对齐办法组合自水平缓垂直方向。

public struct Alignment : Equatable {
public var horizontal: HorizontalAlignment
public var vertical: VerticalAlignment
@inl5 U _ A n L ainablF ) 8e public init(j & x w _ v . Hhorizontal^ 5 Z c A C F v: HorizontalAlignment, vertical: VerticalAlignment)
public sta~ X ktic let center: Alignment
public staticO A m 5 9 _ let leading: Alignment
public static let trailing: Alignment
public stati_ S z F . & / $c let top: Alignment
public static let bottom: Alignment
public static let topLeadingk M I 2 ( ` ? 4: Alignment
public static let topTrailing: Alignment
public static let bottomLeadib f  ; z z U [ Kng: Alignment
public static let bottomTrailing: Alignmz d g | Y & ^ent
public static func == (a: Alignment, b: Alignment) -> Bool
}

Shape in SwiftUI

在 SwiftUI 中绘图相似之前运用 UIBezierPath 的 API，只需求完成 Sh3 1 k 5 g ? A 8 )ap} 9 e z l g w D )e 的描绘信息即可这儿就不多赘述了。

struct WedgeShape: Shape {& 1 q 6 )
var wedge: Ring.Wedge
func path(in rect:6 N P Q I e O 9 n CGRect) -> Pat/ p , #h {
var p = Path()
let g = WedgeGeometry(wedge, in: rect)
pg g 8 a y t [ 9.addArc(center: g.5 & a y ~ ,cen, radius: g.r0, startAngle: g.a0, endAngle: gf o % s $ _ u.a1, clockwise: false)
p.addLine(to: g.topRight)
p.addArc(center: g.cen, radius: g.r1, startAngle: g.a1, endAngle: g.a0, clockwis$ L t He: true)X V i P 8 W
p.closeSubpath()
return p
}
}

SwiftU5 J 6 L ( : ]I 混合布局

许多现有的 APP 许多的运用 Cocoa 传统的指令式 UI 布局办法，即使不用兼容 iOS 13.x 以下直接引入 SwiftUI，也是不行能悉数改造为 SwiftUI，必然会存在较长时刻的混合编程。 苹果现已考虑到这点，而且供给了十分简略的办法供混合编程。

UIKit 嵌入 SwiftUI View

这个是最为常见的场景 SwiftUI 供给了 UI/NS/WKHosti1 O M H | @ q [ tngController 包装一个 SwiftUI View，而且供给了关于的视图更新机遇 setNeedsBodyUpdate+ Y y = * X k updateBodyIfNe] J C T B = y 9eded

SwiftUI View 嵌& A O 6入 UIKit View

开发者现已封装好了许多可用的视图组件，能够直接嵌入到 SwiftUI 中无缝开发。

这块就不做过多解说了，这部分的代码和机遇分成清晰。 Demo 能够L J V参阅 Session 231 integrating swiftui （de~ A u 2 xvelopX , o er.apple.com/videosZ ^ 5 $ B U 5/play…

SwiftUI On All Device

在前文 《新晋网红SwiftUI——淘宝带你初体m R I u 9 u会》说到，苹果考虑的跨渠道不是像 RN Flutter Weex 的跨手机操作体系渠道，而是跨 TV Watch Mac iPad 渠道，所以理v I 2 y R y p I念也不共同，苹果特意指出针对不同的设备，是没有一种办法，能全能的适配到一切设备上。 假如有必然回抹掉许多渠道特有的体会，这尽管对开发者友爱，但不见得对用户是一件功德，苹t b [ G m 7果指出了针对多设备的规划理念。

1、针对对应的渠道选择对应的合适的规划
2、仔细剖析同享模块的规划
3、同享视图是个有风险的行为，要考虑的更加深入
4、Learn once apply anyware.

在 SA ! b T 7wiftUI 中开发者描绘的视图层只是数据的界说和描绘， SwiftUI 结构内部现已做的足够多，6 / 3 I 8 ~ + K信任学习了 SwiftUI 能够容易地在其他渠道上开端开发。 关于更多细节请参阅 Sesu i %sion 240 SwiftUI on all Device 和 Session 219 SwiftUI on watchOS （developd [ l /er.apple.com/videos/play…

accessibility in SwiftUI

本年 SwiftUI 也充分考虑了无障碍拜访功用，不得不说苹果C L是十分有人性化的公司? X * $ K 7，SwiftUIb _ i g ^ E T 4 v 给无障碍开发减少了许多的工作量。不过作者对这方面了解甚少，就不误导各位读者了， 详细的我们能够参阅 Sessioe Q } @n 238 accessibility in swiftui。（developer.apple.com/videos/play…

本文参阅{ $ C } – u J J：

1、SE-0255 omit-return
（https://github.com/apple/Swift-evolution/blob/master# S o O ( h U  #/pro6 ? * j Qposals/0255-omit-return.md）
2、SE-0242 defa. 8 V ? T ?ult-values-memberwise
（https://e 2 w $ o Pgithub.com/apple/Swift-evolutio% V ? 6n/blob/master/proposals/0242p { L-default-values9 V C = S L H G-memberwise.md）
3、SE-0228 expressiblebystringinterpolation
（https://ga ? ` 9 U ; 7 G qithub.com/apple/Swift-evolution/blob/master/t c M Q wproposals/0228-fix-expressibleQ + # i r 4bi $ E D )ystringinterpolation.md）
4、SE-0258 property-wrapper3 Q k 1 j T Ds
（https://github.com/apple/swift-evolution/bY s $ a $ Blob/master/proposals/0258-property-wrappers.md）
5、fuG o # & ( *nction-builders.md
（https://github.com/apple/swift-evolution/blob/9992cf3c11c2d5e0ea20bee98657d93902d5b17w r =4/proposals/XXXX-function-builders.md）
6、swift-evolution
（http{ k B M Q 6 | 7 qs://github.com/applec h L/swift-evolution/tree/master/pf @ cr{ ? l ~ Qoposals）
7、Attribute大全
（https://docs.swift.org/sw6 ) _ Z B @ift-book/ReferD X ? c T J jenc8 I p ~ 5 c j WeManual/Attributes.html）
8、Inside. H ( { ] Y P q SwiftUI's Declarativ* | ce Syntax's Compiler Magic
（https://swiftrocks.com/inside-swiftui-compiler-magic.html）
9、Session402
（https:/[ ? ; T Y/developer.applp c * 2e.com/videos/play/wwdc2019/402/）
10、API Design GuideLio j p $ + x d . kne
（https://swift.org/documentation/api-design-guidelines/）
11、新晋网红Si U z k 8wiftUI——淘宝带你初体会
12、Session415
（https://developer.apple.com/videos/play/wwdc2019/415）
13、声明式编程
（https://zh.wikipedia.org/wiki/%E5%AE%A3%E5% r .91%8A%E5%BC%8F%E7%B7%A8%E7%A8%8B）
14、指令式编程
（https://zh.m.wikipedia.org/zh-my/% n : Z H V 5 K -E6%8C%87%E4%BB%A4%E5%BC%8F%E7%B7%A8%E7%A8%8B）
15、understanding-property-wrappers-in-swM L ^ o U 6 8 uiftui
（https://mecid.github.io/2019/06/12/understanding-propero # # X s V k n gty-wrappers-in-swiftui* h 9 U/）
16、Session 402 What's New in@ K S [ Swift
（https://developer.apple.a S * Ncom/videos/play/wwdc2019/402/）
17、~ , A # O *Session 204 Introducing SwiftUI: Building Your F0 l X p ! $ Y virst App
（https://develope1 c L / ^r.apple.com/T @ 7 7 Avideos/play/wwdc2019/204/）
18、Sessio4 m R 4 c s U Xn 216 Introducing SwiftUI Essentials
（https://developer.apple.com/videos/play/wwdc2019/216/）
19、Session 226 SwiftUI Essentials Y U D ] 4 x
（https://developer.apple.com/videos/play/wwdc2019/226/）
20、Session 231 Integrating SwiftUI
（https://developer.apple.com/videos/play/w] N = 9 ,wdc2019/226/）
21、Session 237 Building Custom Views with SwiftUI
（https://developer.apple.com/videos/pla. e Eyn m R V/wwdc2019/231/）
22、Session 23. P - 3 q P % * G8 accessibility in swiftui
（https://developer.apple.com/videos/play/wwdc2019/238/）
2e t G ` K3、Session 240 SwiftUI on all Device
（https://developer.apple.com/videq M Sos/play/wwdc2019/240/）
24、Session 219 SwiftUI on w? P E 6atchOS
（https://developer.apple.com/videos/play/wwdc2019/219/）
25、Session 415 Modep } 4 h V C ; Q Arn Swift API Design
（https://developer.apple.com/videos/play/wwdc27 5 c !019/415/）
26、30 分钟学会 Flex 布局
（https://zhuanlan.zhihu.com/p/25303493）