快速的开发
- 作者仓库星标 0
- 作者仓库 skills-registry
- 领域
- 人工智能
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @tomevault-io · 未声明许可证
- 上下文用量评级
- 低消耗
- 接入复杂程度
- 需简单配置
- 是否需要外部接口密钥
- 不需要
- 兼容的系统
- macOS
- 运行环境要求
- 未检出明确要求
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 网络行为
- 允许外网请求
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
## When to Use
- Building iOS, iPadOS, macOS, watchOS, or tvOS applications.
- Writing Swift code for any Apple platform or server-side Swift.
- Working with UIKit view controllers, Auto Layout, or navigation.
- Building declarative UIs with SwiftUI.
- Implementing async/await concurrency or reactive data flows.
- Writing unit or UI tests with XCTest.
## Swift Language Patterns
### Optionals — Null Safety
```swift
// guard let — preferred for early returns
func greet(name: String?) {
guard let name = name else { return }
print("Hello, \(name)")
}
// Optional chaining + nil coalescing
let length = user?.profile?.bio?.count
let displayName = user.nickname ?? user.fullName ?? "Anonymous"
```
### Protocols and Extensions
```swift
protocol Repository {
associatedtype Entity: Identifiable
func findById(_ id: Entity.ID) async throws -> Entity?
func save(_ entity: Entity) async throws
}
// Default implementations via extension
extension Repository {
func findByIdOrFail(_ id: Entity.ID) async throws -> Entity {
guard let entity = try await findById(id) else {
throw RepositoryError.notFound(id: "\(id)")
}
return entity
}
}
// Extend existing types
extension Date {
var isToday: Bool { Calendar.current.isDateInToday(self) }
}
extension Array where Element: Numeric {
var sum: Element { reduce(0, +) }
}
```
### Enums with Associated Values
```swift
enum NetworkResult<T: Decodable> {
case success(T)
case failure(NetworkError)
case loading
}
enum Route: Hashable {
case home
case userDetail(userId: UUID)
case settings(tab: SettingsTab)
}
// Pattern matching
switch result {
case .success(let data):
updateUI(with: data)
case .failure(let error) where error.isRetryable:
scheduleRetry()
case .failure(let error):
showError(error)
case .loading:
showSpinner()
}
```
### Generics
```swift
func fetch<T: Decodable>(from url: URL) async throws -> T {
let (data, response) = try await URLSession.shared.data(from: url)
guard let httpResponse = response as? HTTPURLResponse,
(200...299).contains(httpResponse.statusCode) else {
throw NetworkError.invalidResponse
}
return try JSONDecoder().decode(T.self, from: data)
}
```
## UIKit Patterns
### View Controller Lifecycle
```swift
class UserDetailViewController: UIViewController {
private let userId: UUID
private let repository: UserRepository
// Dependency injection via initializer
init(userId: UUID, repository: UserRepository) {
self.userId = userId
self.repository = repository
super.init(nibName: nil, bundle: nil)
}
required init?(coder: NSCoder) { fatalError("Use init(userId:repository:)") }
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
Task {
do {
let user = try await repository.findByIdOrFail(userId)
updateUI(with: user)
} catch { showError(error) }
}
}
private func setupUI() {
view.backgroundColor = .systemBackground
let stack = UIStackView(arrangedSubviews: [nameLabel, emailLabel])
stack.axis = .vertical
stack.spacing = 12
stack.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(stack)
NSLayoutConstraint.activate([
stack.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 20),
stack.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 16),
stack.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -16),
])
}
}
```
## SwiftUI Essentials
### State, Binding, ObservableObject
```swift
import SwiftUI
// @State for local view state
struct CounterView: View {
@State private var count = 0
var body: some View {
Button("Count: \(count)") { count += 1 }
.buttonStyle(.borderedProminent)
}
}
// @Binding for child → parent communication
struct SettingsToggle: View {
@Binding var isEnabled: Bool
let title: String
var body: some View { Toggle(title, isOn: $isEnabled) }
}
// ObservableObject + @StateObject for shared state (pre-iOS 17)
class UserViewModel: ObservableObject {
@Published var user: User?
@Published var isLoading = false
@MainActor
func loadUser(id: UUID) async {
isLoading = true
defer { isLoading = false }
user = try? await UserRepository.shared.findById(id)
}
}
struct UserView: View {
@StateObject private var vm = UserViewModel()
let userId: UUID
var body: some View {
Group {
if vm.isLoading { ProgressView() }
else if let user = vm.user { Text(user.name) }
}
.task { await vm.loadUser(id: userId) }
}
}
```
### iOS 17+ Observation Framework
```swift
import Observation
@Observable
class AppState {
var currentUser: User?
var theme: Theme = .system
}
struct RootView: View {
@State private var appState = AppState()
var body: some View {
ContentView().environment(appState)
}
}
struct ContentView: View {
@Environment(AppState.self) private var appState
var body: some View {
// Tracks only properties actually read
Text(appState.currentUser?.name ?? "Guest")
}
}
```
## Async/Await Concurrency
```swift
// Parallel async with async let
func fetchDashboard() async throws -> Dashboard {
async let profile = fetchProfile()
async let notifications = fetchNotifications()
return Dashboard(
profile: try await profile,
notifications: try await notifications
)
}
// Actor for thread-safe mutable state
actor ImageCache {
private var cache: [URL: UIImage] = [:]
func image(for url: URL) async throws -> UIImage {
if let cached = cache[url] { return cached }
let (data, _) = try await URLSession.shared.data(from: url)
guard let image = UIImage(data: data) else {
throw ImageError.invalidData
}
cache[url] = image
return image
}
}
```
## XCTest Testing
```swift
import XCTest
@testable import MyApp
final class UserRepositoryTests: XCTestCase {
private var sut: UserRepository!
private var mockAPI: MockAPIClient!
override func setUp() {
super.setUp()
mockAPI = MockAPIClient()
sut = UserRepository(api: mockAPI)
}
override func tearDown() {
sut = nil
mockAPI = nil
super.tearDown()
}
func test_findById_returnsUser_whenAPISucceeds() async throws {
// Given
let expected = User(id: UUID(), name: "Ada", email: "ada@example.com")
mockAPI.stubbedResponse = expected
// When
let user = try await sut.findById(expected.id)
// Then
XCTAssertEqual(user?.name, "Ada")
}
func test_findById_throwsError_whenAPIFails() async {
mockAPI.stubbedError = NetworkError.serverError(500)
do {
_ = try await sut.findById(UUID())
XCTFail("Expected error")
} catch {
XCTAssertTrue(error is NetworkError)
}
}
}
```
## Project Structure
```
MyApp/
├── App/
│ └── MyApp.swift # @main entry point
├── Features/
│ ├── Auth/ (Views/, ViewModels/, Models/)
│ └── Dashboard/
├── Core/
│ ├── Network/ (APIClient.swift, Endpoints.swift)
│ ├── Storage/
│ └── Extensions/
├── Resources/ (Assets.xcassets, Localizable.strings)
└── Tests/ (UnitTests/, UITests/)
```
## Dependency Management (SPM)
```swift
// Package.swift — swift-tools-version: 5.9
import PackageDescription
let package = Package(
name: "MyLibrary",
platforms: [.iOS(.v16), .macOS(.v13)],
products: [.library(name: "MyLibrary", targets: ["MyLibrary"])],
dependencies: [
.package(url: "https://github.com/Alamofire/Alamofire.git", from: "5.8.0"),
],
targets: [
.target(name: "MyLibrary", dependencies: ["Alamofire"]),
.testTarget(name: "MyLibraryTests", dependencies: ["MyLibrary"]),
]
)
```
## Best Practices
### DO
- **Use `guard let` for early returns** — keeps the happy path unindented and readable.
- **Use `async/await`** over completion handlers — cleaner, safer, integrates with structured
concurrency.
- **Use `@MainActor`** for view models and UI code — prevents data races on the main thread.
- **Use protocols for dependencies** — enables testing via mock/stub injection.
- **Use value types (structs/enums)** by default — classes only for reference semantics or
inheritance.
- **Use `[weak self]` in escaping closures** to prevent retain cycles.
- **Use `Codable`** for JSON — built-in, type-safe serialization.
- **Use `@Observable` (iOS 17+)** over `ObservableObject` — simpler and more efficient.
- **Test behavior, not implementation** — assert outcomes through public API.
### DON'T
- **DON'T force-unwrap (`!`) in production code** — use `guard let`, `if let`, or `??` instead.
- **DON'T use `var` when `let` works** — immutability by default prevents bugs.
- **DON'T put business logic in Views/ViewControllers** — extract to view models or use cases.
- **DON'T ignore `@Sendable` warnings** — they indicate potential data races.
- **DON'T use singletons for dependencies** — inject via initializers for testability.
- **DON'T block the main thread** — use `async/await` or `DispatchQueue` for heavy work.
- **DON'T use `NotificationCenter` for everything** — prefer delegates, closures, or Combine.
- **DON'T skip `setUp`/`tearDown`** in XCTest — fresh state per test prevents flaky tests.
- **DON'T catch errors silently** — at minimum log them; surface to user when appropriate.
- **DON'T ignore App Store Review Guidelines** — validate entitlements, Info.plist privacy keys, and
prohibited APIs.
## Commands
```bash
# Swift packages
swift package init --type library
swift build
swift test
# Xcode
xcodebuild -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15' build
xcodebuild test -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15'
```
## Resources
- [Swift Language Guide](https://docs.swift.org/swift-book/)
- [Apple Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/)
- [Swift Package Manager Docs](https://www.swift.org/documentation/package-manager/)
---
> Source: [dallay/agents-skills](https://github.com/dallay/agents-skills) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-23 -->
章节与文件索引
按说明文件中的顺序排列。
何时使用
溶解氧
不要
资源
文件/命令 -> guard let · async/await · @MainActor · [weak self] · Codable · @Observable · ObservableObject · ) in production code** — use
内容校验值 -> 07c1ec18d85c
当前原文的自动摘译,尚未人工审校。
何时使用
构建 iOS、iPadOS、macOS、watchOS 或 tvOS 应用程序。为任何 Apple 平台或服务器端 Swift 编写 Swift 代码。使用 UIKit 视图控制器、自动布局或导航。使用 SwiftUI 构建声明式 UI。实现异步/等待并发或反应式数据流。
溶解氧
使用
guard let提前返回——保持快乐路径不缩进且可读。在完成处理程序上使用async/await——更干净、更安全,与结构化并发集成。将@MainActor用于视图模型和 UI 代码 — 防止主线程上的数据竞争。使用依赖协议 - 允许通过模拟/存根注入进行测试。不要
不要在生产代码中强制解包 (
!) — 请使用guard let、if let或??代替。当let工作时,不要使用var— 默认情况下不变性可以防止错误。不要将业务逻辑放入视图/视图控制器中 - 提取到视图模型或用例。不要忽视@Sendable警告——它们表明潜在的数据竞争。不要使用单例作为依赖项——通过初始化器注入以实现可测试性。资源
Swift 语言指南 Apple 人机界面指南 Swift Package Manager 文档 来源:dallay/agents-skills — 由 TomeVault 分发。