Swift

Swift 作为一门现代语言，除去安全，快速等特性之外，还有个明显有别于其他语言的特性，就是巨量细致入微的语言特性。类似iOS API，初学者觉得繁杂，无从下手，但是熟悉之后，绝对能少写不少代码。

其中强大的模式匹配绝对让你用的很爽。

主要整理自：<a href="https://www.swiftbysundell.com/articles/pattern-matching-in-swift/#iterative-patterns">pattern-matching-in-swift</a>

我们经常会在<code class="inline-code">for</code>循环中，使用<code class="inline-code">if</code>判断。

func deleteMarkedMessages() {
    for message in messages {
        if message.isMarked {
            database.delete(message)
        }
    }
}

上面绝对能工作，你可能会使用函数式的写法。

func deleteMarkedMessages() {
    messages.filter { $0.isMarked }
            .forEach(database.delete)
}

上述可能需要团队熟悉函数式编程，而且整个数组会经过两遍处理。

而Swift中<code class="inline-code">where</code>判断，则是此类情况的绝佳解决方案。

func deleteMarkedMessages() {
    for message in messages where message.isMarked {
        database.delete(message)
    }
}

而对于Swift Optional数据来说，例如类似的数据结构：

struct Match {
    var startDate: Date
    var players: [Player?]
}

假设我们需要循环<code class="inline-code">players</code>，且需要排除<code class="inline-code">nil</code>的值，我们可以使用传统的<code class="inline-code">if</code>判断，或者使用函数式的，<code class="inline-code">compactMap</code>函数。但是在Swift中有个更高阶的方法，使用<code class="inline-code">for case let</code>语法。

func makePlayerListView(for players: [Player?]) -> UIView {
    let view = PlayerListView()

    for case let player? in players {
        view.addEntryForPlayer(named: player.name,
                               image: player.image)
    }

    return view
}

这个乍看很奇怪，一般只会在<code class="inline-code">switch</code>和<code class="inline-code">enum</code>声明中才能看到case。但是实际上，swift中optional值底层是<code class="inline-code">Optional&lt;Wrapped&gt;</code>的枚举<code class="inline-code">enum</code>，而且swift的模式匹配不是只在<code class="inline-code">switch</code>下才能工作。

enum LoadingState {
    case loading
    case failed(Error)
}

在无状态的情况下，我们使用可选optional的<code class="inline-code">LoadingState?</code>，在<code class="inline-code">switch</code>匹配中，我们同样可以将<code class="inline-code">?</code> 使用在case的情况，以此来匹配有值的情况。

extension ContentViewController: ViewModelDelegate {
    func viewModel(_ viewModel: ViewModel,
                   loadingStateDidChangeTo state: LoadingState?) {
        switch state {
        case nil:
            removeLoadingSpinner()
            removeErrorView()
            renderContent()
        case .loading?:
            removeErrorView()
            showLoadingSpinner()
        case .failed(let error)?:
            removeLoadingSpinner()
            showErrorView(for: error)
        }
    }
}

错误处理，特别是http错误处理通常挺复杂的，一大堆if else代码。而在swift的强大的模式匹配下，我们可以写出声明式的代码。

func handle(_ error: Error) {
    switch error {
    // Matching against a group of offline-related errors:
    case URLError.notConnectedToInternet,
         URLError.networkConnectionLost,
         URLError.cannotLoadFromNetwork:
        showOfflineView()
    // Matching against a specific error:
    case let error as HTTPError where error == .unauthorized:
        logOut()
    // Matching against our networking error type:
    case is HTTPError:
        showNetworkErrorView()
    // Fallback for other kinds of errors:
    default:
        showGenericErrorView(for: error)
    }
}

模式匹配底层逻辑，以及自定义模式匹配

&nbsp;Swift中模式匹配部分依赖变量相关语法(例如case let)， 这里值和模式匹配的真正逻辑并没有到编译那一步，甚至也不是语言语法，类似很多貌似“底层”的特性其实是在标准库中通过常规的Swift 代码来实现。

具体，Swift使用重载<code class="inline-code">～=</code>运算符号来实现模式匹配——这也就就给了我们自定义模式匹配的方法。

类似上面的判断错误，使用<code class="inline-code">～=</code>运算符号重载

func ~=<E: Error & Equatable>(rhs: E, lhs: Error) -> Bool {
 return (lhs as? E) == rhs
}

这样，上述的switch case写起来更简洁。

func handle(_ error: Error) {
    switch error {
    case URLError.notConnectedToInternet,
         URLError.networkConnectionLost,
         URLError.cannotLoadFromNetwork:
        showOfflineView()
    case HTTPError.unauthorized:
        logOut()
    case is HTTPError:
        showNetworkErrorView()
    default:
        showGenericErrorView(for: error)
    }
}

swift 模式匹配很强大，无疑会减少不少代码，不过里面高级的玩法确实看起来容易费解，这点可能就是swift 这门语言让人又爱又恨的地方。

从我角度来说，我喜欢这种复杂度，可玩性更高～^-^～。

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：<a href="https://cloud.tencent.com/developer/support-plan?invite_code=s4vceg07lp5g">https://cloud.tencent.com/developer/support-plan?invite_code=s4vceg07lp5g</a>

Swift中的模式匹配

blog

Next.js + 腾讯云开发Webify 打造绝佳网站

## Next.js酷在哪里？

之前使用[Next.js](https://nextjs.org/) + [strapi](https://strapi.io)做了一个简单博客站点也顺道写了一篇[Next.js 简明教程](https://hicc.pro/p/blog/nextjs)，之后Next本身一直在迅猛发展。利用现代js能力来说做到了：

- 极佳的开发体验
- 极佳的网站最佳的”动“，“静”平衡

从特性上来说，支持：
- SSR(Server Side Rendering)
	- 提供`getServerSideProps`方法，在用户访问时请求数据，适用于实时数据页面。
- SSG(Static Site Generation)
	- 提供`getStaticProps`，`getStaticPaths`方法来预先生产静态页面
	- 而更酷的一点是：**使用fallback，revalidate来支持一定的动态性**

这种能“动”的SSG自然是我所需要的，保持静态访问，而又能在我新增修改文章的时候，站点能够自动更新。绝佳！！

## 为什么还需要Webify来折腾一番？

既然上面已经很酷了，为什么会有今天的文章，为什么还需要折腾一番？

原因也很简单：**成本略高**，为了不错的访问速度，你需要一台性能不错的虚拟机，一定的带宽。对于一般个人博客，投入不划算。

在这里就隆重地有请我们的解决方案：[腾讯云开发Webify](https://cloud.tencent.com/product/webify)，简单来说就是类似vercel的serverless 服务托管服务，不过支持更多的框架，而且是国内服务商，**便宜**且**访问速度一流**。

有图为证：
[![腾讯云官方数据](https://image.hicc.pro/pro/20210905030848Fq9LgNWnG9Fvnf2xM4UVE8N1PDz0Eilr1UBN49KGJHQi3Yflu.png)](https://webify.cloudbase.net/blog/personal-site-plan)


[![hicc.pro部署在webify上](https://image.hicc.pro/pro/20210904003932Fn3pAdwDf7bOwA-lhR71R3rGWBgcWT-iCLgkLn9MBR0a5kedv.png)](https://www.boce.com/http/hicc.pro/af92134fc4947b5d1de25977b3839cd3.html)

## tcb Webify使用

对于一般文章使用类似github管理的就简单了，tcb Webify支持版本github，gitlab，gitee服务商，适配了：
- Vue.js (vue-cli)
- React.js (create-react-app)
- Hexo
- Gatsby.js
- Angular
- Next.js SSG
- Nuxt.js SSG
- 以及[自动适配框架](https://webify.cloudbase.net/blog/framework-detection)。

以本博客next为例，Webify实际上使用时了next export的能力，构建后，直接部署静态文件到server。

如果你的博客文章，直接使用md，git管理，看到这里就OK了，git 提交，Webify自动会重新部署你的站点。cool～～

问题是如果你的站点数据来源于类似strapi这种serverless cms怎么办？next export 不支持next SSG中“动”的特性（`fallback`，`revalidate`）。

## Webify高阶——自动化Webify

其实方法也很简单，加一个桥接服务，让你的serverless cms的更新变动到git就好。

具体以strapi为例子

1. strapi 数据发布
2. web hook到自定义的桥接服务。
3. 桥接服务更新站点git。
4. Weify触发重新部署。

*当然如果后续webify支持更多的重新部署方式，这里会更简单一点。*

这样乍看，似乎又回到了原点，我们还是需要一台服务器，这里又要引入本文的另一个嘉宾了，tcb 云函数。**上述这种按需调用的服务，使用云函数最合适了**，你不需要一个一直开机的虚拟机，你只需要在更新文章时候才需要唤起云函数就好，随用随停，成本低廉。

按照本博客的场景，我们让桥接服务在运行的时候，自动生成站点的sitemap到github来一举两得。


- 用来[sitemap](https://www.npmjs.com/package/sitemap)生成站点地图xml
- 使用[@octokit/rest](https://www.npmjs.com/package/@octokit/rest)，[@octokit/plugin-create-or-update-text-file](https://www.npmjs.com/package/@octokit/plugin-create-or-update-text-file)来更新github中文件。
- 
下面是精简过的代码：

### 生成站点地图sitemap.xml
```javascript
const {
 SitemapStream,
 streamToPromise
} = require('sitemap')
const {
 Readable,
 Transform,
 pipeline
} = require('stream')
const {
 apiRequest,
 getPostsWithGraphql
} = require('./request')
const PaginationLimit = 30
module.exports = ({
 hostname,
 cmsUrl
}) => {

 async function getPostSitemap() {
 const smStream = new SitemapStream({
 hostname,
 });
 let page = 0;
 const postStream = new Readable({
 objectMode: true,
 async read(size) {
 const result = await getPostsWithGraphql(`${cmsUrl}/graphql`, page++, PaginationLimit);
 if (result.error || !Array.isArray(result.data.posts)) {
 this.push(null);
 } else {
 result.data.posts.forEach((item) => {
 this.push(item);
 });
 if (result.data.posts.length < PaginationLimit) {
 this.push(null);
 }
 }
 },
 });

 const trans = new Transform({
 objectMode: true,
 transform(data, encoding, callback) {
 callback(null, {
 url: `/p/${data.book.slug || data.book.uuid}/${
							data.slug || data.uuid
						}`,
 changefreq: 'daily',
 priority: 1,
 lastmod: new Date(data.updated_at),
 });
 },
 });

 const buffer = await streamToPromise(pipeline(postStream, trans, smStream, (e) => {
 // throw e;
 }))
 return {
 path: 'public/sitemap.xml',
 content: buffer.toString()
 }
 }
		
		return Promise.all([
 // getHomeSitemap(),
 // getBookSitemap(),
 getPostSitemap()
 ])
}
```

### 更新Github中文件
```javascript
'use strict';
const {
 Octokit
} = require("@octokit/rest");
const {
 createOrUpdateTextFile,
} = require("@octokit/plugin-create-or-update-text-file");
const {
 throttling
} = require("@octokit/plugin-throttling");
const getSitemaps = require('./sitemap')

const MyOctokit = Octokit.plugin(createOrUpdateTextFile, throttling);

exports.main = async (event, context) => {
 const {
 headers: {
 authorization,
 'x-strapi-event': strapiEvent
 },
 body
 } = event;
 const {
 model,
 entry
 } = JSON.parse(body)
 const {
 CMS_TOKEN,
 GITHUB_ACCESS_TOKEN,
 BLOG_URL = 'https://hicc.pro',
 CMS_URL = 'https://cms.hicc.pro'
 } = process.env;
 // strapi 上添加密钥来确保安全
 if (CMS_TOKEN !== authorization) {
 return {
 doTrigger: false
 }
 }
 let doTrigger = false // TODO: 识别真正的发布
 const siteMaps = await getSitemaps({
 hostname: BLOG_URL,
 cmsUrl: CMS_URL
 })

 const octokit = new MyOctokit({
 auth: GITHUB_ACCESS_TOKEN,
 throttle: {
 onRateLimit: (retryAfter, options) => {
 console.warn(
 `Request quota exhausted for request ${options.method} ${options.url}`
 );

 // Retry twice after hitting a rate limit error, then give up
 if (options.request.retryCount <= 2) {
 console.log(`Retrying after ${retryAfter} seconds!`);
 return true;
 }
 },
 onAbuseLimit: (retryAfter, options) => {
 // does not retry, only logs a warning
 console.warn(
 `Abuse detected for request ${options.method} ${options.url}`
 );
 },
 },
 });
 await Promise.all(siteMaps.map(({
 path,
 content
 }) => {
 return octokit.createOrUpdateTextFile({
 // replace the owner and email with your own details
 owner: "xxx",
 repo: "xxx",
 path,
 message: `feat: update ${path} programatically`,
 content: content,
 branch: 'master',
 sha: '',
 committer: {
 name: "xxx",
 email: "xxxx@outlook.com",
 },
 author: {
 name: "xxx",
 email: "xxxx@outlook.com",
 },
 })
 }))


 return {
 doTrigger
 }
};
```

WWDC21上发布了Swift 5.5，虽然是小版本，但是特性不少……

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0296-async-await.md">SE-0296</a>提案终于为开发者带来了期待已久的 <code class="inline-code">async</code>/<code class="inline-code">await</code>，语法基本上和javascript中的很像。

func fetchWeatherHistory(completion: @escaping ([Double]) -> Void) {
    // Complex networking code here; we'll just send back 100,000 random temperatures
    DispatchQueue.global().async {
        let results = (1...100_000).map { _ in Double.random(in: -10...30) }
        completion(results)
    }
}

func calculateAverageTemperature(for records: [Double], completion: @escaping (Double) -> Void) {
    // Sum our array then divide by the array size
    DispatchQueue.global().async {
        let total = records.reduce(0, +)
        let average = total / Double(records.count)
        completion(average)
    }
}

func upload(result: Double, completion: @escaping (String) -> Void) {
    // More complex networking code; we'll just send back "OK"
    DispatchQueue.global().async {
        completion("OK")
    }
}

fetchWeatherHistory { records in
    calculateAverageTemperature(for: records) { average in
        upload(result: average) { response in
            print("Server response: \(response)")
        }
    }
}

func fetchWeatherHistory() async -> [Double] {
    (1...100_000).map { _ in Double.random(in: -10...30) }
}

func calculateAverageTemperature(for records: [Double]) async -> Double {
    let total = records.reduce(0, +)
    let average = total / Double(records.count)
    return average
}

func upload(result: Double) async -> String {
    "OK"
}

func processWeather() async {
    let records = await fetchWeatherHistory()
    let average = await calculateAverageTemperature(for: records)
    let response = await upload(result: average)
    print("Server response: \(response)")
}

swift 5.5 async 函数也可以像普通函数一样抛出错误 <code class="inline-code">async throws</code>。

enum UserError: Error {
    case invalidCount, dataTooLong
}

func fetchUsers(count: Int) async throws -> [String] {
    if count > 3 {
        // Don't attempt to fetch too many users
        throw UserError.invalidCount
    }

    // Complex networking code here; we'll just send back up to `count` users
    return Array(["Antoni", "Karamo", "Tan"].prefix(count))
}

func save(users: [String]) async throws -> String {
    let savedUsers = users.joined(separator: ",")

    if savedUsers.count > 32 {
        throw UserError.dataTooLong
    } else {
        // Actual saving code would go here
        return "Saved \(savedUsers)!"
    }
}

func updateUsers() async {
    do {
        let users = try await fetchUsers(count: 3)
        let result = try await save(users: users)
        print(result)
    } catch {
        print("Oops!")
    }
}

函数加上<code class="inline-code">async</code> 并不会自动并行 <code class="inline-code">concurrency</code>

现在(2021-7-25)之前，暂时还没有明显优雅的方式在playground中执行async / await 代码。参考<a href="https://github.com/kishikawakatsumi/swift-playground/discussions/101">这里</a>，可以这样执行：

import Foundation

struct Main {
  static func main() async {
    await doSomething()
  }

  static func doSomething() async {
    print("doSomething")
  }
}


Task.detached {
  await Main.main()
  exit(EXIT_SUCCESS)
}
RunLoop.main.run()

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0298-asyncsequence.md">SE-0298</a>提案为swift 引入了<code class="inline-code">AsyncSequence</code> protocol，循环异步队列。

使用<code class="inline-code">AsyncSequence</code>&nbsp;使用和<code class="inline-code">Sequence</code>几乎一样。需要遵循<code class="inline-code">AsyncSequence</code>和<code class="inline-code">AsyncIterator</code>，当然<code class="inline-code">next()</code>方法需要时异步<code class="inline-code">async</code>的，和<code class="inline-code">Sequence</code>一样，迭代结束确认返回<code class="inline-code">nil</code>。

struct DoubleGenerator: AsyncSequence {
 typealias Element = Int

 struct AsyncIterator: AsyncIteratorProtocol {
 var current = 1

 mutating func next() async -> Int? {
 defer { current &*= 2 }

 if current < 0 {
 return nil
 } else {
 return current
 }
 }
 }

 func makeAsyncIterator() -> AsyncIterator {
 AsyncIterator()
 }
}

运行也是常见的<code class="inline-code"> for await </code>语法。

func printAllDoubles() async {
    for await number in DoubleGenerator() {
        print(number)
    }
}

更高级的是，<code class="inline-code">AsyncSequence</code>协议提供了一些常用的方法，像<code class="inline-code">map()</code>， <code class="inline-code">compactMap()</code>, <code class="inline-code">allSatisfy()</code>等

func containsExactNumber() async {
    let doubles = DoubleGenerator()
    let match = await doubles.contains(16_777_216)
    print(match)
}

SE-0310提案升级了swift的只读属性，让其支持了async和throws。

enum FileError: Error {
    case missing, unreadable
}

struct BundleFile {
    let filename: String

    var contents: String {
        get async throws {
            guard let url = Bundle.main.url(forResource: filename, withExtension: nil) else {
                throw FileError.missing
            }

            do {
                return try String(contentsOf: url)
            } catch {
                throw FileError.unreadable
            }
        }
    }
}

func printHighScores() async throws {
    let file = BundleFile(filename: "highscores")
    try await print(file.contents)
}

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0304-structured-concurrency.md">SE-0304</a>在async / await 和async sequence的基础上为swift 引入了一整套的并发的执行，取消，监控的方法。

为了更好说明，我们先假设这两个情况

enum LocationError: Error {
 case unknown
}

func getWeatherReadings(for location: String) async throws -> [Double] {
 switch location {
 case "London":
 return (1...100).map { _ in Double.random(in: 6...26) }
 case "Rome":
 return (1...100).map { _ in Double.random(in: 10...32) }
 case "San Francisco":
 return (1...100).map { _ in Double.random(in: 12...20) }
 default:
 throw LocationError.unknown
 }
}

func fibonacci(of number: Int) -> Int {
 var first = 0
 var second = 1

 for _ in 0..<number {
 let previous = first
 first = second
 second = previous + first
 }

 return first
}

在swift的项目中，可以这么执行(如果在playground文件中，可以使用上文的方法)

@main
struct Main {
    static func main() async throws {
        let readings = try await getWeatherReadings(for: "London")
        print("Readings are: \(readings)")
    }
}

结构化并发，实际上是引入了两个类型，<code class="inline-code">Task</code>和<code class="inline-code">TaskGroup</code>来，独立或者协同地运行并发代码。

简单来说，你只要将异步代码传入<code class="inline-code">Task</code>对象，就会立即在background 线程上运行，然后你用<code class="inline-code">await</code>等待结果就好。

func printFibonacciSequence() async {
 let task1 = Task { () -> [Int] in
 var numbers = [Int]()

 for i in 0..<50 {
 let result = fibonacci(of: i)
 numbers.append(result)
 }

 return numbers
 }

 let result1 = await task1.value
 print("The first 50 numbers in the Fibonacci sequence are: \(result1)")
}

需要注意，代码中明确指定了<code class="inline-code">Task { () -&gt; [Int] in </code>这样，Swift就会知道task需要返回，而如果你的异步代码比较简单，可以像下面这样写：

let task1 = Task {
 (0..<50).map(fibonacci)
}

再次，task会在创建之后立即运行，但是在斐波那契函数得到结果之后，，<code><code class="inline-code">printFibonacciSequence()</code></code>函数会继续运行在原来的线程。

<code class="inline-code">task</code>参数属于non-escaping 闭包

上述函数中，通过<code class="inline-code">await task.value</code>来获取task的值，如果你不关心task 返回的值，你也不需要存储task。

对于会抛出错误的异步任务，从task的<code class="inline-code">value</code>取值，也会触发错误，因此仍然需要<code class="inline-code">try await</code>。

func runMultipleCalculations() async throws {
 let task1 = Task {
 (0..<50).map(fibonacci)
 }

 let task2 = Task {
 try await getWeatherReadings(for: "Rome")
 }

 let result1 = await task1.value
 let result2 = try await task2.value
 print("The first 50 numbers in the Fibonacci sequence are: \(result1)")
 print("Rome weather readings are: \(result2)")
}

Swift为task内置了几种优先级<code class="inline-code">high</code>， <code class="inline-code">default</code>，<code class="inline-code">low</code>和<code class="inline-code">background</code>。如果未指定，会默认设置为<code class="inline-code">default</code>，当然你可以显式指定Task(priority: .high)。当然如果你在Apple的平台上，你会使用很熟悉的优先级，<code class="inline-code">userInitiated</code>对应<code class="inline-code">high</code>，<code class="inline-code">utility</code>对应<code class="inline-code">low</code>，当然你不能使用<code class="inline-code">userInteractive</code>，它是为主线程保留的。

当然，Task也为我们提供了几个静态的方法。

func cancelSleepingTask() async {
    let task = Task { () -> String in
        print("Starting")
        await Task.sleep(1_000_000_000)
        try Task.checkCancellation()
        return "Done"
    }

    // The task has started, but we'll cancel it while it sleeps
    task.cancel()

    do {
        let result = try await task.value
        print("Result: \(result)")
    } catch {
        print("Task was cancelled.")
    }
}

上述代码中，<code><code class="inline-code">Task.checkCancellation()</code>会检测到task已经被取消了，会立即跑出<code class="inline-code">CancellationError</code>的错误，当然只有在尝试<code class="inline-code">task.value</code>取值的时候，才会抛出。</code>

使用<code class="inline-code">task.result</code>来获取到<code class="inline-code">Result</code>类型的值

对于复杂的任务，可以使用 task group来组织更多的task。

func printMessage() async {
    let string = await withTaskGroup(of: String.self) { group -> String in
        group.async { "Hello" }
        group.async { "From" }
        group.async { "A" }
        group.async { "Task" }
        group.async { "Group" }

        var collected = [String]()

        for await value in group {
            collected.append(value)
        }

        return collected.joined(separator: " ")
    }

    print(string)
}


不要将<code class="inline-code">withTaskGroup</code>里面的代码复制到外面，编辑不会报错，但是自然会有潜在的问题。

所有task group中的任务应该返回同样的数据类型。复杂情况，你可能需要一个有associated值的enum来准确取值，当然你还可以使用async let 绑定的替代方案。

task group的值需要所有的task都完成，但是每个task执行完顺序是不保证的。

你可以在task group中处理错误，或者你可以使用<code class="inline-code">withThrowingTaskGroup()</code>把错误抛出，这样也就需要<code class="inline-code">try</code>的方式来取值。

func printAllWeatherReadings() async {
    do {
        print("Calculating average weather…")

        let result = try await withThrowingTaskGroup(of: [Double].self) { group -> String in
            group.async {
                try await getWeatherReadings(for: "London")
            }

            group.async {
                try await getWeatherReadings(for: "Rome")
            }

            group.async {
                try await getWeatherReadings(for: "San Francisco")
            }

            // Convert our array of arrays into a single array of doubles
            let allValues = try await group.reduce([], +)

            // Calculate the mean average of all our doubles
            let average = allValues.reduce(0, +) / Double(allValues.count)
            return "Overall average temperature is \(average)"
        }

        print("Done! \(result)")
    } catch {
        print("Error calculating data.")
    }
}

上述每个 <code class="inline-code">async</code>任务，你可以简化使用<code class="inline-code">for location in ["London", "Rome", "San Francisco"] {</code>来调用。

task group 提供一个<code class="inline-code">cancelAll()</code>的方法来取消所有的task。之后你仍然可以给group添加异步任务。当然，你可以使用<code class="inline-code">asyncUnlessCancelled()</code>来跳过添加任务，如果group已经被取消—— 检查Boolean的返回值类判断group是否被取消。

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0317-async-let.md">SE-0317</a>引入了一种更简易的语法<code class="inline-code">async let</code>来创建和等待子任务。这个可以作为task group的替代方法，特别是你需要使用不同数据类型的异步任务时候。

struct UserData {
    let username: String
    let friends: [String]
    let highScores: [Int]
}

func getUser() async -> String {
    "Taylor Swift"
}

func getHighScores() async -> [Int] {
    [42, 23, 16, 15, 8, 4]
}

func getFriends() async -> [String] {
    ["Eric", "Maeve", "Otis"]
}

func printUserDetails() async {
    async let username = getUser()
    async let scores = getHighScores()
    async let friends = getFriends()

    let user = await UserData(name: username, friends: friends, highScores: scores)
    print("Hello, my name is \(user.name), and I have \(user.friends.count) friends!")
}

你只能在<code class="inline-code">async</code>的上下文中，使用<code class="inline-code">async let</code>。

绑定抛错的异步方法的时候，你也不需要使用<code class="inline-code">try</code>关键词。只需要取值时候<code class="inline-code">try await</code>。

更高级的是，我们可以递归的使用async let语法。

enum NumberError: Error {
 case outOfRange
}

func fibonacci(of number: Int) async throws -> Int {
 if number < 0 || number > 22 {
 throw NumberError.outOfRange
 }

 if number < 2 { return number }
 async let first = fibonacci(of: number - 2)
 async let second = fibonacci(of: number - 1)
 return try await first + second
}

Continuation函数(转换回调异步为async函数)

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0300-continuation.md">SE-0300</a>提供了把老的回调式异步函数转换为async函数的方法。

func fetchLatestNews(completion: @escaping ([String]) -> Void) {
    DispatchQueue.main.async {
        completion(["Swift 5.5 release", "Apple acquires Apollo"])
    }
}

swift 5.5之后，你不需要重写你的所有代码，你只需要使用<code class="inline-code">withCheckedContinuation()</code>函数包裹就好。

func fetchLatestNews() async -> [String] {
    await withCheckedContinuation { continuation in
        fetchLatestNews { items in
            continuation.resume(returning: items)
        }
    }
}

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0306-actors.md">SE-0306</a>引入了<code class="inline-code">actor</code>，概念上和<code class="inline-code">class</code>很相似，但是swfit确保了，actor中的变量在任意时间段内只会被一个线程获取，这也就确保了actor在并发环境下的安全。

class RiskyCollector {
 var deck: Set<String>

 init(deck: Set<String>) {
 self.deck = deck
 }

 func send(card selected: String, to person: RiskyCollector) -> Bool {
 guard deck.contains(selected) else { return false }

 deck.remove(selected)
 person.transfer(card: selected)
 return true
 }

 func transfer(card: String) {
 deck.insert(card)
 }
}

在单线程的环境中都是OK的。但是在多线程的环境中，我们代码就有了潜在的资源竞争风险，这也就导致了，当代码并行运行时，代码的执行结果会可能不同。

假设我们调用<code class="inline-code">send(card:to:)</code> 在同一时间调用多次，

这样就导致给一个人转移了两个卡片。绝对的麻烦。

Actor通过actor isolation隔离的方式解决这个问题：

swift 内部通过队列的方式避免资源竞争，因此应能不会很好。

对于上述的例子，我们可以改写为：

actor SafeCollector {
 var deck: Set<String>

 init(deck: Set<String>) {
 self.deck = deck
 }

 func send(card selected: String, to person: SafeCollector) async -> Bool {
 guard deck.contains(selected) else { return false }

 deck.remove(selected)
 await person.transfer(card: selected)
 return true
 }

 func transfer(card: String) {
 deck.insert(card)
 }
}

更细节来说，actor内部可以任意读写属性和方法，但是和另一个actor交互的时候就必须使用异步的方式。这样就保证了线程安全，而且更棒的事编译后保证了这一点。

Swift 5.5 新特性

iOS 15 format新方法

# iOS 15格式化新方式

swift算语法很甜的语言了，但是iOS 15之前个格式化需要先 init 一个formatter，然后再根据配置格式化数据， 稍微有点点麻烦。

从iOS 15（macOS 12，watchOS 8……）开始，我们直接像其他面向对象语言一样，直接在数据上`.formatted`就好。

## iOS 15 Date格式化

```swift
let now = Date()
print(now.formatted())
// 2021/7/18, 12:19 AM

print(now.formatted(date: .complete, time: .omitted))
// Sunday, July 18, 2021
```
需要ISO8601 API？

```swift
let now = Date()
print(now.formatted(.iso8601.dateSeparator(.dash)))
// 2021-07-17T161944Z
```

还有更长的语法
```swift
let now = Date()
print(now.formatted(.dateTime.year().month()))
// Jul 2021

print(now.formatted(.dateTime.year(.twoDigits).month(.wide)))
// July 21
```

`.dateTime`可以设置更精确的时间，也可以让你设置地区

```swift
let now = Date()
print(now.formatted(.dateTime.locale(Locale(identifier: "cs"))))
// 18. 7. 2021 0:19
```

## number格式化

```swift
print(40.formatted(.percent))
// 40%

print(40.formatted(.currency(code: "eur")))
// ¥40.00

print(0.2948485.formatted(.number.precision(.significantDigits(2))))
// 0.29
```

可以使用`ByteCountFormatter`来格式化文件大小

```swift
print(38436483.formatted(.byteCount(style: .file, allowedUnits: .all, spellsOutZero: true, includesExactByteCount: false)))
// 38.4 MB
```

## `ListFormatter`也能`.formatted`

`ListFormatter` 也能在collection中`.formatted`使用。

```swift
let appleStuff = ["iPhone", "iPad", "Mac"]
print(appleStuff.formatted())
// iPhone, iPad, and Mac
```

![](https://image.hicc.pro/pro/20210718005439FhtFPO-AWHtgtolSMoDzdsbA8mYp3Vp6PYc327uwkR6zbaf1d.jpg)
---

更多: [What's new in Foundation](https://developer.apple.com/videos/play/wwdc2021/10109/)

[New approach to formatters in iOS 15](https://nemecek.be/blog/106/new-approach-to-formatters-in-ios-15?utm_campaign=iOS%2BDev%2BWeekly&utm_medium=email&utm_source=iOS%2BDev%2BWeekly%2BIssue%2B512)









Swift 5.5 终于为开发者带来了async，await，actor这些便捷的异步语法，而其中一个小小的@MainActor语法，能带来让我们的开发更加便捷安全。

在swift 5.5 之前，我们需要手动使用<code class="inline-code">DispatchQueue.main</code>来让代码运行在主线程，特别是UI更新操作。这样没问题，但是略显麻烦，而且容易遗漏。

class ProfileViewController: UIViewController {
    private let userID: User.ID
    private let loader: UserLoader
    private lazy var nameLabel = UILabel()
    private lazy var biographyLabel = UILabel()
    ...

    private func loadUser() {
        loader.loadUser { [weak self] result in
            DispatchQueue.main.async {
                switch result {
                case .success(let user):
                    self?.nameLabel.text = user.name
                    self?.biographyLabel.text = user.biography
                case .failure(let error):
                    self?.showError(error)
                }
            }
        }
    }
}

Swift 5.5 内置了的<code class="inline-code">actor</code>，MainActor被装饰的操作自动运行在主线程。

首先我们需要将我们的异步callback代码，转换成async/await模式。

extension UserLoader {
    func loadUser() async throws -> User {
        try await withCheckedThrowingContinuation { continuation in
            loadUser { result in
                switch result {
                case .success(let user):
                    continuation.resume(returning: user)
                case .failure(let error):
                    continuation.resume(throwing: error)
                }
            }
        }
    }
}

class ProfileViewController: UIViewController {
    ...
    
    private func loadUser() {
        async {
            do {
                let user = try await loader.loadUser()
                nameLabel.text = user.name
                biographyLabel.text = user.biography
            } catch {
                showError(error)
            }
        }
    }
}

等等，没有看到<code class="inline-code">@MainAcotr</code>?

那是因为apple已经将<code class="inline-code">UILabel</code>和<code class="inline-code">UIViewController</code> 装饰过了。

@MainActor class UILabel: UIView
@MainActor class UIViewController: UIResponder

也就是，在swift 的concurrency 系统中，被<code class="inline-code">@MainActor</code>装饰过的类，及其子类的属性和方法，都会自动在主线程中，get，set，或者call。

假设，我们SwiftUI中的一个实现<code class="inline-code">ObservableObject</code>的类，其中被<code class="inline-code">@Published</code>装饰的属性需要自动运行在主线程。 我们只需要装饰<code class="inline-code">@MainActor</code>即可。

@MainActor class ListViewModel: ObservableObject {
 @Published private(set) var result: Result<[Item], Error>?
 private let loader: ItemLoader
 ...

 func load() {
 async {
 do {
 let items = try await loader.loadItems()
 result = .success(items)
 } catch {
 result = .failure(error)
 }
 }
 }
}

@MainActor 只能运行在async/await环境中。

@MainActor class ListViewModel: ObservableObject {
    ...

    func load() {
        loader.loadItems { [weak self] result in
    self?.result = result
}
    }
}

@MainActor 不会对Callback中的代码生效

使用@MainActor自动在主线程更新UI

使用Dart开发你的serverless 后端

# Why ? 10M的Dart server镜像🤓

这是篇快文。😄


serverless时代，用什么开发你的后端？Go? NodeJs ? 其实随着Flutter的流行，我们还有个选项 -- Dart。

有什么优势让我们选用这个相对小众的语言？

还是它的**核心优势，JIT + AOT**

![10M的镜像尺寸](https://image.hicc.pro/pro/20210621011729FhaT4W8hkv5q66xVSGcDeaOdI1mduNoZuAgO6t8S_0nmQ5qw6.png)

- JIT: 极佳的开发体验，特别是前端工程师，像Nodejs一样，甚至有类似express的server框架，而且Dart是强类型语言，最近也做到了[null safe](https://dart.dev/null-safety) 更写起来跟省心，潜在bug少。
- AOT：极小的构建镜像，**10M**的尺寸加上执行更快的编译后机器码，保证最高效率的使用云资源。（最小的node镜像也有50M了）


## 快速开始

### 创建项目

```bash
dart create -t server-simple hipo
```

### 入口代码
```dart
import 'dart:io';

import 'package:shelf/shelf.dart';
import 'package:shelf/shelf_io.dart' as shelf_io;
import 'package:shelf_static/shelf_static.dart' as shelf_static;
import 'package:dotenv/dotenv.dart' show load, clean, isEveryDefined, env;

import 'src/common/db.dart';
import 'src/routers/user.router.dart';

Future main() async {
 load();

 final port = int.parse(Platform.environment['PORT'] ?? '8080');
 final isDev = env['DART_ENV'] == 'production';
 final conf = {
 'isDev': isDev,
 'database': {
 'host': env['DB_HOST'] ?? '127.0.0.1',
 }
 };

 final cascade = Cascade().add(_staticHandler).add(userRouter);

 // init db
 final db = getDb(conf);

 final pipeline = Pipeline()
 .addMiddleware(logRequests())
 .addMiddleware((innerHandler) => (req) async {
 final _req = req.change(context: {'db': db});
 return innerHandler(_req);
 })
 .addHandler(cascade.handler);

 final server = await shelf_io.serve(
 pipeline,
 InternetAddress.anyIPv4, // Allows external connections
 port);

 print('Serving at http://${server.address.host}:${server.port}');
}

final _staticHandler =
 shelf_static.createStaticHandler('public', defaultDocument: 'index.html');
```

shelf 系列是Google 提供类似前端express中间件形式的开发库，用起来很好上手

### 路由代码

```dart
import 'package:hipo/mysql_utils.dart';
import 'package:shelf_router/shelf_router.dart' as shelf_router;
import 'package:shelf/shelf.dart';
import 'dart:async';

final userRouter = shelf_router.Router()
 ..get('/api/helloworld', _helloWorldHandler);

Future<Response> _helloWorldHandler(Request request) async {
 var data = await (request.context['db'] as MysqlUtils).getAll(table: 'user');
 print('$data');
 return Response.ok({'len': data.length}.toString());
}

```

### mysql 数据库

可以使用[mysql1](https://pub.dev/packages/mysql1)，[mysql_utils](https://pub.dev/packages/mysql_utils) 这两个库。

```dart
import 'package:hipo/mysql_utils.dart';
import 'package:mysql1/mysql1.dart';

final getDb = (Map<String, dynamic> conf) => MysqlUtils(
 settings: ConnectionSettings(
 host: conf['database']['host'],
 port: conf['database']['port'],
 user: conf['database']['user'],
 password: conf['database']['password'],
 db: conf['database']['db'],
 useCompression: false,
 useSSL: false,
 // maxPacketSize: 1024 * 1024,
 // characterSet: CharacterSet.UTF8,
 // timeout: const Duration(seconds: 10),
 ),
 // prefix: 'prefix_',
 pool: false,
 errorLog: (error) {
 print('db error |$error\n├───────────────────────────');
 },
 sqlLog: (sql) {
 print('db sql |$sql\n├───────────────────────────');
 },
 connectInit: (db1) async {
 print('whenComplete');
 });

```

注意：

- 貌似不支持mysql 8.0+的版本
- mysql_utils需要变通下使用，作者写明了依赖flutter，实际上server也能用。


### Dockerfile

```dockerfile
# Official Dart image: https://hub.docker.com/_/dart
# Specify the Dart SDK base image version using dart:<version> (ex: dart:2.12)
FROM dart:stable AS build

# Resolve app dependencies.
WORKDIR /app
COPY pubspec.* ./
RUN dart pub get

# Copy app source code and AOT compile it.
COPY . .
# Ensure packages are still up-to-date if anything has changed
RUN dart pub get --offline
RUN dart compile exe bin/hipo.dart -o bin/hipo

# Build minimal serving image from AOT-compiled `/hipo` and required system
# libraries and configuration files stored in `/runtime/` from the build stage.
FROM scratch

ARG DART_ENV=production
ENV DART_ENV=${DART_ENV}

COPY --from=build /runtime/ /
COPY --from=build /app/bin/hipo /app/bin/

# Include files in the /public directory to enable static asset handling
COPY --from=build /app/public/ /public

# Start server.
EXPOSE 8080
CMD ["/app/bin/hipo"]
```




哇啦～～

![](https://image.hicc.pro/pro/20210621011100FogTEZ-rHY_vjy8BV-yGeEPPrBe3NWXhU6m2v1W4087jDXEnl.jpg)

MongoDB不需要像关系型数据库一样提前设计表结构，但是仍然需要处理业务间的关系，甚至因为灵活性，其中一对多One-to-N需要格外注意。

MongoDB中<code class="inline-code">One-to-N</code>模型可以简单通过在父文档中嵌入一组子文档(sub-documents)，但并不意味着你应该这么做。

在mongo中你需要考虑更多的问题：关系(relationship)的基数(cardinality)是什么?&nbsp;

你需要更精细地判断以下的情况：

通过上面的精细化判断，已经可以设计一个合理的One-to-N的模式了。但是在具体不同的业务中，仍然需要一些方法来优化One-to-N的模型。

> db.person.findOne()
{
  name: 'Kate Monster',
  ssn: '123-456-7890',
  addresses : [
     { street: '123 Sesame St', city: 'Anytown', cc: 'USA' },
     { street: '123 Avenue Q', city: 'New York', cc: 'USA' }
  ]
}

> db.parts.findOne()
{
    _id : ObjectID('AAAA'),
    partno : '123-aff-456',
    name : '#4 grommet',
    qty: 94,
    cost: 0.94,
    price: 3.99
}

> db.products.findOne()
{
    name : 'left-handed smoke shifter',
    manufacturer : 'Acme Corp',
    catalog_number: 1234,
    parts : [     // array of references to Part documents
        ObjectID('AAAA'),    // reference to the #4 grommet above
        ObjectID('F17C'),    // reference to a different Part
        ObjectID('D2AA'),
        // etc
    ]
}

使用<code class="inline-code">application-level join</code>来获取指定产品的零件。

// Fetch the Product document identified by this catalog number
> product = db.products.findOne({catalog_number: 1234});
   // Fetch all the Parts that are linked to this Product
> product_parts = db.parts.find({_id: { $in : product.parts } } ).toArray() ;

> db.hosts.findOne()
{
    _id : ObjectID('AAAB'),
    name : 'goofy.example.com',
    ipaddr : '127.66.66.66'
}

>db.logmsg.findOne()
{
    time : ISODate("2014-03-28T09:42:41.382Z"),
    message : 'cpu is on fire!',
    host: ObjectID('AAAB')       // Reference to the Host document
}

使用稍微不同的<code class="inline-code">application-level join</code>来获取指定host的最近5000条日志。

  // find the parent ‘host’ document
> host = db.hosts.findOne({ipaddr : '127.66.66.66'});  // assumes unique index
   // find the most recent 5000 log message documents linked to that host
> last_5k_msg = db.logmsg.find({host: host._id}).sort({time : -1}).limit(5000).toArray()

db.person.findOne()
{
    _id: ObjectID("AAF1"),
    name: "Kate Monster",
    tasks [     // array of references to Task documents
        ObjectID("ADF9"), 
        ObjectID("AE02"),
        ObjectID("AE73") 
        // etc
    ]
}

db.tasks.findOne()
{
    _id: ObjectID("ADF9"), 
    description: "Write lesson plan",
    due_date:  ISODate("2014-04-01"),
    owner: ObjectID("AAF1")     // Reference to Person document
}

> db.products.findOne()
{
    name : 'left-handed smoke shifter',
    manufacturer : 'Acme Corp',
    catalog_number: 1234,
    parts : [
        { id : ObjectID('AAAA'), name : '#4 grommet' },         // Part name is denormalized
        { id: ObjectID('F17C'), name : 'fan blade assembly' },
        { id: ObjectID('D2AA'), name : 'power switch' },
        // etc
    ]
}

// Fetch the product document
> product = db.products.findOne({catalog_number: 1234});  
  // Create an array of ObjectID()s containing *just* the part numbers
> part_ids = product.parts.map( function(doc) { return doc.id } );
  // Fetch all the Parts that are linked to this Product
> product_parts = db.parts.find({_id: { $in : part_ids } } ).toArray() ;

> db.parts.findOne()
{
    _id : ObjectID('AAAA'),
    partno : '123-aff-456',
    name : '#4 grommet',
    product_name : 'left-handed smoke shifter',   // Denormalized from the ‘Product’ document
    product_catalog_number: 1234,                     // Ditto
    qty: 94,
    cost: 0.94,
    price: 3.99
}

> db.logmsg.findOne()
{
    time : ISODate("2014-03-28T09:42:41.382Z"),
    message : 'cpu is on fire!',
    ipaddr : '127.66.66.66',
    host: ObjectID('AAAB')
}

> last_5k_msg = db.logmsg.find({ipaddr : '127.66.66.66'}).sort({time : -1}).limit(5000).toArray()

甚至，你可以冗余全部的One侧到squillions

> db.logmsg.findOne()
{
    time : ISODate("2014-03-28T09:42:41.382Z"),
    message : 'cpu is on fire!',
    ipaddr : '127.66.66.66',
    hostname : 'goofy.example.com',
}

 //  Get log message from monitoring system
logmsg = get_log_msg();
log_message_here = logmsg.msg;
log_ip = logmsg.ipaddr;
  // Get current timestamp
now = new Date()
  // Find the _id for the host I’m updating
host_doc = db.hosts.findOne({ipaddr : log_ip },{_id:1});  // Don’t return the whole document
host_id = host_doc._id;
  // Insert the log message, the parent reference, and the denormalized data into the ‘many’ side
db.logmsg.save({time : now, message : log_message_here, ipaddr : log_ip, host : host_id ) });
  // Push the denormalized log message onto the ‘one’ side
db.hosts.update( {_id: host_id }, 
        {$push : {logmsgs : { $each:  [ { time : now, message : log_message_here } ],
                           $sort:  { time : 1 },  // Only keep the latest ones 
                           $slice: -1000 }        // Only keep the latest 1000
         }} );

MongoDB Schema 设计

Swift 5.4 需要Xcode 12.5以上

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0287-implicit-member-chains.md">SE-0287</a>提案改进了Swift使用隐式成员表达式的能力。Swift 5.4之后不但可以使用单个 使用，而且可以链起来使用。

struct ContentViewView1: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(.red)
    }
}

我们如果要使用颜色的函数，我们只能用回<code class="inline-code">Color.red.opacity(0.5)</code>：

struct ContentViewView2: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(Color.red.opacity(0.5))
    }
}

这点很违反直觉，Swift 5.4之后就不会报错了“Cannot infer contextual base in reference to member 'red'”。可以更简易使用了：

struct ContentViewView3: View {
    var body: some View {
        Text("You're not my supervisor!")
            .foregroundColor(.red.opacity(0.5))
    }
}


函数支持多个可变参数(variadic parameter)

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0284-multiple-variadic-parameters.md">SE-0284</a>能够让函数，下标和初始化器能够支持多个可变参数(需要带上参数label)。在此之前只支持一个。

func sumarizeGoals(times: Int..., players: String...) {
    let joinedNames = ListFormatter.localizedString(byJoining: players)
    let joinedTimes = ListFormatter.localizedString(byJoining: times.map(String.init))
    
    print("\(times.count) goals where scord by \(joinedNames) at the follow minutes:\(joinedTimes)")
}

sumarizeGoals(times: 18, 33, 55, 90, players: "Dani", "jamie", "Roy")
// 4 goals where scord by Dani, jamie, and Roy at the follow minutes:18, 33, 55, and 90

Swift 5.1中非正式的引入了Function Builders。Swift 5.4中<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0289-result-builders.md">SE-0289</a>提案把它升级为了Result Builders。

简单来说，Result Builders最重要功能是可以将我们所需的一系列值一步一步变成一个新值。这个能力也是SwiftUI view创建系统的核心驱动，例如在<code class="inline-code">VStack</code>有一批子view，Swift会在背后将这些view组合成一个内部的<code class="inline-code">Tupleview</code>，这样才会被<code class="inline-code">VStack</code>真正使用。——Result Builder把一系列view变成了一个view。

举例来说，首先我们有个函数返回一个字符串：

func makeSenence1() -> String {
    "Why settle for a Duke when you can have a Prince?"
}

print(makeSenence1())
// Why settle for a Duke when you can have a Prince?

这点没问题，但是我们如果需要将多个字符串join在一起呢？我们能像SwifUI那么写么？

很明显会编译错误，Swift 5.4之后，我们可以创建一个result builder来告诉Swift如何去转换。

@resultBuilder
struct SimplestringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }
}

可以直接使用SimpleStringBuilder.buildBlock()：

let joined = SimplestringBuilder.buildBlock(
    "Why settle for a Duke",
    "when you can have",
    "a Prince?"
)

print(joined)
// Why settle for a Duke
// when you can have
// a Prince?

当然，我们使用了<code class="inline-code">@resultBuilder</code>来装饰了我们的<code class="inline-code">SimpleStringBuilder</code>。我们可以如下使用：

@SimplestringBuilder
func makesentence3() -> String {
    "Why settle for a Duke"
    "when you can have"
    "a Prince?"
}

print(makesentence3())
// Why settle for a Duke
// when you can have
// a Prince?

注意： 我们不再需要在每个字符串结尾使用逗号

result builder还可以支持if/else, for循环等表达方式。

@resultBuilder
struct ConditionalStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }
    
    static func buildEither(first component: String) -> String {
        return component
    }
    static func buildEither(second component: String) -> String {
        return component
    }
}

可以直接在函数体内使用 if else

@ConditionalStringBuilder
func makesentence4() -> String {
    "Why settle for a Duke"
    "when you can have"
    if Bool.random() {
        "a Prince?"
    } else {
        "a King?"
    }
}

// Why settle for a Duke
// when you can have
// a King?

同样，可以使用buildArray()来支持for循环:

@resultBuilder
struct ComplexStringBuilder {
    static func buildBlock(_ parts: String...) -> String {
        parts.joined(separator: "\n")
    }
    
    static func buildEither(first component: String) -> String {
        return component
    }
    static func buildEither(second component: String) -> String {
        return component
    }
    
    static func buildArray(_ components: [String]) -> String {
        components.joined(separator: "\n")
    }
}

@ComplexStringBuilder
func countDown() -> String {
    for i in (0...10).reversed() {
        "\(i)..."
    }
    
    "Lift off!"
}

print(countDown())
// 10...
// 9...
// 8...
// 7...
// 6...
// 5...
// 4...
// 3...
// 2...
// 1...
// 0...
// Lift off!

还值得一提的是，Swift 5.4中<a href="https://bugs.swift.org/browse/SR-13188">result builder也支持作用在属性</a>上， 它会自动让结构体struct的初始化函数应用result builder。

struct CustomVStack<Content: View>: View {
 @ViewBuilder let content:Content
 
 var body: some View {
 VStack {
 // custom functionality here
 content
 }
 }
}

SE-10069提案，可以让Swift支持嵌套函数中重载。

struct Butter { }
struct Flour { }
struct Sugar { }

func makeCookies() {
    func add(item: Butter) {
        print("Adding butter…")
    }

    func add(item: Flour) {
        print("Adding flour…")
    }

    func add(item: Sugar) {
        print("Adding sugar…")
    }

    add(item: Butter())
    add(item: Flour())
    add(item: Sugar())
}

在Swift 5.4之前，<code class="inline-code">add()</code>方法只有不再<code class="inline-code">makeCookies()</code>中才支持重载。

Property wrapper 从Swift 5.1引入，用来装饰属性，复用代码，在Swift 5.4中也支持函数内变量装饰Property wrapper了。

@propertyWrapper struct NonNegative<T: Numeric & Comparable> {
 var value: T

 var wrappedValue: T {
 get { value }

 set {
 if newValue < 0 {
 value = 0
 } else {
 value = newValue
 }
 }
 }

 init(wrappedValue: T) {
 if wrappedValue < 0 {
 self.value = 0
 } else {
 self.value = wrappedValue
 }
 }
}

在Swift 5.4中函数内使用，就可以避免score不会为负数。

func playGame() {
    @NonNegative var score = 0

    // player was correct
    score += 4

    // player was correct again
    score += 8

    // player got one wrong
    score -= 15

    // player got another one wrong
    score -= 16

    print(score)
}

<a href="https://github.com/apple/swift-evolution/blob/main/proposals/0294-package-executable-targets.md">SE-0294提案</a>可以支持声明Swift Package声明可执行的target。

这点对想使用<code class="inline-code">@main</code>属性的情况很有用，因为目前Swift Package包管理会自动寻找main.swift文件，有了这个能力的支持，我们在Package.swift中指定<code class="inline-code">//swift-tools-version:5.4</code>就可以移除main.swift文件，使用<code class="inline-code">@main</code>的方式了。

<a href="https://github.com/apple/swift-evolution/blob/master/proposals/0276-multi-pattern-catch-clauses.md">SE-0276提案</a>(Multi-pattern catch clauses)，能够让我们在单个<code class="inline-code">catch</code>块中，捕获多个错误，以此来减少重复代码。

enum Temperatureerror: Error {
    case tooCold, tooHot
}


func getReactortemperature() -> Int {
 100
}

func checkreactorOperational() throws -> String {
 let temp = getReactortemperature()
 
 if temp < 10 {
 throw Temperatureerror.tooCold
 } else if temp > 90 {
 throw Temperatureerror.tooHot
 } else {
 return "ok"
 }
}

Swift 5.2之后，你可以使用逗号，同时处理tooHot和tooCold。

do {
    let result = try checkreactorOperational()
    print("Result: \(result)")
} catch Temperatureerror.tooHot, Temperatureerror.tooCold {
    print("Shut down the reactor!")
} catch {
    print("An unknown error occurred.")
}


SE-0279提案引入了多重尾随闭包，能够让我们更简单的调用有多个闭包参数的函数。

Hipo Log

Swift中的模式匹配

Next.js + 腾讯云开发Webify 打造绝佳网站

Swift 5.5 新特性

iOS 15 format新方法

使用@MainActor自动在主线程更新UI

使用Dart开发你的serverless 后端

MongoDB Schema 设计

Swift 5.2到5.4新特性整理

深圳东西冲穿越

前端元编程——使用注解加速你的前端开发

青海的海，祁连的山

Next.js 简明教程

使用腾讯云开发来部署Svelte Sapper应用

Combine 基本概念

小刀志

【译】SwiftUI中使用ForEach枚举列表

Hipo 2.6

Ghost-MDE -- 使用Markdown来书写Ghost 博客

Swift 5.1

Ghost-MDE -- Writing ghost post with markdown editor