今年 Anthropic 的势头异常凶猛。

不仅热度居高不下，口碑也持续攀升，稳坐 AI 圈「顶流」的交椅。现在几乎每天醒来，都能看到他们准点推送的新产品或新功能。久而久之，大家也从兴奋变成了「是你，果然又是你」的默契感。

而就在刚刚，万众期待的 Claude Opus 4.7 也正式发布，依旧是熟悉的配方，熟悉的高分选手。

有趣的是，Anthropic 在公告里非常坦诚，甚至带着点骄傲：「这并非我们最强大的模型。」那个传说强得可怕的 Claude Mythos Preview 依然还在藏。

但就是这个并非最强的 Opus 4.7，却依旧引发了极大的关注。因为它解决了一个比聪明更重要的痛点：靠谱。不是那种你说什么它就做什么的靠谱，而是当你提出一个愚蠢的方案时，它敢于反驳你，并自己把坑填上的靠谱。

当靠谱成为比聪明更稀缺的品质

基准测试结果显示，在业界公认最硬核的 SWE-bench Pro 上，4.7 从前代的 53.4% 直接拉到 64.3%，单代升级涨了近 11 个百分点，把 GPT-5.4（57.7%）和 Gemini 3.1 Pro（54.2%）都甩在了身后。

视觉推理的 CharXiv 基准从 69.1% 跳到 82.1%，对应的是它新获得的 2576 像素长边识别能力——清晰度是前代的 3 倍以上。

这不只是「看得更清楚」这么简单。更高的分辨率直接带动了输出质量的连锁提升：生成界面、制作幻灯片、排版文档，细节精度也全面提升。

工具调用规模化评测 MCP-Atlas 上，4.7 跑出 77.3%，超过 GPT-5.4 的 68.1% 和 Gemini 的 73.9%。法律 AI 平台 Harvey 测试中，4.7 在 BigLaw 基准上拿下 90.9%，正确区分了历来是前沿模型死穴的「转让条款」与「控制权变更条款」。

不过，4.7 也并非全然遥遥领先，在 Agentic search 评测 BrowseComp 上，4.7 反而从前代的 83.7% 下降到了 79.3%，被 GPT-5.4（89.3%）和 Gemini（85.9%）超越。

这个退步并非偶然。一个遇到缺失信息会直接报错、不肯乱编答案的 Agent，在以「是否给出答案」为评判标准的基准上，天然会吃亏。

而数据之外，更值得关注的问题是：这种「靠谱」，在真实工作里到底意味着什么？

过去一年，业界对代码大模型的期待，普遍还停留在「写个函数、找个 Bug」的层面，但 Claude 4.7 在早期测试里，展现出了一种截然不同的气质。

知名云端开发平台 Replit 的负责人这样描述：「它在技术讨论中会反驳我，帮我做出更好的决定。它真的感觉像一个更好的同事。」

它不再一味地「唯命是从」，也不再为了交差而胡编乱造。在数据科学平台 Hex 的测试里，4.7 遇到缺失数据时会直接报错，而不是像前代那样塞一个「看似合理但完全错误」的备选值。Hex 团队甚至直言：「低消耗状态下的 4.7，等同于中等消耗状态下的 4.6。」

这种「拒绝顺从」的特质，恰恰是高级软件工程里最稀缺的东西。

当然，凡事有两面。为旧模型写的 prompt，到了 4.7 手里可能会产生意想不到的结果。那些过去被模型「意会」掉的模糊指令，4.7 会一字一字地字面执行。这也意味着越懂得清楚表达需求的人，越能从 4.7 这里拿到好结果。

光会「顶嘴」还不够，遇到挫折就罢工的 AI 同样不是好同事。4.7 的另一个大的变化，是任务韧性。

以往大模型在多步任务中遇到工具调用失败，往往直接停机报错。Notion 团队测试发现，4.7 的工具错误率降到了原来的三分之一，更关键的是，它能在工具链崩溃时自己绕过障碍，继续把任务跑完。

当 AI 停止谄媚，真正的生产力才开始爆发。

Anthropic 公布的一个极端案例里，4.7 在没有任何人类干预的情况下，从零构建了一个完整的 Rust 文本转语音引擎——写神经网络模型、SIMD 内核和浏览器演示，还自己把输出喂给语音识别器做验证，连测试都一并完成了。

前端框架巨头 Vercel 还发现了一个过去从未有过的行为：4.7 会在开始写系统级代码之前，先自己进行数学证明。这已经超出了写代码的范畴，进入了严谨工程设计的领域。

雇佣 AI「资深专家」的代价

为了验证它在细节上的处理能力，我设定了三个前端交互场景，评判标准只有一个：细节是否敷衍，一眼便知。

第一个场景，是让它做一个俯视视角的黑胶唱片机界面，其难点在于「金属光泽」与「呼吸光晕」的呈现。4.7 并没有用廉价的色彩渐变敷衍了事，而是通过复杂的 CSS 样式叠加，逼真地还原了金属质感。

第二个场景是只用 CSS，不用 JavaScript 做一个老式电风扇。 面对这个限制严格的题目，一些模型会悄悄违规使用 JS，但 4.7 遵守了规则。它用纯 CSS 做出了风扇的立体结构，低中高三档过渡流畅，底座透视和阴影的处理也真有一点实物感，它在规则允许的范围内找到了很好的解决办法。

第三个场景是做一个复古磁带随身听，带有录像带那种老旧的噪点效果。磁带转动的细节也是有的。

当然，变聪明是有代价的。Opus 4.7 现已在所有 Claude 产品和 API、Amazon Bedrock、Google Cloud 的 Vertex AI 以及 Microsoft Foundry 平台上推出。

基础定价维持在每百万输入 5 美元、输出 25 美元不变。但 4.7 引入了全新分词器，同样的文本会拆分出比原来多 1.0 到 1.35 倍的 Token。

叠加上它在高强度任务中本身就倾向于「多想一会儿」，实际消耗几乎必然上升。

此外，Anthropic 在原有的难度选项之上，加入了全新的 xhigh（超高）级别。在这个级别下，面对复杂难题，Claude 4.7 会消耗更多的 Token，花更多的时间去「思考」。Claude Code 已经把所有套餐的默认 effort level 直接拉到了 xhigh。

Anthropic 用行动告诉所有人，对于真正的编码任务，省着用不如想清楚。

为了匹配这种工作流，Claude Code 顺势推出了两个杀手级功能：

/ultrareview（深度审查）：开启一个专门的审查会话，像一个极其挑剔的资深 Reviewer 一样，通读所有代码更改，精准标记出深层的架构设计缺陷和 Bug。Pro 和 Max 用户可以免费试用三次。

Auto Mode（自动模式）扩展到 Max 用户：一种介于「逐项授权」和「跳过所有权限」之间的新权限模式。Claude 会在你授权的范围内自主做决策，既能跑完漫长无聊的任务，又比完全放权更安全。

为了防止这个「太能思考」的 AI 把账户余额刷爆，API 端还推出了「任务预算」（Task Budgets）功能公测版，让开发者可以显式规划 Claude 在长任务中的 Token 支出优先级。

当然，4.7 并不是 Anthropic 手里最强的牌。

那个更强的 Claude Mythos Preview，本月刚以「Project Glasswing」的名义，小范围开放给了一批企业用于网络安全研究。Mythos 没有公开发布，原因则是因为它的网络攻防能力太强，Anthropic 觉得还没想清楚怎么安全地推给所有人。

4.7 本身也做了主动取舍，训练阶段就压低了网络攻防能力，内置自动拦截机制，碰到高风险请求直接挡掉。有合规需求的安全研究人员，可以通过官方渠道单独申请。

不急着把最强的牌打出去，和不停地往桌上加新牌，背后是同一套逻辑。实际上，Anthropic 真正的护城河，是交付节奏本身。

在今年 2 月 1 日至 3 月 24 日，短短 52 天里，Anthropic 一共更新了 74 款产品，平均不到两天一个。Cowork、插件……这些动作扎扎实实地击中了职场办公的痛点。

如今的 Claude 生态，早就超越了单纯的「聊天机器人」。对于那些渴望将 AI 深度嵌入实际工作流的团队而言，这种稳定、高频且可预期的更新节奏，才是最让人感到踏实的定心丸。

今天发布的 Claude 4.7，是这条链条上最新的一块压舱石。而那个 Mythos Preview，迟早也会来。到那时候，我们现在觉得已经很能打的 4.7，可能只是个开端。

#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。

给你一个整数数组 nums。

镜像对 是指一对满足下述条件的下标 (i, j)：

• 0 <= i < j < nums.length，并且
• reverse(nums[i]) == nums[j]，其中 reverse(x) 表示将整数 x 的数字反转后形成的整数。反转后会忽略前导零，例如 reverse(120) = 21。

返回任意镜像对的下标之间的 最小绝对距离。下标 i 和 j 之间的绝对距离为 abs(i - j)。

如果不存在镜像对，返回 -1。

示例 1：

示例 2：

示例 3：

提示：

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 109

解法：双指针

考虑整数 x，假设我们把序列里的所有 x 变成红色，所有 reverse(x) 变成蓝色， 我们就可以枚举所有红色，看左边最近的蓝色在哪里。这一问题可以用双指针解决。

枚举序列中出现过的所有不同整数 x，取最小答案即可。复杂度 $\mathcal{O}(n)$。

参考代码（c++）

class Solution {
public:
    int minMirrorPairDistance(vector<int>& nums) {
        int n = nums.size();

        // 求 reverse(x)
        auto gao = [&](int x) {
            vector<int> vec;
            for (; x; x /= 10) vec.push_back(x % 10);
            int ret = 0;
            for (int y : vec) ret = ret * 10 + y;
            return ret;
        };

        // pos1 记录每种元素出现的所有位置
        // pos2 记录每种 reverse 出现的所有位置
        unordered_map<int, vector<int>> pos1, pos2;
        for (int i = 0; i < n; i++) {
            pos1[nums[i]].push_back(i);
            pos2[gao(nums[i])].push_back(i);
        }

        const int INF = 1e9;
        int ans = INF;
        for (auto &entry : pos1) if (pos2.count(entry.first)) {
            auto &vec1 = entry.second;
            auto &vec2 = pos2[entry.first];
            // vec1[i] 是当前枚举到的元素下标，vec2[j] 是大于等于 vec1[i] 的最近 reverse 的下标
            // 所以 vec2[j - 1] 就是小于 vec[i] 的最近 reverse 的下标
            for (int i = 0, j = 0; i < vec1.size(); i++) {
                while (j < vec2.size() && vec2[j] < vec1[i]) j++;
                if (j - 1 >= 0) ans = min(ans, vec1[i] - vec2[j - 1]);
            }
        }
        return ans < INF ? ans : -1;
    }
};

不会做怎么办

本题是双指针的简单应用，不会做本题的读者可以学习 灵神题单 - 滑动窗口与双指针 的“双序列双指针”一节。

枚举 $j$，同时用哈希表维护 $j$ 左边的 $\text{reverse}(\textit{nums}[i])$ 的最大下标，哈希表的 key 是 $\text{reverse}(\textit{nums}[i])$，value 是下标 $i$。

如果哈希表中有 $\textit{nums}[j]$，获取对应的下标 $i$，用 $j-i$ 更新答案的最小值。

⚠注意：请仔细读题，题目要求的是 reverse(nums[i]) == nums[j]，不是 reverse(nums[j]) == nums[i]，下标必须满足 $i<j$，不是对称的。

本题视频讲解，欢迎点赞关注~

###py

class Solution:
    def minMirrorPairDistance(self, nums: List[int]) -> int:
        last_index = {}
        ans = inf

        for j, x in enumerate(nums):
            if x in last_index:
                ans = min(ans, j - last_index[x])
            rev = int(str(x)[::-1])
            last_index[rev] = j

        return ans if ans < inf else -1

###py

class Solution:
    def minMirrorPairDistance(self, nums: List[int]) -> int:
        last_index = {}
        ans = inf

        for j, x in enumerate(nums):
            if x in last_index:
                ans = min(ans, j - last_index[x])

            # 计算 reverse(x)，不用字符串
            rev = 0
            while x > 0:
                x, d = divmod(x, 10)
                rev = rev * 10 + d
            last_index[rev] = j

        return ans if ans < inf else -1

###java

class Solution {
    public int minMirrorPairDistance(int[] nums) {
        int n = nums.length;
        int ans = n;
        Map<Integer, Integer> lastIndex = new HashMap<>(n, 1); // 预分配空间

        for (int j = 0; j < n; j++) {
            int x = nums[j];
            Integer i = lastIndex.get(x);
            if (i != null) {
                ans = Math.min(ans, j - i);
            }

            // 计算 reverse(x)，不用字符串
            int rev = 0;
            for (; x > 0; x /= 10) {
                rev = rev * 10 + x % 10;
            }
            lastIndex.put(rev, j);
        }

        return ans < n ? ans : -1;
    }
}

###cpp

class Solution {
public:
    int minMirrorPairDistance(vector<int>& nums) {
        unordered_map<int, int> last_index;
        int n = nums.size(), ans = n;

        for (int j = 0; j < n; j++) {
            int x = nums[j];
            auto it = last_index.find(x);
            if (it != last_index.end()) {
                ans = min(ans, j - it->second);
            }

            // 计算 reverse(x)，不用字符串
            int rev = 0;
            for (; x > 0; x /= 10) {
                rev = rev * 10 + x % 10;
            }
            last_index[rev] = j;
        }

        return ans < n ? ans : -1;
    }
};

###go

func minMirrorPairDistance(nums []int) int {
n := len(nums)
ans := n
lastIndex := make(map[int]int, n) // 预分配空间

for j, x := range nums {
if i, ok := lastIndex[x]; ok {
ans = min(ans, j-i)
}

// 计算 reverse(x)，不用字符串
rev := 0
for ; x > 0; x /= 10 {
rev = rev*10 + x%10
}
lastIndex[rev] = j
}

if ans == n {
return -1
}
return ans
}

复杂度分析

• 时间复杂度：$\mathcal{O}(n\log U)$，其中 $n$ 是 $\textit{nums}$ 的长度，$U=\max(\textit{nums})$。反转一个数字需要 $\mathcal{O}(\log U)$ 时间。
• 空间复杂度：$\mathcal{O}(n)$。

专题训练

见下面数据结构题单的「§0.1 枚举右，维护左」。

分类题单

如何科学刷题？

1. 滑动窗口与双指针（定长/不定长/单序列/双序列/三指针/分组循环）
2. 二分算法（二分答案/最小化最大值/最大化最小值/第K小）
3. 单调栈（基础/矩形面积/贡献法/最小字典序）
4. 网格图（DFS/BFS/综合应用）
5. 位运算（基础/性质/拆位/试填/恒等式/思维）
6. 图论算法（DFS/BFS/拓扑排序/基环树/最短路/最小生成树/网络流）
7. 动态规划（入门/背包/划分/状态机/区间/状压/数位/数据结构优化/树形/博弈/概率期望）
8. 常用数据结构（前缀和/差分/栈/队列/堆/字典树/并查集/树状数组/线段树）
9. 数学算法（数论/组合/概率期望/博弈/计算几何/随机算法）
10. 贪心与思维（基本贪心策略/反悔/区间/字典序/数学/思维/脑筋急转弯/构造）
11. 链表、树与回溯（前后指针/快慢指针/DFS/BFS/直径/LCA）
12. 字符串（KMP/Z函数/Manacher/字符串哈希/AC自动机/后缀数组/子序列自动机）

我的题解精选（已分类）

作为大众汽车首款基于纯电平台打造的专属车型，问世已有六年之久的 ID.3 迎来了大规模升级，并正式更名为「ID.3 Neo」。

目前，大众汽车正逐步取消纯电车型的数字命名体系，例如即将迎来大改款的 ID.4 已确认将更名为 ID. Tiguan。

然而，鉴于 ID.3 在市场上已积累了深厚的品牌资产，大众决定为其保留数字「3」的名称。新增的「Neo」后缀，则意在强调这并非一次常规的中期改款，而是一场由内而外的全面更新。

焕新而来的 ID.3 Neo，不仅拥有了全新的外观造型和更大容量的电池，也在内饰及交互体验上进行了修正和升级。

大众调整了 ID.3 Neo 的前脸，让其与即将推出的 ID. Polo 和 ID. Cross 在视觉上保持统一，展现全新的家族化设计。相比于 ID. Polo，它的整体视觉效果更加成熟稳重。

车头最显著的变化在于换装了更粗壮的贯穿式 LED 灯带，连接了经过微调的大灯组与黑色饰条；大众的 Logo 位置略微下移，前保险杠也换上了造型更犀利的进气口。

此外，车辆的 A 柱、车顶、后扰流板和尾门均取消了以往的亮黑色拼色处理，统一改用与车身同色的涂装。车身侧面轮廓与老款基本保持一致，但新增了几款全新样式的轮毂。

尺寸方面，新车车长增加了 23 毫米，车高降低了 10 毫米，轴距缩短了 6 毫米，车宽则保持不变。大众表示，这些微调赋予了车辆全新的比例，使其在视觉上比前代车型显得更加修长、低趴且富有动感。

座舱内部是此次升级的核心所在，大众对早期车型上备受争议的设计缺陷进行了全面修正。

车内大量采用了更高品质的柔软材质，仪表板也经过重新设计，运用更平直的线条来进一步凸显座舱的空间感。

而所有升级中，最令人瞩目的改变是实体按键的全面回归——

• 备受诟病的触摸感应式「滑动条」，被传统的音量旋钮和实体座椅加热开关所取代；
• 全新设计的双辐式方向盘不仅配备了发光的大众 Logo，更将此前的触感反馈按键全部替换为实体按键;
• 在主驾驶侧的车门上，四个车窗都拥有了独立的控制按键，彻底告别了以往「两个按键加切换拨杆」的反人类繁琐设计。

智能化方面，新车配备了 10.25 英寸全液晶仪表盘与 12.9 英寸悬浮式中控触摸屏。车机系统采用了全新的 UI 图形界面和更直观的菜单逻辑，与即将发布的 ID. Polo 保持一致。

值得一提的是，数字仪表盘支持高度自定义，甚至可以模仿 20 世纪 80 年代高尔夫的复古仪表风格，其中还包含了极具情怀的复古电量表。

消费者还可选装增强现实（AR）HUD 抬头显示、全景天窗、带按摩和记忆功能的前排座椅，以及哈曼卡顿（Harman Kardon）高级音响系统。

ID.3 Neo 基于大众 MEB 平台的最新进化版MEB+平台打造。该架构未来也将应用于 ID. Polo 和 ID. Cross 这两款前驱车型，而 ID.3 Neo 则继续保留后置电机、后轮驱动的经典布局。

在欧洲市场首发的 ID.3 Neo 提供了三种后驱纯移动力输出和电池配置，整体能效得到了显著提升。

• 入门版（Entry）配备了 50kWh 电池，提供 168 马力（140kW / 170PS）的动力，支持 105kW 的充电功率。
• 中配版（Mid）配备了 58kWh 电池，动力提升至 188 马力（140kW / 190PS），同样支持 105kW 充电功率。
• 顶配版（High）搭载了 79kWh 的电池，可输出 228 马力（170kW / 231PS）的动力，其最大快充功率提升至 183kW，该版本的 WLTP 续航里程达到了 630 公里。

此外，新车全系新增了 V2L 对外放电功能，可作为移动电源为外部设备供电。

并且得益于大众最新的软件架构，ID.3 Neo 不仅新增了单踏板驾驶模式，还支持智能手机数字钥匙功能。这套全新软件在提升车辆底层性能的同时，也大幅优化了用户体验。

安全性方面，新车搭载了增强版 Connected Travel Assist 系统，可实现更流畅的半自动驾驶，并提供交通信号灯识别、带记忆功能的 Park Assist Pro（专业泊车辅助）等选装配置。

此外，ID.3 Neo 还全系标配了车道保持辅助、前部防碰撞预警以及转弯制动辅助等主动安全系统。

而对于追求极致性能的消费者，大众正在研发一款比之前 322 马力的 ID.3 GTX Performance 更快的高性能继任车型。

据悉，该车有望于今年晚些时候正式亮相，并有可能挂上「GTI」徽标。

大众表示，希望通过此次全方位的软硬件升级，使 ID.3 Neo 能够更好地应对来自中国新能源汽车品牌日益激烈的竞争，并在本年代末纯电动版 ID. Golf 问世前，持续保持市场竞争力。

大众汽车首席执行官 Thomas Schäfer 坦言，在 2022 年他接手大众时，品牌正在逐渐失去其所代表的核心价值观；而 ID.3 Neo 正是大众回归「真正的大众汽车」的首款代表作。

如今，大众的目标是再次打造出「能够完美融入人们生活、值得信赖且极具实用性」的汽车。

目前，大众尚未公布 ID.3 Neo 在欧洲市场的具体售价。作为参考，现款 ID.3 在英国的起售价为 30,860 英镑（约合人民币 28.5 万元）。

在国内市场，国产 ID.3 曾在 2024 年创下全年销量超 9.38 万台的辉煌战绩，一度实现月销破万，至今仍是合资纯电车型的销量标杆。

然而，在国内新能源市场极度「内卷」的挤压下，国产 ID.3 的竞争优势逐渐被削弱，目前起售价 13 万元的国产 ID.3 在过去半年仅售出了 8505 辆。

未来，引入国产 ID.3 Neo 要是起售价能到 10 万元以下，或许能和蔚来萤火虫扳扳手腕？

#欢迎关注爱范儿官方微信公众号：爱范儿（微信号：ifanr），更多精彩内容第一时间为您奉上。

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

5.1 @State：本地视图状态

@State 介绍

@State 是 SwiftUI 中最基本的状态管理工具，用于管理视图的本地状态。它是一个属性包装器，允许我们在结构体中创建可变状态。

基本用法

import SwiftUI

struct CounterView: View {
    // 使用 @State 声明本地状态
    @State private var count = 0
    
    var body: some View {
        VStack(spacing: 20) {
            // 显示状态值
            Text("Count: \(count)")
                .font(.largeTitle)
                .fontWeight(.bold)
            
            // 修改状态
            Button("Increment") {
                count += 1  // 状态改变，UI 自动更新
            }
            .buttonStyle(.borderedProminent)
            
            Button("Reset") {
                count = 0  // 状态重置
            }
            .buttonStyle(.bordered)
        }
        .padding()
    }
}

#Preview {
    CounterView()
}

工作原理

@State 的工作原理：

1. 当你使用 @State 标记一个属性时，SwiftUI 会在底层为这个属性创建一个独立的存储
2. 这个存储不受结构体值类型特性的影响，即使结构体被重新创建，状态也会保持
3. 当状态值改变时，SwiftUI 会自动重新计算视图的 body 属性
4. 系统会对比新旧视图树，只更新发生变化的部分

最佳实践

1. 标记为 private：@State 应该只在当前视图内部使用，所以应该标记为 private
2. 初始值：必须为 @State 属性提供初始值
3. 避免在 body 中修改：不要在 body 计算属性中直接修改 @State 值
4. 简单类型：@State 适合存储简单类型（如 Bool、Int、String 等）

5.2 @Binding：父子视图双向绑定

@Binding 介绍

@Binding 用于在父子视图之间创建双向绑定，允许子视图修改父视图的状态。

基本用法

import SwiftUI

// 父视图
struct ParentView: View {
    // 父视图的状态
    @State private var isPlaying = false
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Parent View")
                .font(.headline)
            
            Text("Is Playing: \(isPlaying ? "Yes" : "No")")
            
            // 使用 $ 符号创建绑定并传递给子视图
            PlayButton(isPlaying: $isPlaying)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

// 子视图
struct PlayButton: View {
    // 使用 @Binding 接收父视图的状态引用
    @Binding var isPlaying: Bool
    
    var body: some View {
        Button(isPlaying ? "Pause" : "Play") {
            // 修改绑定值，会同步更新父视图的状态
            isPlaying.toggle()
        }
        .buttonStyle(.borderedProminent)
        .tint(isPlaying ? .red : .green)
        .padding()
        .background(Color.gray.opacity(0.05))
        .cornerRadius(8)
    }
}

#Preview {
    ParentView()
}

工作原理

@Binding 的工作原理：

1. 它不是存储状态，而是创建一个对现有状态的引用
2. 当子视图修改绑定值时，实际上是修改了原始的 @State 状态
3. 状态的所有权仍然在父视图中
4. 这种机制确保了单一数据源（SSOT）原则

实际应用

// 表单输入示例
struct FormView: View {
    @State private var username = ""
    @State private var email = ""
    
    var body: some View {
        VStack(spacing: 16) {
            Text("User Form")
                .font(.headline)
            
            TextFieldView(
                title: "Username",
                text: $username,
                placeholder: "Enter your username"
            )
            
            TextFieldView(
                title: "Email",
                text: $email,
                placeholder: "Enter your email"
            )
            
            Text("Username: \(username)")
            Text("Email: \(email)")
        }
        .padding()
    }
}

struct TextFieldView: View {
    let title: String
    @Binding var text: String
    let placeholder: String
    
    var body: some View {
        VStack(alignment: .leading, spacing: 4) {
            Text(title)
                .font(.subheadline)
                .fontWeight(.medium)
            
            TextField(
                placeholder,
                text: $text
            )
            .textFieldStyle(.roundedBorder)
        }
    }
}

5.3 @StateObject：可观察对象状态

@StateObject 介绍

@StateObject 用于管理符合 ObservableObject 协议的对象，适用于需要在多个视图之间共享的复杂状态。

基本用法

import SwiftUI
import Combine

// 可观察对象模型
class UserViewModel: ObservableObject {
    // 使用 @Published 标记需要发布的属性
    @Published var username = ""
    @Published var email = ""
    @Published var isLoggedIn = false
    
    func login() {
        // 模拟登录操作
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            self.isLoggedIn = true
        }
    }
    
    func logout() {
        username = ""
        email = ""
        isLoggedIn = false
    }
}

struct UserView: View {
    // 使用 @StateObject 管理可观察对象
    @StateObject private var viewModel = UserViewModel()
    
    var body: some View {
        VStack(spacing: 20) {
            Text("User Profile")
                .font(.headline)
            
            if viewModel.isLoggedIn {
                Text("Welcome, \(viewModel.username)!")
                    .font(.title)
                Text("Email: \(viewModel.email)")
                
                Button("Logout") {
                    viewModel.logout()
                }
                .buttonStyle(.borderedProminent)
                .tint(.red)
            } else {
                TextField("Username", text: $viewModel.username)
                    .textFieldStyle(.roundedBorder)
                TextField("Email", text: $viewModel.email)
                    .textFieldStyle(.roundedBorder)
                
                Button("Login") {
                    viewModel.login()
                }
                .buttonStyle(.borderedProminent)
                .disabled(viewModel.username.isEmpty || viewModel.email.isEmpty)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    UserView()
}

工作原理

@StateObject 的工作原理：

1. 它会创建并拥有一个符合 ObservableObject 协议的对象
2. 当对象的 @Published 属性改变时，所有使用该对象的视图都会自动更新
3. 即使视图被重新创建，@StateObject 也会保持对象的生命周期
4. 适用于需要在多个视图之间共享的复杂状态

最佳实践

1. 用于复杂状态：适用于包含多个相关属性的复杂状态
2. 单一数据源：作为状态的唯一来源
3. 生命周期管理：由 SwiftUI 管理对象的生命周期
4. 性能考虑：对于大型对象，考虑使用更细粒度的状态管理

5.4 @ObservedObject：观察外部对象

@ObservedObject 介绍

@ObservedObject 用于观察外部传入的符合 ObservableObject 协议的对象，适用于从父视图传递的可观察对象。

基本用法

import SwiftUI

// 父视图
struct ParentWithObservedObject: View {
    // 父视图拥有状态对象
    @StateObject private var userViewModel = UserViewModel()
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Parent View")
                .font(.headline)
            
            // 传递给子视图
            ChildView(viewModel: userViewModel)
        }
        .padding()
    }
}

// 子视图
struct ChildView: View {
    // 使用 @ObservedObject 观察外部对象
    @ObservedObject var viewModel: UserViewModel
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Child View")
                .font(.subheadline)
            
            TextField("Username", text: $viewModel.username)
                .textFieldStyle(.roundedBorder)
            
            TextField("Email", text: $viewModel.email)
                .textFieldStyle(.roundedBorder)
            
            Button("Login") {
                viewModel.login()
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    ParentWithObservedObject()
}

工作原理

@ObservedObject 的工作原理：

1. 它不拥有对象，只是观察外部传入的对象
2. 当对象的 @Published 属性改变时，视图会自动更新
3. 对象的生命周期由其拥有者管理
4. 适用于从父视图传递的可观察对象

与 @StateObject 的区别

5.5 @EnvironmentObject：全局环境对象

@EnvironmentObject 介绍

@EnvironmentObject 用于访问通过环境传递的全局可观察对象，适用于跨多个视图层级共享的状态。

基本用法

import SwiftUI

// 全局状态模型
class AppState: ObservableObject {
    @Published var isDarkMode = false
    @Published var userLanguage = "zh"
    
    func toggleDarkMode() {
        isDarkMode.toggle()
    }
    
    func changeLanguage(to language: String) {
        userLanguage = language
    }
}

// 主视图 - 设置环境对象
struct MainView: View {
    @StateObject private var appState = AppState()
    
    var body: some View {
        NavigationStack {
            VStack {
                Text("Main View")
                    .font(.headline)
                
                NavigationLink("Settings", destination: SettingsView())
                NavigationLink("Profile", destination: ProfileView())
            }
            .padding()
        }
        // 通过环境传递对象
        .environmentObject(appState)
    }
}

// 设置视图 - 访问环境对象
struct SettingsView: View {
    // 通过 @EnvironmentObject 访问全局对象
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Settings")
                .font(.headline)
            
            Toggle("Dark Mode", isOn: $appState.isDarkMode)
            
            Picker("Language", selection: $appState.userLanguage) {
                Text("English").tag("en")
                Text("中文").tag("zh")
                Text("日本語").tag("ja")
            }
            .pickerStyle(.segmented)
        }
        .padding()
        .background(appState.isDarkMode ? Color.black : Color.white)
        .foregroundColor(appState.isDarkMode ? Color.white : Color.black)
    }
}

// 个人资料视图 - 访问环境对象
struct ProfileView: View {
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Profile")
                .font(.headline)
            
            Text("Current Language: \(appState.userLanguage)")
            Text("Dark Mode: \(appState.isDarkMode ? "On" : "Off")")
        }
        .padding()
        .background(appState.isDarkMode ? Color.black : Color.white)
        .foregroundColor(appState.isDarkMode ? Color.white : Color.black)
    }
}

#Preview {
    MainView()
}

工作原理

@EnvironmentObject 的工作原理：

1. 它从环境中查找指定类型的可观察对象
2. 当对象的 @Published 属性改变时，所有使用该对象的视图都会自动更新
3. 不需要手动传递对象，通过环境自动注入
4. 适用于跨多个视图层级共享的全局状态

最佳实践

1. 全局状态：用于应用级别的全局状态
2. 依赖注入：通过环境进行依赖注入，避免层层传递
3. 类型安全：基于类型查找，确保类型正确
4. 错误处理：确保在使用前在环境中设置了对象

5.6 @Environment：环境值

@Environment 介绍

@Environment 用于访问 SwiftUI 环境中的系统值，如布局方向、颜色方案、字体大小等。

基本用法

import SwiftUI

struct EnvironmentValuesView: View {
    // 访问环境值
    @Environment(\.colorScheme) private var colorScheme
    @Environment(\.layoutDirection) private var layoutDirection
    @Environment(\.dynamicTypeSize) private var dynamicTypeSize
    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
    
    var body: some View {
        VStack(spacing: 16) {
            Text("Environment Values")
                .font(.headline)
            
            Text("Color Scheme: \(colorScheme == .dark ? "Dark" : "Light")")
            Text("Layout Direction: \(layoutDirection == .leftToRight ? "LTR" : "RTL")")
            Text("Dynamic Type Size: \(dynamicTypeSize.description)")
            Text("Horizontal Size Class: \(horizontalSizeClass == .regular ? "Regular" : "Compact")")
            
            // 根据环境值调整布局
            if horizontalSizeClass == .regular {
                HStack {
                    Text("Wide Layout")
                    Spacer()
                    Text("More Content")
                }
            } else {
                VStack {
                    Text("Narrow Layout")
                    Text("Content Below")
                }
            }
        }
        .padding()
        .background(colorScheme == .dark ? Color.black : Color.white)
        .foregroundColor(colorScheme == .dark ? Color.white : Color.black)
    }
}

#Preview {
    EnvironmentValuesView()
}

常用环境值

工作原理

@Environment 的工作原理：

1. 它从 SwiftUI 环境中读取指定的环境值
2. 当环境值改变时，视图会自动更新
3. 环境值由系统或父视图设置
4. 适用于响应系统设置和环境变化

5.7 @SceneStorage：场景存储

@SceneStorage 介绍

@SceneStorage 用于在场景级别持久化存储简单数据，适用于保存用户偏好设置和状态。

基本用法

import SwiftUI

struct SceneStorageView: View {
    // 使用 @SceneStorage 存储数据
    @SceneStorage("username") private var username = ""
    @SceneStorage("isDarkMode") private var isDarkMode = false
    @SceneStorage("counter") private var counter = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Scene Storage")
                .font(.headline)
            
            TextField("Username", text: $username)
                .textFieldStyle(.roundedBorder)
            
            Toggle("Dark Mode", isOn: $isDarkMode)
            
            VStack {
                Text("Counter: \(counter)")
                HStack {
                    Button("Increment") {
                        counter += 1
                    }
                    .buttonStyle(.bordered)
                    
                    Button("Reset") {
                        counter = 0
                    }
                    .buttonStyle(.bordered)
                }
            }
            
            Text("Note: Data persists across app restarts")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(isDarkMode ? Color.black : Color.white)
        .foregroundColor(isDarkMode ? Color.white : Color.black)
    }
}

#Preview {
    SceneStorageView()
}

工作原理

@SceneStorage 的工作原理：

1. 它将数据存储在场景的 UserDefaults 中
2. 数据会在场景重启后保持
3. 每个场景有自己的存储，不同场景之间数据隔离
4. 适用于存储用户偏好设置和临时状态

最佳实践

1. 简单数据：适合存储简单类型（String、Int、Bool 等）
2. 场景隔离：每个场景有独立的存储
3. 自动持久化：数据自动保存，无需手动管理
4. 键名唯一性：使用唯一的键名避免冲突

5.8 @AppStorage：应用存储

@AppStorage 介绍

@AppStorage 用于在应用级别持久化存储简单数据，适用于保存全局用户偏好设置。

基本用法

import SwiftUI

struct AppStorageView: View {
    // 使用 @AppStorage 存储数据
    @AppStorage("userName") private var userName = "Guest"
    @AppStorage("appTheme") private var appTheme = "light"
    @AppStorage("notificationsEnabled") private var notificationsEnabled = true
    
    var body: some View {
        VStack(spacing: 20) {
            Text("App Storage")
                .font(.headline)
            
            TextField("User Name", text: $userName)
                .textFieldStyle(.roundedBorder)
            
            Picker("Theme", selection: $appTheme) {
                Text("Light").tag("light")
                Text("Dark").tag("dark")
                Text("Auto").tag("auto")
            }
            .pickerStyle(.segmented)
            
            Toggle("Enable Notifications", isOn: $notificationsEnabled)
            
            Text("Note: Data persists across app reinstalls")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(getThemeColor())
        .foregroundColor(appTheme == "dark" ? Color.white : Color.black)
    }
    
    private func getThemeColor() -> Color {
        switch appTheme {
        case "dark":
            return Color.black
        case "light":
            return Color.white
        default:
            return Color.white
        }
    }
}

#Preview {
    AppStorageView()
}

工作原理

@AppStorage 的工作原理：

1. 它将数据存储在应用的 UserDefaults 中
2. 数据会在应用重启后保持
3. 所有场景共享相同的存储
4. 适用于存储全局用户偏好设置

与 @SceneStorage 的区别

5.9 @FocusedValue：聚焦值

@FocusedValue 介绍

@FocusedValue 用于在视图层次结构中传递聚焦状态相关的值，适用于处理键盘焦点和上下文相关操作。

基本用法

import SwiftUI

// 定义聚焦值键
struct EditModeKey: FocusedValueKey {
    typealias Value = Bool
}

// 扩展 FocusedValues
extension FocusedValues {
    var isEditMode: EditModeKey.Value? {
        get { self[EditModeKey.self] }
        set { self[EditModeKey.self] = newValue }
    }
}

struct FocusedValueView: View {
    @State private var isEditMode = false
    @State private var text = "Hello, SwiftUI"
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Focused Value")
                .font(.headline)
            
            // 设置聚焦值
            TextField("Enter text", text: $text)
                .textFieldStyle(.roundedBorder)
                .focusedValue(\.isEditMode, true)
            
            Button("Toggle Edit Mode") {
                isEditMode.toggle()
            }
            .buttonStyle(.borderedProminent)
            
            // 子视图访问聚焦值
            FocusedChildView()
        }
        .padding()
        .environment(\.isEditMode, isEditMode)
    }
}

struct FocusedChildView: View {
    // 访问聚焦值
    @FocusedValue(\.isEditMode) private var isEditMode
    
    var body: some View {
        VStack {
            Text("Child View")
                .font(.subheadline)
            
            Text("Edit Mode: \(isEditMode ?? false ? "On" : "Off")")
            
            if isEditMode ?? false {
                Text("Editing is enabled!")
                    .foregroundColor(.green)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

#Preview {
    FocusedValueView()
}

工作原理

@FocusedValue 的工作原理：

1. 它通过 FocusedValues 字典传递值
2. 当焦点变化时，聚焦值会自动更新
3. 适用于与焦点相关的上下文信息
4. 可以自定义聚焦值键

适用场景

1. 键盘焦点：跟踪当前聚焦的视图
2. 上下文操作：根据聚焦状态显示不同的操作
3. 编辑模式：在编辑模式下显示额外的控件
4. 工具栏配置：根据当前聚焦的内容配置工具栏

5.10 状态驱动 UI 更新原理

核心原理

SwiftUI 的核心设计哲学是状态驱动：

UI = f(State)

这意味着：

1. UI 是状态的函数
2. 当状态改变时，UI 会自动更新
3. 给定相同的状态，总是渲染相同的 UI

更新流程

当状态改变时，SwiftUI 的更新流程如下：

1. 状态改变：用户操作或其他因素导致状态值发生变化
2. 检测变化：SwiftUI 检测到状态变化
3. 重新计算 body：重新调用受影响视图的 body 计算属性
4. 构建新视图树：生成新的视图层次结构
5. 对比差异：对比新旧视图树，找出变化的部分
6. 更新 UI：只更新发生变化的部分，保持其他部分不变

性能优化

SwiftUI 的状态驱动机制本身就很高效，因为：

1. 增量更新：只更新变化的部分
2. 值类型：视图是轻量级的值类型，创建成本低
3. 智能对比：使用高效的差异算法
4. 批处理：合并多个状态更新，减少渲染次数
5. 懒加载：只渲染可见的部分

5.11 状态管理最佳实践

1. 选择合适的状态管理工具

2. 状态管理原则

1. 单一数据源：每个状态应该有唯一的来源
2. 状态提升：将状态提升到需要访问它的所有视图的共同父视图
3. 最小化状态：只存储必要的状态，避免冗余
4. 状态隔离：将相关状态组织在一起，避免混乱
5. 可测试性：状态管理应该易于测试
6. 性能考虑：对于大型状态，考虑使用更细粒度的更新

3. 性能优化技巧

1. 使用 Equatable：为模型实现 Equatable 协议，避免不必要的更新
2. 视图分离：将复杂视图拆分为更小的子视图
3. @State 用于简单类型：@State 适合存储简单类型，复杂类型使用 @StateObject
4. 避免在 body 中创建对象：不要在 body 计算属性中创建新对象
5. 使用 .id() 强制更新：当需要强制视图更新时使用
6. 考虑使用 Combine：对于复杂的异步操作，使用 Combine 框架

实战：创建一个完整的状态管理示例

需求分析

创建一个包含多种状态管理技术的应用，包括：

1. 本地状态管理
2. 父子视图绑定
3. 可观察对象
4. 环境对象
5. 持久化存储

代码实现

import SwiftUI
import Combine

// 全局应用状态
class AppState: ObservableObject {
    @Published var isDarkMode = false
    @Published var currentUser: User? = nil
    
    func toggleTheme() {
        isDarkMode.toggle()
    }
    
    func login(user: User) {
        currentUser = user
    }
    
    func logout() {
        currentUser = nil
    }
}

// 用户模型
struct User: Identifiable, Equatable {
    let id = UUID()
    let name: String
    let email: String
}

// 主应用视图
struct StateManagementDemo: View {
    @StateObject private var appState = AppState()
    @AppStorage("lastLoggedInUser") private var lastLoggedInUser = ""
    
    var body: some View {
        NavigationStack {
            VStack(spacing: 20) {
                Text("状态管理演示")
                    .font(.largeTitle)
                    .fontWeight(.bold)
                
                // 主题切换
                Toggle("深色模式", isOn: $appState.isDarkMode)
                
                // 用户登录状态
                if appState.currentUser != nil {
                    Text("欢迎, \(appState.currentUser?.name ?? "")!")
                    Button("退出登录") {
                        appState.logout()
                        lastLoggedInUser = ""
                    }
                    .buttonStyle(.borderedProminent)
                    .tint(.red)
                } else {
                    LoginView()
                }
                
                // 导航链接
                NavigationLink("计数器示例", destination: CounterView())
                NavigationLink("待办事项示例", destination: TodoApp())
                NavigationLink("环境对象示例", destination: EnvironmentObjectDemo())
            }
            .padding()
        }
        .environmentObject(appState)
        .preferredColorScheme(appState.isDarkMode ? .dark : .light)
    }
}

// 登录视图
struct LoginView: View {
    @State private var name = ""
    @State private var email = ""
    @EnvironmentObject private var appState: AppState
    @AppStorage("lastLoggedInUser") private var lastLoggedInUser = ""
    
    var body: some View {
        VStack(spacing: 16) {
            TextField("姓名", text: $name)
                .textFieldStyle(.roundedBorder)
            TextField("邮箱", text: $email)
                .textFieldStyle(.roundedBorder)
            Button("登录") {
                let user = User(name: name, email: email)
                appState.login(user: user)
                lastLoggedInUser = name
            }
            .buttonStyle(.borderedProminent)
            .disabled(name.isEmpty || email.isEmpty)
            
            if !lastLoggedInUser.isEmpty {
                Text("上次登录: \(lastLoggedInUser)")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(8)
    }
}

// 计数器视图
struct CounterView: View {
    @State private var count = 0
    @SceneStorage("counterValue") private var storedCount = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("计数器")
                .font(.headline)
            Text("Count: \(count)")
                .font(.largeTitle)
                .fontWeight(.bold)
            HStack(spacing: 16) {
                Button("减1") {
                    count -= 1
                    storedCount = count
                }
                .buttonStyle(.bordered)
                Button("重置") {
                    count = 0
                    storedCount = 0
                }
                .buttonStyle(.bordered)
                Button("加1") {
                    count += 1
                    storedCount = count
                }
                .buttonStyle(.borderedProminent)
            }
            Text("场景存储值: \(storedCount)")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
        .onAppear {
            // 从场景存储恢复
            count = storedCount
        }
    }
}

// 待办事项应用
struct TodoApp: View {
    @State private var todos: [TodoItem] = [
        TodoItem(title: "学习 SwiftUI 状态管理"),
        TodoItem(title: "完成本章练习"),
        TodoItem(title: "构建示例应用")
    ]
    @State private var newTodoTitle = ""
    
    var body: some View {
        VStack {
            HStack(spacing: 8) {
                TextField("输入新的待办事项", text: $newTodoTitle)
                    .textFieldStyle(.roundedBorder)
                Button("添加") {
                    addTodo()
                }
                .buttonStyle(.borderedProminent)
                .disabled(newTodoTitle.isEmpty)
            }
            .padding()
            List {
                ForEach($todos) { $todo in
                    HStack {
                        Button(action: {
                            todo.isCompleted.toggle()
                        }) {
                            Image(systemName: todo.isCompleted ? "checkmark.circle.fill" : "circle")
                                .foregroundColor(todo.isCompleted ? .green : .gray)
                        }
                        .buttonStyle(.plain)
                        Text(todo.title)
                            .strikethrough(todo.isCompleted, color: .gray)
                            .foregroundColor(todo.isCompleted ? .secondary : .primary)
                        Spacer()
                        Button(action: {
                            deleteTodo(todo)
                        }) {
                            Image(systemName: "trash.fill")
                                .foregroundColor(.red)
                        }
                        .buttonStyle(.plain)
                    }
                }
            }
        }
        .navigationTitle("待办事项")
    }
    
    private func addTodo() {
        guard !newTodoTitle.isEmpty else { return }
        todos.append(TodoItem(title: newTodoTitle))
        newTodoTitle = ""
    }
    
    private func deleteTodo(_ todo: TodoItem) {
        if let index = todos.firstIndex(where: { $0.id == todo.id }) {
            todos.remove(at: index)
        }
    }
}

// 待办事项模型
struct TodoItem: Identifiable, Equatable {
    let id = UUID()
    var title: String
    var isCompleted = false
}

// 环境对象演示
struct EnvironmentObjectDemo: View {
    @EnvironmentObject private var appState: AppState
    
    var body: some View {
        VStack(spacing: 20) {
            Text("环境对象演示")
                .font(.headline)
            Text("当前主题: \(appState.isDarkMode ? "深色" : "浅色")")
            Text("登录状态: \(appState.currentUser != nil ? "已登录" : "未登录")")
            if let user = appState.currentUser {
                Text("用户: \(user.name)")
                Text("邮箱: \(user.email)")
            }
            Button("切换主题") {
                appState.toggleTheme()
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

#Preview {
    StateManagementDemo()
}

代码解析

1. AppState：使用 @StateObject 管理全局应用状态
2. User：符合 Identifiable 和 Equatable 协议的用户模型
3. StateManagementDemo：主应用视图，设置环境对象
4. LoginView：使用 @State 和 @AppStorage 管理登录状态
5. CounterView：使用 @State 和 @SceneStorage 管理计数器
6. TodoApp：使用 @State 管理待办事项列表
7. EnvironmentObjectDemo：使用 @EnvironmentObject 访问全局状态

小结

本章详细介绍了 SwiftUI 中的状态管理系统，包括：

• @State：用于管理视图的本地状态
• @Binding：用于父子视图之间的双向绑定
• @StateObject：用于管理可观察对象的状态
• @ObservedObject：用于观察外部传入的可观察对象
• @EnvironmentObject：用于访问全局环境对象
• @Environment：用于访问系统环境值
• @SceneStorage：用于场景级别的持久化存储
• @AppStorage：用于应用级别的持久化存储
• @FocusedValue：用于传递聚焦相关的值
• 状态驱动 UI 更新的原理
• 状态管理的最佳实践
• 一个完整的状态管理示例应用

通过本章的学习，你已经掌握了 SwiftUI 中所有的状态管理技术，能够根据不同的场景选择合适的状态管理工具，创建具有复杂交互功能的应用。

参考资料

• SwiftUI 官方文档
• Apple Developer Documentation: State
• Apple Developer Documentation: Binding
• Apple Developer Documentation: StateObject
• Apple Developer Documentation: ObservedObject
• Apple Developer Documentation: EnvironmentObject
• Apple Developer Documentation: Environment
• Apple Developer Documentation: SceneStorage
• Apple Developer Documentation: AppStorage
• Apple Developer Documentation: FocusedValue
• WWDC 2019: Data Flow Through SwiftUI
• WWDC 2020: Data Essentials in SwiftUI
• SwiftUI by Example

本内容为《SwiftUI 基础教程》第五章，欢迎关注后续更新。

2026年，大语言模型和视频生成大模型都在疯狂烧token，而具身机器人行业却正在经历“无token可烧”的局面。大模型能像人一样读书，而具身智能要去真实的世界里摸爬滚打才能获取数据——数据的匮乏成为了卡住全行业的瓶颈。

4月16日，智元机器人旗下觅蜂科技发布一站式物理 AI 数据服务平台，希望能让数据像水电一样即取即用。

“GPT5用了100万亿tokens的训练语料。1token约等于0.75个英语单词，如果一个正常人一分钟能说150个词，这个语料级就等于一个人要说100亿个小时才能说完。”觅蜂科技董事长兼 CEO 姚卯青说，“但具身智能不一样。今天，全世界的高质量数据汇聚在一起，可能也只有50万小时的规模。”

数据资源匮乏且扩容缓慢，是因为具身智能所需要的训练数据，比大预言模型需要的训练语料要难获得的多。在三维的开放世界，行业各家公司已经尝试了通过真机遥操或仿真数据等等各种方式去积累数据，但仍然难以摆脱高成本和增速慢的问题。

现在，最前沿的采集方式是“无本体采集”。

无本体采集（Object-free/Body-less Data Collection）是指在具身智能训练中，直接利用人类操作（手戴传感器夹爪）或轻量化设备记录动作，而非依赖昂贵的实体机器人本体进行遥控操作。它通过人手抓取、移动等方式记录高质量、多模态的动作数据，具有成本低、采集效率高、场景泛化性强等优势。

发布会上，觅蜂推出了 MEgo 系列无本体数据采集硬件及 MEgo Engine 数据治理引擎。MEgo 系列包含采集夹爪、头戴式采集设备等，设备具备超 300° 全景感知与亚毫秒级数据同步能力，支持在工厂、商超、家庭等全场景随时随地轻量化采集。

这款名为 MEgo Gripper 的夹爪全通道支持1080P 60fps，轨迹重建的精度可以达到一毫米，确保拿起一张纸的力度都可以被还原，“让客户拿到数据就能直接落地”，以及亚毫秒级无线时间同步。这个设备只有480g的重量，支持电池快换快拆，摆脱了电线，方便人“走到哪采到哪”。

MEgo Gripper

另一款头戴式采集设备MEgo View融合了头部超过300度的视野，以及两个附着在手腕上的局部相机，既可以兼顾超广域的环境，也可以做到腕部和手部操作细节的捕捉。它搭载7个高清摄像头，车规级九轴IMU（惯性测量单元），可以输出RGB图片、IMU，还有位姿、音频在内的全感官数据。

MEgo View

与夹爪设备一样，头戴式采集设备同样采用无线设计，支持电池快换，并能实现亚毫秒级无线时间同步。

轻量化的硬件，带来了数据采集门槛的降低。在发布会后的采访环节，姚卯青告诉包括36氪在内的媒体，他认为未来理想的采集者工作模式可能会类似于“美团骑手”——“大家可以兼职来做，但同时也要经过驿站的培训才能上岗。”

在软件上，MEgo系列解决方案背后有一套MEgo Engine 数据治理引擎，用来处理所有MEgo设备采集到的数据，包括数据的预处理、提取、评估等等，而且可以评估在机器人上的表现，实现一站式数据的多种标注。

姚卯青表示，觅蜂已经实现了真机遥操、无本体采集、仿真数据全范式覆盖，旨在“让高质量数据像水电一样即取即用。”该公司计划在 2026 年实现千万小时级数据产能，2030 年达成百亿小时级数据产能。

作为智元机器人旗下企业，觅蜂的定位却是面向其他机器人公司的To B数据服务平台。在活动后的采访环节，有媒体向姚卯青提问：“说服说服智元的竞争对手去买你们的数据？”

姚卯青回复说，“觅蜂作为一家独立的数据服务平台，所有的用户数据交易都有严格协议。数据的交易模式分为‘使用权’和‘所有权’两种，过去大部分用户都是选择了购买使用权而不是所有权，对于极个别选择购买所有权的客户，我们会进行严格的资产转移，在本地销毁数据。”

“智元并不是需要所有数据，它也没法获取觅蜂的数据。”姚卯青说，“智元现在向觅蜂获取数据的唯一途径，就是市场化下订单。智元不存在免费从觅蜂获取数据的途径。”

在发布会上，觅蜂宣布与京东云、百度云、阿里云、猎聘及贵州大数据集团等多家企业举行战略签约，各方将在数据生态、场景协同、算力支撑等领域展开深度合作。

When you run a PostgreSQL database in production, you rarely want every application and every developer to connect as the postgres superuser. A clean setup gives each service its own login role with a scoped set of privileges, so a bug or a leaked password cannot touch unrelated data.

PostgreSQL handles this with roles. A role can represent a single user, a group, or both at the same time, and privileges are granted to roles rather than to raw login accounts. This guide explains how to create roles, set passwords, grant and revoke privileges, and clean up roles you no longer need.

Roles vs Users in PostgreSQL #

Historically, PostgreSQL had separate CREATE USER and CREATE GROUP statements. Modern versions replaced both with a single concept: the role. A role with the LOGIN attribute can connect to the server, which makes it a user. A role without LOGIN is typically used as a group that other roles inherit privileges from.

In practice, CREATE USER is still valid and is treated as a shortcut for CREATE ROLE ... LOGIN. We will use both forms in this guide.

Connecting to PostgreSQL #

All the commands below run inside the psql shell. On most systems you can open it as the postgres system user:

sudo -u postgres psql

You will see a prompt like this:

postgres=#

Every SQL statement ends with a semicolon. If you forget it, psql keeps waiting for more input.

Creating a Role #

The simplest form of CREATE ROLE takes just a name:

CREATE ROLE linuxize;

This role exists but cannot log in yet and has no password.

To create a login role with a password, use LOGIN:

CREATE ROLE linuxize_login WITH LOGIN PASSWORD 'strong_password_here';

The equivalent shortcut is:

CREATE USER linuxize_user WITH PASSWORD 'strong_password_here';

Both statements produce the same result. Use whichever form reads more clearly in your scripts.

Useful Role Attributes #

You can combine several attributes in a single CREATE ROLE statement. These are the ones you will reach for most often:

• LOGIN - The role can connect to the server.
• PASSWORD 'secret' - Sets the login password.
• SUPERUSER - Grants full access, equivalent to the postgres role. Use sparingly.
• CREATEDB - The role may create new databases.
• CREATEROLE - The role may create and modify other roles.
• INHERIT - The role automatically inherits privileges of roles it is a member of. This is the default.
• VALID UNTIL 'timestamp' - Expires the password at the given time.
• CONNECTION LIMIT n - Caps the number of concurrent connections for this role.

For example, to create a login role that can also create databases and is limited to ten concurrent connections:

CREATE ROLE app_owner WITH LOGIN PASSWORD 'strong_password_here' CREATEDB CONNECTION LIMIT 10;

Listing Existing Roles #

To see every role on the server, use the \du meta-command:

\du

 List of roles
Role name | Attributes
-----------+------------------------------------------------------------
app_owner | Create DB, 10 connections
linuxize |
postgres | Superuser, Create role, Create DB, Replication, Bypass RLS

The Attributes column tells you what each role can do. A blank column means the role has no special attributes beyond the defaults, such as NOLOGIN and INHERIT.

Changing a Role #

Use ALTER ROLE to change attributes, rename a role, or reset a password. To change the password:

ALTER ROLE linuxize WITH PASSWORD 'new_password_here';

To grant an additional attribute:

ALTER ROLE linuxize CREATEDB;

To remove one, prefix it with NO:

ALTER ROLE linuxize NOCREATEDB;

Creating a Database for the Role #

It is common to give each application its own database owned by its login role. Create the database and assign ownership in one statement:

CREATE DATABASE linuxize_app OWNER linuxize;

The owner of a database has full control over it, so the role can create tables, schemas, and other objects without any further grants.

Granting Privileges #

Privileges in PostgreSQL are granted at several levels: database, schema, table, column, sequence, and function. The syntax is consistent across levels:

GRANT privilege_list ON object_type object_name TO role_name;

Database-level Privileges #

To let a role connect to a database and create objects in it:

GRANT CONNECT ON DATABASE linuxize_app TO linuxize;
GRANT CREATE ON DATABASE linuxize_app TO linuxize;

CONNECT controls whether the role can open a session to the database. CREATE controls whether it can create schemas.

Schema-level Privileges #

To let a role create and use objects inside a schema:

GRANT USAGE ON SCHEMA public TO linuxize;
GRANT CREATE ON SCHEMA public TO linuxize;

USAGE is required for almost every operation inside the schema. CREATE lets the role add new tables, views, or functions.

Table-level Privileges #

Table privileges match the common SQL operations:

GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE orders TO linuxize;

To grant every available table privilege at once:

GRANT ALL PRIVILEGES ON TABLE orders TO linuxize;

To grant the same privileges on every existing table in a schema:

GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO linuxize;

This only affects tables that exist at the moment you run the command. Tables created later are not covered.

Default Privileges for Future Objects #

To cover tables created in the future, set default privileges:

ALTER DEFAULT PRIVILEGES IN SCHEMA public
 GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO linuxize;

From this point on, any new table created in public by the current role inherits the listed privileges for linuxize.

Revoking Privileges #

REVOKE is the mirror of GRANT and uses the same structure:

REVOKE INSERT, UPDATE, DELETE ON TABLE orders FROM linuxize;

To strip every privilege on a table:

REVOKE ALL PRIVILEGES ON TABLE orders FROM linuxize;

Revoking a privilege only affects the privileges you previously granted. Ownership is a separate concept: the owner of an object always keeps full control over it, regardless of grants.

Group Roles #

To manage privileges for a team, create a role without LOGIN and add members to it:

CREATE ROLE readonly;
GRANT CONNECT ON DATABASE linuxize_app TO readonly;
GRANT USAGE ON SCHEMA public TO readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly;

GRANT readonly TO linuxize;

linuxize now inherits every privilege granted to readonly. To remove the membership later:

REVOKE readonly FROM linuxize;

This pattern scales better than granting privileges role by role, because you change permissions in one place.

Deleting a Role #

To drop a role, use DROP ROLE:

DROP ROLE linuxize;

PostgreSQL refuses the command if the role still owns any objects or holds any privileges. To clean these up first, reassign the objects and drop dependent privileges in each database where the role owns objects:

REASSIGN OWNED BY linuxize TO postgres;
DROP OWNED BY linuxize;
DROP ROLE linuxize;

REASSIGN OWNED transfers ownership of objects owned by the role in the current database, and DROP OWNED removes any remaining privileges there. If the role owns objects in other databases, repeat the cleanup in each one before dropping the role.

Quick Reference #

Troubleshooting #

ERROR: permission denied for schema public
Grant USAGE on the schema: GRANT USAGE ON SCHEMA public TO role_name;. On PostgreSQL 15 and later, the public schema is no longer writable by default, so you may also need GRANT CREATE ON SCHEMA public.

ERROR: role "name" cannot be dropped because some objects depend on it
Reassign and drop the role’s objects first: REASSIGN OWNED BY name TO postgres; DROP OWNED BY name;, then run DROP ROLE name; again.

FATAL: password authentication failed for user
Check that the role has LOGIN and that the authentication method in pg_hba.conf matches the client (for example, md5 or scram-sha-256). Reload the configuration with SELECT pg_reload_conf(); after editing pg_hba.conf.

New tables are not visible to a read-only user
Grants on ALL TABLES IN SCHEMA only cover tables that exist at grant time. Set ALTER DEFAULT PRIVILEGES for the owning role so new tables inherit the read permissions automatically.

FAQ #

What is the difference between CREATE USER and CREATE ROLE?
CREATE USER is a shortcut for CREATE ROLE ... LOGIN. Both create the same kind of object. Use CREATE USER when you want a login account and CREATE ROLE when you are creating a group role without login.

Can a single role be both a user and a group?
Yes. A role with LOGIN can still be granted to other roles. Members inherit its privileges as long as INHERIT is set, which is the default.

How do I change the owner of an existing database?
Use ALTER DATABASE db_name OWNER TO new_owner;. The new owner gains full control over the database and its objects.

Do I need to restart PostgreSQL after creating a role?
No. Role changes take effect immediately. Only changes to pg_hba.conf or the main server configuration require a reload or restart.

Conclusion #

Roles are the single unit of access control in PostgreSQL. Give each application its own login role, group shared privileges into group roles, and use ALTER DEFAULT PRIVILEGES so future objects stay consistent with your current policy.

For related reading, see how to check the PostgreSQL version and the installation guide for your distribution under the PostgreSQL tag .

Bun v1.3.12 带来了内置无头浏览器自动化、终端 Markdown 渲染、进程内定时任务等新特性，同时在性能优化和兼容性方面取得了显著进展。本文将通过示例代码和实战指南，帮助开发者快速上手这些新功能。

大家好，我是 iDao。10 年全栈开发，做过架构、运维，也在落地 AI 工程化。这里不搞虚的，只分享能直接跑、能直接用的代码、方案和经验。内容包括：全栈开发实战、系统搭建、可视化大屏、自动化部署、AI 应用、私有化部署等。关注我，一起写能落地的代码，做能上线的项目。

一、Bun.WebView：内置无头浏览器自动化

Bun v1.3.12 引入了 Bun.WebView，这是一个内置的无头浏览器自动化工具，支持 WebKit 和 Chrome 两种后端，提供类似 Playwright 的 API。

主要特性

• 原生事件模拟：所有输入均以操作系统级别事件分发，无法被网站检测为自动化。
• 自动等待：支持选择器操作的自动等待，确保元素可见、稳定后再执行。
• 跨平台支持：WebKit 默认用于 macOS，Chrome 后端支持所有平台。

示例代码

以下代码展示了如何使用 Bun.WebView 进行页面导航、点击和截图：

await using view = new Bun.WebView({ width: 800, height: 600 });
await view.navigate("https://bun.sh");

await view.click("a[href='/docs']"); // 等待元素可点击并执行点击
await view.scroll(0, 400); // 模拟滚轮事件

const title = await view.evaluate("document.title");
const png = await view.screenshot({ format: "jpeg", quality: 90 });
await Bun.write("page.jpg", png);

二、Markdown 渲染：终端直接预览

Bun v1.3.12 支持直接在终端渲染 Markdown 文件，提供了两种方式：

1. 运行 bun ./file.md。
2. 使用 Bun.markdown.ansi() API。

示例代码

以下代码展示了如何使用 Bun.markdown.ansi() 渲染 Markdown：

const out = Bun.markdown.ansi("# Hello\n\n**bold** and *italic*\n");
process.stdout.write(out);

// 启用超链接
const linked = Bun.markdown.ansi("[docs](https://bun.sh)", { hyperlinks: true });
process.stdout.write(linked);

三、Bun.cron：进程内定时任务

Bun.cron 新增了回调函数支持，适合长时间运行的服务和容器。

示例代码

以下代码展示了如何使用 Bun.cron 定时执行异步任务：

Bun.cron("* * * * *", async () => {
  console.log("每分钟执行一次");
});

四、性能优化与新特性

URLPattern 性能提升

URLPattern.test() 和 URLPattern.exec() 的性能提升了最高 2.3 倍。

const pattern = new URLPattern({ pathname: "/api/users/:id/posts/:postId" });
pattern.test("https://example.com/api/users/42/posts/123");

Bun.stripANSI 和 Bun.stringWidth 的 SIMD 优化

Bun.stripANSI 和 Bun.stringWidth 的性能显著提升，处理速度最高提升 11 倍。

bun build 构建优化

修复了线程池问题，使低核机器上的构建速度提升了 1.43 倍。

五、Bug 修复与兼容性改进

• 修复了多个 Node.js 兼容性问题，例如 process.env 在某些情况下为空的问题。
• 改进了 Bun.serve 的 TCP_DEFER_ACCEPT 支持，降低了 HTTP 请求延迟。

六、升级指南与验证步骤

升级到 v1.3.12

运行以下命令升级到最新版本：

bun upgrade

验证新功能

验证 Bun.WebView 是否正常工作：

await using view = new Bun.WebView();
await view.navigate("https://example.com");
console.log(await view.title);

七、总结

Bun v1.3.12 带来了众多令人兴奋的新特性和性能优化，尤其是 Bun.WebView 和 Bun.cron 的引入，为开发者提供了更多可能性。通过本文的示例代码和实战指南，相信你已经掌握了这些新功能的使用方法。

关注 【iDao技术魔方】，获取更多全栈到AI可落地的实战干货。

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

第4章：基础布局系统

4.1 垂直布局：VStack

VStack 介绍

VStack 是 SwiftUI 中用于垂直堆叠视图的容器，它会将子视图按垂直方向排列。VStack 是构建垂直布局的基础组件，适用于需要从上到下排列的界面元素。

基本用法

// 基本垂直栈

VStack {

    Text("第一行")

    Text("第二行")

    Text("第三行")

}

  


// 带间距和对齐的垂直栈

VStack(alignment: .leading, spacing: 20) {

    Text("左对齐")

    Text("第二行")

    Text("第三行")

}

.padding()

对齐方式

VStack 提供了三种主要的对齐方式：

• .leading：左对齐

• .center：居中对齐（默认）

• .trailing：右对齐

• .top、.bottom：在嵌套布局中使用

// 不同对齐方式

VStack(alignment: .leading) {

    Text("左对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

  


VStack(alignment: .center) {

    Text("居中对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

  


VStack(alignment: .trailing) {

    Text("右对齐")

    Text("这是一行更长的文本")

    Text("短文本")

}

.padding()

嵌套 VStack

VStack 可以嵌套使用，创建更复杂的布局结构。

// 嵌套垂直栈

VStack(spacing: 10) {

    Text("标题")

        .font(.headline)

    

    VStack(alignment: .leading, spacing: 8) {

        Text("项目 1")

        Text("项目 2")

        Text("项目 3")

    }

    .padding()

    .background(Color.gray.opacity(0.1))

    .cornerRadius(8)

    

    Button("确认") {}

}

.padding()

适用场景

• 表单布局：从上到下排列的输入字段

• 列表项：垂直排列的内容块

• 页面结构：标题、内容、按钮的垂直布局

• 卡片式布局：垂直堆叠的信息卡片

性能考虑

• VStack 会根据子视图的大小自动调整高度

• 对于大量子视图，考虑使用 LazyVStack 来提高性能

• 避免过深的嵌套，可能会影响渲染性能

4.2 水平布局：HStack

HStack 介绍

HStack 是 SwiftUI 中用于水平堆叠视图的容器，它会将子视图按水平方向排列。HStack 是构建水平布局的基础组件，适用于需要从左到右排列的界面元素。

基本用法

// 基本水平栈

HStack {

    Text("左侧")

    Text("中间")

    Text("右侧")

}

  


// 带间距和对齐的水平栈

HStack(alignment: .top, spacing: 20) {

    Text("顶部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

对齐方式

HStack 提供了三种主要的对齐方式：

• .top：顶部对齐

• .center：居中对齐（默认）

• .bottom：底部对齐

• .leading、.trailing：在嵌套布局中使用

// 不同对齐方式

HStack(alignment: .top) {

    Text("顶部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

  


HStack(alignment: .center) {

    Text("居中对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

  


HStack(alignment: .bottom) {

    Text("底部对齐")

    Text("这是一行\n多行文本")

    Text("短文本")

}

.padding()

空间分配

HStack 可以使用 Spacer 来分配空间，实现更灵活的布局。

// 空间分配

HStack {

    Text("左侧")

    Spacer()  // 占据剩余空间

    Text("右侧")

}

.padding()

  


// 带比例的空间分配

HStack {

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

    Spacer()

    Text("1/4 宽度")

        .frame(maxWidth: .infinity)

}

.padding()

适用场景

• 工具栏：水平排列的操作按钮

• 列表项内容：左侧图标、中间文本、右侧箭头

• 表单行：标签和输入框的水平排列

• 导航栏：左侧返回按钮、中间标题、右侧操作按钮

性能考虑

• HStack 会根据子视图的大小自动调整宽度

• 对于大量子视图，考虑使用 LazyHStack 来提高性能

• 注意水平空间不足时的布局行为，可能需要使用 ScrollView

4.3 层叠布局：ZStack

ZStack 介绍

ZStack 是 SwiftUI 中用于层叠视图的容器，它会将子视图按层叠方式排列，后面的视图会覆盖前面的视图。ZStack 是构建叠加效果的基础组件，适用于需要层级关系的界面元素。

基本用法

// 基本层叠

ZStack {

    Color.blue  // 背景

    Text("前景文本")

        .foregroundStyle(.white)

        .font(.largeTitle)

}

.frame(height: 200)

  


// 多层叠

ZStack {

    // 底层

    Rectangle()

        .fill(Color.yellow)

        .frame(width: 200, height: 200)

    

    // 中层

    Circle()

        .fill(Color.green)

        .frame(width: 150, height: 150)

    

    // 顶层

    Text("ZStack")

        .font(.headline)

}

对齐方式

ZStack 提供了多种对齐方式，可以精确控制子视图的位置：

• .topLeading、.top、.topTrailing

• .leading、.center、.trailing

• .bottomLeading、.bottom、.bottomTrailing

// 不同对齐方式

ZStack(alignment: .topLeading) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("左上角")

        .padding(10)

}

  


ZStack(alignment: .center) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("居中")

}

  


ZStack(alignment: .bottomTrailing) {

    Rectangle()

        .fill(Color.gray.opacity(0.2))

        .frame(width: 300, height: 200)

    

    Text("右下角")

        .padding(10)

}

实际应用

// 带徽章的图标

ZStack(alignment: .topTrailing) {

    Image(systemName: "bell")

        .font(.system(size: 24))

    

    Circle()

        .fill(Color.red)

        .frame(width: 16, height: 16)

        .overlay {

            Text("3")

                .font(.system(size: 10))

                .foregroundStyle(.white)

        }

        .offset(x: 4, y: -4)

}

  


// 卡片覆盖效果

ZStack {

    RoundedRectangle(cornerRadius: 12)

        .fill(Color.white)

        .shadow(radius: 4)

        .frame(width: 300, height: 200)

    

    VStack {

        Text("卡片标题")

            .font(.headline)

        Text("卡片内容")

            .foregroundStyle(.secondary)

    }

    .padding()

    

    // 右上角标签

    Text("NEW")

        .font(.caption)

        .foregroundStyle(.white)

        .padding(4)

        .background(Color.blue)

        .cornerRadius(4)

        .offset(x: 45, y: -10)

}

适用场景

• 带背景的文本：文本叠加在背景之上

• 徽章效果：通知图标上的数字徽章

• 卡片布局：带有覆盖元素的信息卡片

• 复杂 UI 组件：需要多层叠加的自定义控件

• 模态视图：半透明覆盖层

性能考虑

• ZStack 会按照添加顺序渲染视图，后面的视图会覆盖前面的

• 对于复杂的叠加效果，注意渲染性能

• 考虑使用 offset 修饰符来微调子视图位置

4.4 间距与对齐

间距设置

间距是布局中的重要因素，它决定了视图之间的关系和视觉舒适度。

// VStack 间距

VStack(spacing: 16) {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

  


// HStack 间距

HStack(spacing: 20) {

    Text("左")

    Text("中")

    Text("右")

}

  


// 嵌套栈的间距

VStack(spacing: 20) {

    Text("标题")

    

    HStack(spacing: 10) {

        Button("按钮 1") {}

        Button("按钮 2") {}

    }

    

    Text("底部文本")

}

对齐设置

对齐决定了视图在容器中的位置，影响整体布局的一致性。

// 垂直对齐

VStack(alignment: .leading) {

    Text("左对齐")

    Text("这是一行更长的文本")

}

  


// 水平对齐

HStack(alignment: .center) {

    Text("顶部")

        .font(.largeTitle)

    Text("底部")

        .font(.footnote)

}

  


// 层叠对齐

ZStack(alignment: .bottom) {

    Image(systemName: "photo")

        .resizable()

        .aspectRatio(contentMode: .fit)

        .frame(height: 200)

    

    Text("图片标题")

        .padding()

        .background(Color.black.opacity(0.5))

        .foregroundStyle(.white)

        .frame(maxWidth: .infinity, alignment: .center)

}

内边距与外边距

内边距（padding）和外边距是控制视图与其他元素之间空间的重要工具。

// 内边距

VStack {

    Text("带内边距的文本")

        .padding()  // 四周内边距

    

    Text("自定义内边距")

        .padding(.horizontal, 20)  // 水平内边距

        .padding(.vertical, 10)    // 垂直内边距

}

  


// 外边距

VStack {

    Text("带外边距的文本")

}

.padding()  // 给整个 VStack 添加内边距

  


// 组合使用

Text("文本")

    .padding(10)  // 内边距

    .background(Color.yellow)

    .padding(10)  // 外边距（看起来像内边距）

    .background(Color.blue)

适用场景

• 表单设计：通过间距和对齐创建整齐的表单

• 卡片布局：使用内边距和外边距创建视觉层次感

• 响应式设计：根据不同屏幕尺寸调整间距

• 可访问性：适当的间距提高内容的可读性

最佳实践

• 保持一致的间距系统：使用统一的间距值（如 8、16、24 等）

• 考虑内容的重要性：重要内容之间应有更大的间距

• 响应式调整：在不同屏幕尺寸上调整间距

• 测试不同设备：确保在各种设备上布局都美观

4.5 垫片：Spacer

Spacer 介绍

Spacer 是 SwiftUI 中用于占据剩余空间的视图，它会自动扩展以填充可用空间。Spacer 是实现灵活布局的重要工具，特别适用于需要将元素推到容器边缘的场景。

基本用法

// 水平布局中的 Spacer

HStack {

    Text("左侧")

    Spacer()  // 占据中间的所有空间

    Text("右侧")

}

.padding()

  


// 垂直布局中的 Spacer

VStack {

    Text("顶部")

    Spacer()  // 占据中间的所有空间

    Text("底部")

}

.frame(height: 200)

.padding()

灵活使用

// 顶部对齐

VStack {

    Text("标题")

    Spacer()

}

.frame(height: 200)

.padding()

  


// 底部对齐

VStack {

    Spacer()

    Text("底部文本")

}

.frame(height: 200)

.padding()

  


// 两端对齐

HStack {

    Text("左侧")

    Spacer()

    Text("中间")

    Spacer()

    Text("右侧")

}

.padding()

实际应用

// 工具栏布局

HStack {

    Button("返回") {

        print("返回")

    }

    

    Spacer()

    

    Text("页面标题")

    

    Spacer()

    

    Button("更多") {

        print("更多")

    }

}

.padding()

.background(Color(.systemBackground))

  


// 表单底部按钮

VStack {

    // 表单内容

    ForEach(0..<3) {

        Text("表单项 \($0 + 1)")

            .padding()

            .background(Color.gray.opacity(0.1))

            .cornerRadius(8)

            .padding(.horizontal)

    }

    

    Spacer()

    

    // 底部按钮

    Button("提交") {

        print("提交")

    }

    .buttonStyle(.borderedProminent)

    .padding()

}

适用场景

• 工具栏：将标题居中，按钮放在两侧

• 表单：将提交按钮固定在底部

• 卡片：将内容推到顶部，操作按钮放在底部

• 导航栏：创建平衡的布局

性能考虑

• Spacer 是轻量级视图，对性能影响很小

• 合理使用 Spacer 可以减少不必要的几何计算

• 避免在不需要的地方使用 Spacer，可能会导致意外的布局行为

4.6 布局修饰符

框架修饰符

frame 修饰符用于控制视图的大小和对齐方式。

// 设置固定大小

Text("固定大小")

    .frame(width: 200, height: 100)

    .background(Color.yellow)

  


// 设置最大和最小大小

Text("灵活大小")

    .frame(minWidth: 100, maxWidth: 300, minHeight: 50, maxHeight: 150)

    .background(Color.blue)

  


// 填充父容器

Text("填充")

    .frame(maxWidth: .infinity, maxHeight: .infinity)

    .background(Color.green)

  


// 带对齐的框架

Text("右对齐")

    .frame(width: 200, alignment: .trailing)

    .background(Color.gray.opacity(0.2))

位置修饰符

position 和 offset 修饰符用于调整视图的位置。

// 绝对位置

Text("绝对位置")

    .position(x: 100, y: 100)

  


// 相对偏移

Text("相对偏移")

    .offset(x: 50, y: 20)

  


// 组合使用

ZStack {

    Text("基础位置")

        .background(Color.yellow)

    

    Text("偏移位置")

        .offset(x: 50, y: 30)

        .background(Color.red)

}

布局优先级

layoutPriority 修饰符用于设置视图的布局优先级。

HStack {

    Text("短文本")

        .layoutPriority(1)  // 高优先级

        .background(Color.yellow)

    

    Text("这是一段非常长的文本，会被截断")

        .background(Color.blue)

}

.frame(width: 200)

适用场景

• 响应式设计：根据屏幕尺寸调整视图大小

• 自定义布局：精确控制视图位置

• 复杂界面：处理不同优先级的内容

• 动态布局：根据内容自动调整

4.7 网格布局：LazyVGrid 和 LazyHGrid

网格布局介绍

LazyVGrid 和 LazyHGrid 是 SwiftUI 中用于创建网格布局的容器，它们支持延迟加载，适用于大量数据。网格布局使用 GridItem 来定义列或行的大小和间距。

基本用法

// 定义网格列

let columns = [

    GridItem(.flexible()),

    GridItem(.flexible()),

    GridItem(.flexible())

]

  


// 垂直网格

ScrollView {

    LazyVGrid(columns: columns, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(height: 80)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                        .font(.headline)

                )

        }

    }

    .padding()

}

  


// 水平网格

let rows = [

    GridItem(.flexible()),

    GridItem(.flexible())

]

  


ScrollView(.horizontal) {

    LazyHGrid(rows: rows, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(width: 100)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                        .font(.headline)

                )

        }

    }

    .padding()

}

GridItem 配置

GridItem 支持多种大小配置：

• .fixed：固定大小

• .flexible：灵活大小（默认）

• .adaptive：自适应大小，尽可能多的列

// 固定大小的列

let fixedColumns = [

    GridItem(.fixed(100)),

    GridItem(.fixed(100)),

    GridItem(.fixed(100))

]

  


// 自适应列数

let adaptiveColumns = [

    GridItem(.adaptive(minimum: 80, maximum: 120))

]

  


// 混合配置

let mixedColumns = [

    GridItem(.fixed(80)),

    GridItem(.flexible()),

    GridItem(.fixed(80))

]

适用场景

• 图片网格：相册、产品展示

• 图标网格：应用图标、功能入口

• 数据网格：表格数据展示

• 响应式布局：自适应不同屏幕尺寸

4.8 列表和表单：List 和 Form

List 列表

List 是 SwiftUI 中用于显示滚动列表的容器，自动处理单元格布局和数据展示。

// 基本列表

List {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

  


// 带分组的列表

List {

    Section(header: Text("分组 1")) {

        Text("项目 1")

        Text("项目 2")

    }

    

    Section(header: Text("分组 2")) {

        Text("项目 3")

        Text("项目 4")

    }

}

  


// 动态列表

let items = ["苹果", "香蕉", "橙子", "葡萄"]

  


List(items, id: \.self) { item in

    HStack {

        Image(systemName: "fruit")

        Text(item)

    }

}

Form 表单

Form 是专门用于表单布局的容器，提供了预设的样式和间距。

// 基本表单

Form {

    TextField("用户名", text: .constant(""))

    SecureField("密码", text: .constant(""))

    Toggle("记住密码", isOn: .constant(true))

    Button("登录") {}

}

  


// 带分组的表单

Form {

    Section(header: Text("个人信息")) {

        TextField("姓名", text: .constant(""))

        TextField("邮箱", text: .constant(""))

    }

    

    Section(header: Text("偏好设置")) {

        Toggle("接收通知", isOn: .constant(true))

        Picker("主题", selection: .constant("浅色")) {

            Text("浅色").tag("浅色")

            Text("深色").tag("深色")

        }

    }

    

    Section {

        Button("保存设置") {}

    }

}

适用场景

• List：显示结构化数据列表、设置项、联系人

• Form：创建用户输入表单、设置页面、注册登录页面

4.9 几何读取器：GeometryReader

GeometryReader 介绍

GeometryReader 是一个特殊的容器，它可以读取父视图的几何信息（尺寸和位置），并根据这些信息来布局子视图。

// 基本用法

GeometryReader { geometry in

    VStack {

        Text("宽度: \(geometry.size.width)")

        Text("高度: \(geometry.size.height)")

        Text("安全区域: \(geometry.safeAreaInsets.top)")

    }

    .frame(width: geometry.size.width, height: geometry.size.height)

    .background(Color.gray.opacity(0.1))

}

  


// 根据父视图大小调整子视图

GeometryReader { geometry in

    HStack(spacing: 0) {

        Color.red

            .frame(width: geometry.size.width * 0.3)

        Color.green

            .frame(width: geometry.size.width * 0.3)

        Color.blue

            .frame(width: geometry.size.width * 0.4)

    }

}

.frame(height: 100)

  


// 自适应网格

GeometryReader { geometry in

    let columns = Int(geometry.size.width / 100)

    let gridItems = Array(repeating: GridItem(.flexible()), count: max(columns, 1))

    

    LazyVGrid(columns: gridItems, spacing: 10) {

        ForEach(1..<10) { index in

            Rectangle()

                .fill(Color(hue: Double(index)/10, saturation: 0.8, brightness: 0.8))

                .frame(height: 80)

                .overlay(

                    Text("\(index)")

                        .foregroundColor(.white)

                )

        }

    }

    .padding()

}

适用场景

• 响应式布局：根据屏幕尺寸调整布局

• 自定义布局：需要精确控制尺寸的场景

• 动画效果：基于几何信息创建动画

• 复杂布局：需要基于父视图尺寸的布局

4.10 其他重要布局组件

Divider 分隔线

Divider 用于在视图之间创建水平或垂直的分隔线。

// 水平分隔线

VStack {

    Text("顶部")

    Divider()

    Text("底部")

}

  


// 垂直分隔线

HStack {

    Text("左侧")

    Divider()

    Text("右侧")

}

.frame(height: 50)

Group 视图分组

Group 用于将多个视图组合在一起，作为一个整体应用修饰符。

// 分组应用修饰符

Group {

    Text("项目 1")

    Text("项目 2")

    Text("项目 3")

}

.foregroundColor(.blue)

.font(.headline)

  


// 条件渲染

Group {

    if true {

        Text("显示这个")

    } else {

        Text("显示那个")

    }

}

自定义布局（iOS 16+）

iOS 16 引入了 Layout 协议，允许创建完全自定义的布局。

// 简单的自定义布局

struct SimpleLayout: Layout {

    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {

        // 计算布局尺寸

        return CGSize(width: proposal.width ?? 300, height: proposal.height ?? 200)

    }

    

    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {

        // 放置子视图

        for (index, subview) in subviews.enumerated() {

            let x = bounds.minX + CGFloat(index) * 50

            let y = bounds.midY

            subview.place(at: CGPoint(x: x, y: y), proposal: .unspecified)

        }

    }

}

  


// 使用自定义布局

SimpleLayout {

    Text("1")

    Text("2")

    Text("3")

    Text("4")

}

.frame(height: 100)

.background(Color.gray.opacity(0.1))

实战：创建一个登录页面

需求分析

创建一个包含以下元素的登录页面：

1. 应用图标和标题

2. 用户名输入框

3. 密码输入框（带可见性切换）

4. 登录按钮

5. 忘记密码链接

6. 注册链接

代码实现

import SwiftUI

  


struct LoginView: View {

    // 状态变量

    @State private var username = ""

    @State private var password = ""

    @State private var showPassword = false

    

    var body: some View {

        ZStack {

            // 背景

            LinearGradient(

                colors: [.blue.opacity(0.1), .purple.opacity(0.1)],

                startPoint: .top,

                endPoint: .bottom

            )

            .ignoresSafeArea()

            

            VStack(spacing: 24) {

                // 应用图标和标题

                VStack(spacing: 12) {

                    Image(systemName: "lock.fill")

                        .resizable()

                        .aspectRatio(contentMode: .fit)

                        .frame(width: 80, height: 80)

                        .foregroundStyle(.blue)

                    

                    Text("欢迎回来")

                        .font(.largeTitle)

                        .fontWeight(.bold)

                    

                    Text("请登录以继续")

                        .foregroundStyle(.secondary)

                }

                

                // 输入区域

                VStack(spacing: 16) {

                    // 用户名输入框

                    TextField(

                        "用户名",

                        text: $username,

                        prompt: Text("请输入用户名")

                    )

                    .textFieldStyle(.roundedBorder)

                    .padding(.horizontal)

                    

                    // 密码输入框

                    ZStack(alignment: .trailing) {

                        if showPassword {

                            TextField(

                                "密码",

                                text: $password,

                                prompt: Text("请输入密码")

                            )

                        } else {

                            SecureField(

                                "密码",

                                text: $password,

                                prompt: Text("请输入密码")

                            )

                        }

                        

                        Button(action: {

                            showPassword.toggle()

                        }) {

                            Image(systemName: showPassword ? "eye.slash.fill" : "eye.fill")

                                .foregroundStyle(.secondary)

                                .padding(.trailing, 16)

                        }

                    }

                    .textFieldStyle(.roundedBorder)

                    .padding(.horizontal)

                    

                    // 忘记密码

                    HStack {

                        Spacer()

                        Button("忘记密码?") {

                            print("忘记密码")

                        }

                        .foregroundStyle(.blue)

                        .padding(.trailing)

                    }

                }

                

                // 登录按钮

                Button("登录") {

                    print("登录")

                }

                .buttonStyle(.borderedProminent)

                .tint(.blue)

                .padding(.horizontal)

                .frame(maxWidth: .infinity)

                

                // 注册链接

                HStack {

                    Text("还没有账号?")

                    Button("立即注册") {

                        print("注册")

                    }

                    .foregroundStyle(.blue)

                }

                

                Spacer()

            }

            .padding(.top, 60)

        }

    }

}

  


#Preview {

    LoginView()

}

代码解析

1. ZStack：用于层叠背景和内容，创建深度感

2. VStack：用于垂直排列各个部分，保持页面结构清晰

3. HStack：用于水平排列忘记密码链接和注册链接

4. Spacer：用于底部填充空间，将内容推到顶部

5. TextField 和 SecureField：用于用户输入

6. Button：用于操作按钮

7. LinearGradient：用于创建美观的背景渐变

8. ** @State**：用于管理视图状态

实战：创建一个产品详情页

需求分析

创建一个产品详情页，包含以下元素：

1. 产品图片

2. 产品标题和价格

3. 产品描述

4. 规格选择

5. 购买按钮

代码实现

import SwiftUI

  


struct ProductDetailView: View {

    // 状态变量

    @State private var selectedColor = "红色"

    @State private var selectedSize = "M"

    @State private var quantity = 1

    

    // 产品数据

    let productName = "SwiftUI 高级教程"

    let productPrice = "¥99.00"

    let productDescription = "本教程涵盖了 SwiftUI 的高级特性，包括动画、手势、布局和性能优化等内容。通过实际项目案例，帮助你掌握 SwiftUI 的核心概念和最佳实践。"

    let colors = ["红色", "蓝色", "黑色"]

    let sizes = ["S", "M", "L", "XL"]

    

    var body: some View {

        ScrollView {

            VStack(spacing: 20) {

                // 产品图片

                ZStack {

                    Color.gray.opacity(0.1)

                        .frame(height: 300)

                    

                    Image(systemName: "book.fill")

                        .resizable()

                        .aspectRatio(contentMode: .fit)

                        .frame(width: 150, height: 150)

                        .foregroundStyle(.blue)

                }

                

                // 产品信息

                VStack(alignment: .leading, spacing: 12) {

                    HStack {

                        Text(productName)

                            .font(.title)

                            .fontWeight(.bold)

                        Spacer()

                        Text(productPrice)

                            .font(.title)

                            .fontWeight(.bold)

                            .foregroundStyle(.red)

                    }

                    

                    // 产品描述

                    Text(productDescription)

                        .foregroundStyle(.secondary)

                        .lineLimit(nil)

                    

                    // 颜色选择

                    Text("颜色")

                        .font(.headline)

                    HStack(spacing: 10) {

                        ForEach(colors, id: \.self) {

                            color in

                            Button(action: {

                                selectedColor = color

                            }) {

                                Text(color)

                                    .padding(8)

                                    .background(selectedColor == color ? Color.blue : Color.gray.opacity(0.1))

                                    .foregroundStyle(selectedColor == color ? .white : .primary)

                                    .cornerRadius(4)

                            }

                        }

                    }

                    

                    // 尺寸选择

                    Text("尺寸")

                        .font(.headline)

                    HStack(spacing: 10) {

                        ForEach(sizes, id: \.self) {

                            size in

                            Button(action: {

                                selectedSize = size

                            }) {

                                Text(size)

                                    .padding(8)

                                    .background(selectedSize == size ? Color.blue : Color.gray.opacity(0.1))

                                    .foregroundStyle(selectedSize == size ? .white : .primary)

                                    .cornerRadius(4)

                            }

                        }

                    }

                    

                    // 数量选择

                    Text("数量")

                        .font(.headline)

                    HStack {

                        Button(action: {

                            if quantity > 1 {

                                quantity -= 1

                            }

                        }) {

                            Image(systemName: "minus.circle")

                                .font(.system(size: 24))

                        }

                        

                        Text("\(quantity)")

                            .font(.headline)

                            .padding(.horizontal, 20)

                        

                        Button(action: {

                            quantity += 1

                        }) {

                            Image(systemName: "plus.circle")

                                .font(.system(size: 24))

                        }

                    }

                }

                .padding()

                

                // 购买按钮

                Button("加入购物车") {

                    print("加入购物车")

                }

                .buttonStyle(.borderedProminent)

                .tint(.blue)

                .padding(.horizontal)

                .frame(maxWidth: .infinity)

                .padding(.bottom, 30)

            }

        }

        .navigationTitle("产品详情")

        .navigationBarTitleDisplayMode(.inline)

    }

}

  


#Preview {

    ProductDetailView()

}

代码解析

1. ScrollView：用于滚动显示产品详情

2. ZStack：用于显示产品图片和背景

3. VStack：用于垂直排列产品信息

4. HStack：用于水平排列价格、颜色选择、尺寸选择和数量控制

5. Button：用于选择颜色、尺寸和调整数量

6. ** @State**：用于管理用户选择的状态

小结

本章详细介绍了 SwiftUI 中的基础布局系统，包括：

• VStack：垂直堆叠视图，适用于从上到下的布局

• HStack：水平堆叠视图，适用于从左到右的布局

• ZStack：层叠视图，适用于需要层级关系的布局

• 间距与对齐：控制视图之间的空间和位置关系

• Spacer：占据剩余空间，实现灵活布局

• 布局修饰符：控制视图的大小、位置和优先级

• 网格布局：LazyVGrid、LazyHGrid，用于创建网格

• 列表和表单：List、Form，用于显示列表和表单

• 几何读取器：GeometryReader，用于获取父视图尺寸

• 其他布局组件：Divider、Group、自定义布局

• 实战案例：登录页面和产品详情页的完整实现

布局最佳实践

1. 保持简洁：使用最少的容器实现所需布局

2. 嵌套合理：避免过深的布局嵌套

3. 响应式设计：考虑不同屏幕尺寸的布局适配

4. 性能优化：对于大量数据使用 Lazy 容器

5. 一致性：保持间距和对齐的一致性

6. 可访问性：确保布局对所有用户都友好

通过本章的学习，你已经掌握了 SwiftUI 中最基本的布局技巧，能够创建各种常见的布局结构。在实际开发中，你可以根据具体需求选择合适的布局容器和技术，创建美观、响应式的用户界面。

参考资料

• SwiftUI 官方文档

• Apple Developer Documentation: VStack

• Apple Developer Documentation: HStack

• Apple Developer Documentation: ZStack

• Apple Developer Documentation: Spacer

• Apple Developer Documentation: LazyVGrid

• Apple Developer Documentation: List

• Apple Developer Documentation: GeometryReader

• SwiftUI by Example

• SwiftUI Layout Essentials

本内容为《SwiftUI 基础教程》第四章，欢迎关注后续更新。

示例代码都放这里啦，有需要的可以下载学习。swiftUIDemo

3.1 文本显示：Text

Text 组件介绍

Text 是 SwiftUI 中最基本的视图组件，用于显示文本内容。它支持富文本、字体样式、颜色等多种属性。

基本用法

// 基本文本
Text("Hello, SwiftUI!")

// 带样式的文本
Text("Hello, SwiftUI!")
    .font(.largeTitle)         // 设置字体大小
    .fontWeight(.bold)         // 设置字重
    .foregroundStyle(.blue)    // 设置文本颜色
    .italic()                  // 斜体
    .underline()               // 下划线
    .strikethrough()           // 删除线

富文本

// 富文本
Text("Hello, \(Text("SwiftUI").foregroundStyle(.blue).bold())!")

// 多行文本
Text("这是一段多行文本，\n可以通过反斜杠 n 来换行，\n或者直接在字符串中换行。")
    .multilineTextAlignment(.center)  // 多行文本对齐方式
    .lineLimit(3)                     // 限制行数
    .truncationMode(.tail)            // 截断方式

本地化

// 本地化文本
Text("welcome_message")  // 从 Localizable.strings 文件中读取

// 带参数的本地化
Text("greeting", comment: "欢迎语")

// 格式化文本
let name = "张三"
Text("欢迎 %@", name)

日期和数字格式化

// 日期格式化
let date = Date()
Text(date, style: .date)           // 仅日期
Text(date, style: .time)           // 仅时间
Text(date, style: .relative)       // 相对时间
Text(date, style: .offset)         // 时间偏移
Text(date, style: .timer)          // 计时器

// 数字格式化
let number = 123456.789
Text(number, format: .number)
Text(number, format: .currency(code: "CNY"))
Text(number, format: .percent)

3.2 图片显示：Image

Image 组件介绍

Image 用于显示图片，可以从系统图标、资源文件或网络加载图片。

基本用法

// 系统图标
Image(systemName: "star.fill")

// 资源文件图片
Image("avatar")

// 网络图片 (iOS 15+)
AsyncImage(url: URL(string: "https://example.com/image.jpg")) { phase in
    switch phase {
    case .empty:
        ProgressView()  // 加载中
    case .success(let image):
        image
            .resizable()
            .aspectRatio(contentMode: .fill)
    case .failure:
        Image(systemName: "photo")  // 加载失败
    @unknown default:
        EmptyView()
    }
}

图片修饰符

Image("avatar")
    .resizable()                 // 可调整大小
    .aspectRatio(contentMode: .fit)  // 内容模式
    .frame(width: 100, height: 100)  // 设置大小
    .clipShape(Circle())         // 裁剪形状
    .overlay(                    // 叠加内容
        Circle()
            .stroke(Color.blue, lineWidth: 2)
    )
    .shadow(radius: 5)           // 阴影
    .opacity(0.8)                // 透明度

系统图标

// 系统图标
Image(systemName: "heart.fill")
    .foregroundStyle(.red)
    .font(.system(size: 24))

// 多色图标 (iOS 15+)
Image(systemName: "person.fill.badge.plus")
    .symbolRenderingMode(.multicolor)

// 可变颜色图标
Image(systemName: "star")
    .foregroundStyle(.yellow)

3.3 按钮交互：Button

Button 组件介绍

Button 用于创建可点击的按钮，支持多种样式和交互方式。

基本用法

// 基本按钮
Button("点击我") {
    print("按钮被点击了")
}

// 带图标的按钮
Button {
    print("按钮被点击了")
} label: {
    HStack {
        Image(systemName: "star.fill")
        Text("喜欢")
    }
}

// 带角色的按钮
Button("删除", role: .destructive) {
    print("删除操作")
}

按钮样式

// 边框按钮
Button("边框按钮") {
    // 操作
}
.buttonStyle(.bordered)

// 突出显示的按钮
Button("突出按钮") {
    // 操作
}
.buttonStyle(.borderedProminent)
.tint(.blue)  // 按钮颜色

// 胶囊按钮
Button("胶囊按钮") {
    // 操作
}
.buttonStyle(.borderedProminent)
.tint(.green)
.cornerRadius(20)

// 文本按钮
Button("文本按钮") {
    // 操作
}
.buttonStyle(.plain)

禁用状态

@State private var isEnabled = false

Button("禁用按钮") {
    // 操作
}
.disabled(!isEnabled)
.opacity(isEnabled ? 1.0 : 0.5)

3.4 输入控件：TextField、SecureField、TextEditor

TextField 文本输入框

@State private var text = ""

TextField("请输入文本", text: $text)
    .textFieldStyle(.roundedBorder)  // 边框样式
    .padding()                      // 内边距
    .keyboardType(.default)         // 键盘类型
    .autocapitalization(.sentences) // 自动大写
    .autocorrectionDisabled(true)   // 禁用自动纠正

// 带提示的 TextField
TextField(
    "请输入用户名",
    text: $text,
    prompt: Text("用户名不能为空")
        .foregroundStyle(.secondary)
)
.textFieldStyle(.roundedBorder)

SecureField 安全输入框

@State private var password = ""

SecureField("请输入密码", text: $password)
    .textFieldStyle(.roundedBorder)
    .padding()

// 带可见性切换的密码输入
@State private var showPassword = false

ZStack(alignment: .trailing) {
    if showPassword {
        TextField("请输入密码", text: $password)
    } else {
        SecureField("请输入密码", text: $password)
    }
    Button(action: {
        showPassword.toggle()
    }) {
        Image(systemName: showPassword ? "eye.slash.fill" : "eye.fill")
            .foregroundStyle(.secondary)
            .padding(.trailing, 8)
    }
}
.textFieldStyle(.roundedBorder)
.padding()

TextEditor 多行文本编辑器

@State private var message = ""

TextEditor(text: $message)
    .frame(height: 150)           // 设置高度
    .border(Color.gray.opacity(0.3), width: 1)  // 边框
    .cornerRadius(8)              // 圆角
    .padding()
    .foregroundStyle(.primary)    // 文本颜色

// 带占位符的 TextEditor
ZStack(alignment: .topLeading) {
    TextEditor(text: $message)
        .frame(height: 150)
        .padding(8)
    
    if message.isEmpty {
        Text("请输入消息...")
            .foregroundStyle(.secondary)
            .padding(10)
            .allowsHitTesting(false)  // 允许点击穿透
    }
}
.border(Color.gray.opacity(0.3), width: 1)
.cornerRadius(8)
.padding()

3.5 开关与选择：Toggle、Picker、Slider、Stepper

Toggle 开关

@State private var isEnabled = false

Toggle("启用功能", isOn: $isEnabled)
    .toggleStyle(.switch)  // 开关样式
    .padding()

// 带图标的 Toggle
Toggle(isOn: $isEnabled) {
    HStack {
        Image(systemName: "bell.fill")
        Text("接收通知")
    }
}
.toggleStyle(.switch)
.padding()

Picker 选择器

@State private var selectedOption = "选项1"
let options = ["选项1", "选项2", "选项3"]

// 分段控件样式
Picker("选择", selection: $selectedOption) {
    ForEach(options, id: \.self) {
        Text($0)
    }
}
.pickerStyle(.segmented)
.padding()

// 菜单样式
Picker("选择", selection: $selectedOption) {
    ForEach(options, id: \.self) {
        Text($0)
    }
}
.pickerStyle(.menu)
.padding()

// 轮盘样式（iOS 14+）
@State private var selectedColor = Color.red
let colors: [Color] = [.red, .green, .blue, .yellow]

Picker("颜色", selection: $selectedColor) {
    ForEach(colors, id: \.self) {
        ColorPickerView(color: $0)
    }
}
.pickerStyle(.wheel)
.frame(height: 200)
.padding()

// 辅助视图
struct ColorPickerView: View {
    let color: Color
    var body: some View {
        HStack {
            Rectangle()
                .fill(color)
                .frame(width: 20, height: 20)
                .cornerRadius(4)
            Text(String(describing: color))
        }
    }
}

Slider 滑块

@State private var value = 0.5

Slider(value: $value, in: 0...1)
    .padding()
    .tint(.blue)  // 滑块颜色

// 带标签的滑块
Slider(
    value: $value,
    in: 0...1,
    label: { Text("亮度") },
    minimumValueLabel: { Text("暗") },
    maximumValueLabel: { Text("亮") }
)
.padding()

// 整数滑块
@State private var intValue = 5

Slider(value: Binding(
    get: { Double(intValue) },
    set: { intValue = Int($0) }
), in: 0...10, step: 1)
.padding()
Text("值：\(intValue)")

Stepper 步进器

@State private var count = 0

Stepper("数量：\(count)", value: $count)
    .padding()

// 带范围的步进器
Stepper(
    "数量：\(count)",
    value: $count,
    in: 0...10,
    step: 2
)
.padding()

// 带标签的步进器
Stepper {
    Text("数量：\(count)")
} onIncrement: {
    count += 1
    print("增加到：\(count)")
} onDecrement: {
    count -= 1
    print("减少到：\(count)")
}
.padding()

3.6 进度指示：ProgressView

不确定进度

// 基本进度指示器
ProgressView()

// 带标签的进度指示器
ProgressView("加载中...")

// 带样式的进度指示器
ProgressView("处理中...")
    .progressViewStyle(.circular)
    .tint(.blue)
    .padding()

确定进度

@State private var progress = 0.0

ProgressView("下载进度", value: progress, total: 1.0)
    .padding()

// 带百分比的进度条
ProgressView(
    value: progress,
    total: 1.0,
    label: { Text("下载进度") },
    currentValueLabel: { Text("\(Int(progress * 100))%") }
)
.padding()

// 水平进度条样式
ProgressView(value: progress, total: 1.0)
    .progressViewStyle(.linear)
    .tint(.green)
    .frame(height: 10)
    .padding()

实战：创建一个用户设置页面

需求分析

创建一个包含以下元素的用户设置页面：

1. 个人信息区域
2. 通知设置（开关）
3. 主题选择（选择器）
4. 字体大小（滑块）
5. 清除缓存按钮
6. 退出登录按钮

代码实现

import SwiftUI

struct SettingsView: View {
    // 状态变量
    @State private var notificationsEnabled = true
    @State private var selectedTheme = "浅色"
    @State private var fontSize = 16.0
    @State private var cacheSize = "128 MB"
    
    // 主题选项
    let themes = ["浅色", "深色", "跟随系统"]
    
    var body: some View {
        NavigationStack {
            List {
                // 个人信息区域
                Section {
                    HStack {
                        Image(systemName: "person.circle.fill")
                            .resizable()
                            .aspectRatio(contentMode: .fill)
                            .frame(width: 60, height: 60)
                            .foregroundStyle(.blue)
                        
                        VStack(alignment: .leading, spacing: 4) {
                            Text("张三")
                                .font(.headline)
                            Text("zhangsan@example.com")
                                .font(.subheadline)
                                .foregroundStyle(.secondary)
                        }
                        Spacer()
                        Image(systemName: "chevron.right")
                            .foregroundStyle(.secondary)
                    }
                    .padding(.vertical, 8)
                }
                
                // 通知设置
                Section("通知设置") {
                    Toggle("接收推送通知", isOn: $notificationsEnabled)
                    Toggle("声音提醒", isOn: $notificationsEnabled)
                    Toggle("振动提醒", isOn: $notificationsEnabled)
                }
                
                // 外观设置
                Section("外观设置") {
                    Picker("主题", selection: $selectedTheme) {
                        ForEach(themes, id: \.self) {
                            Text($0)
                        }
                    }
                    .pickerStyle(.menu)
                    
                    VStack(alignment: .leading, spacing: 8) {
                        Text("字体大小：\(Int(fontSize))")
                        Slider(value: $fontSize, in: 12...24, step: 1)
                            .tint(.blue)
                    }
                }
                
                // 存储设置
                Section("存储设置") {
                    HStack {
                        Text("缓存大小")
                        Spacer()
                        Text(cacheSize)
                            .foregroundStyle(.secondary)
                    }
                    Button("清除缓存") {
                        // 清除缓存逻辑
                        print("清除缓存")
                    }
                    .foregroundStyle(.blue)
                }
                
                // 账户设置
                Section {
                    Button("关于我们") {
                        // 关于我们逻辑
                    }
                    Button("隐私政策") {
                        // 隐私政策逻辑
                    }
                    Button("退出登录", role: .destructive) {
                        // 退出登录逻辑
                    }
                }
            }
            .navigationTitle("设置")
            .navigationBarTitleDisplayMode(.inline)
        }
    }
}

#Preview {
    SettingsView()
}

代码解析

• List 和 Section：使用列表和分组组织设置项
• NavigationStack：提供导航功能
• Toggle：用于开关设置
• Picker：用于主题选择
• Slider：用于调整字体大小
• Button：用于操作按钮
• HStack 和 VStack：用于布局
• @State：用于管理视图状态

小结

本章介绍了 SwiftUI 中的基础视图组件，包括：

• Text：文本显示，支持富文本、本地化和格式化
• Image：图片显示，支持系统图标、资源文件和网络图片
• Button：按钮交互，支持多种样式和角色
• 输入控件：TextField、SecureField、TextEditor
• 选择控件：Toggle、Picker、Slider、Stepper
• 进度指示：ProgressView
• 一个完整的用户设置页面实战

通过本章的学习，你已经掌握了 SwiftUI 中最常用的基础组件，能够创建各种常见的用户界面元素。

参考资料

• SwiftUI 官方文档
• Apple Developer Documentation: Text
• Apple Developer Documentation: Image
• Apple Developer Documentation: Button
• SwiftUI by Example

本内容为《SwiftUI 基础教程》第三章，欢迎关注后续更新。