0Pricing
Swift Academy · Lektion

Bibliotheks- und ausführbare Pakete

Verstehen Sie den Unterschied zwischen library - und executable -Paketen in SwiftPM: Deklarieren Sie Produkte/Ziele, verwenden Sie Bibliotheken und führen Sie ausführbare Dateien aus.

Bibliotheks- und ausführbare Pakete ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 3 Lektionen.

Zwei Produkttypen

SwiftPM-Pakete können als Bibliothek (Code zum Importieren) oder als ausführbares Produkt (ein ausführbares Werkzeug) bereitgestellt werden.

  • Definieren Sie Produkte in Package.swift
  • Organisieren Sie Targets und Quelldateien
  • Verwenden Sie Bibliotheken; führen Sie ausführbare Produkte aus

Grundlagen von Bibliotheksprodukten

Eine Bibliothek stellt Module bereit, die andere mit import importieren können. Ein Einstiegspunkt ist nicht erforderlich.

// Package.swift (illustrative library)
// import PackageDescription
// let package = Package(
//   name: "GreeterLib",
//   products: [
//     .library(name: "GreeterLib", targets: ["GreeterLib"]),
//   ],
//   targets: [
//     .target(name: "GreeterLib"),
//     .testTarget(name: "GreeterLibTests", dependencies: ["GreeterLib"]),
//   ]
// )
//
// Sources/GreeterLib/Greeter.swift
public struct Greeter {
    public init() {}
    public func hello(_ name: String) -> String { "Hello, \\(name)!" }
}
print(Greeter().hello("Ana")) // demo run

Grundlagen ausführbarer Produkte

Ein ausführbares Produkt besitzt einen Einstiegspunkt (main.swift) und erstellt eine ausführbare Binärdatei (swift run).

// Package.swift (illustrative executable)
// import PackageDescription
// let package = Package(
//   name: "greeter",
//   products: [ .executable(name: "greeter", targets: ["App"]) ],
//   targets: [ .executableTarget(name: "App") ]
// )
//
// Sources/App/main.swift
let args = CommandLine.arguments.dropFirst()
let who = args.first ?? "world"
print("Hello, \\(who)")

Von Bibliotheken abhängen

Verwenden Sie beim nutzenden Paket .package und .product, um eine Bibliothek zu importieren. Fixieren Sie die Version mit semantischen Versionen (z. B. from: "1.0.0").

// In the consumer's Package.swift (illustrative):
// dependencies: [
//   .package(url: "https://example.com/GreeterLib.git", from: "1.0.0")
// ],
// targets: [
//   .executableTarget(
//     name: "App",
//     dependencies: [ .product(name: "GreeterLib", package: "GreeterLib") ]
//   )
// ]
//
// Sources/App/main.swift
// import GreeterLib
struct Dummy {}
print("Add import GreeterLib in your app to use its APIs.")

Zuständigkeiten aufteilen

Teilen Sie Code: Legen Sie die Kernlogik in eine Bibliothek und halten Sie das ausführbare Produkt als schlanke Hülle.

// Package.swift can expose both a library and an executable:
// products: [
//   .library(name: "GreeterLib", targets: ["GreeterLib"]),
//   .executable(name: "greeter", targets: ["GreeterCLI"]),
// ],
// targets: [
//   .target(name: "GreeterLib"),
//   .executableTarget(name: "GreeterCLI", dependencies: ["GreeterLib"]),
// ]
//
// Reuse logic in the library; keep CLI thin.
print("Tip: put reusable logic in the library; the CLI depends on it.")

Befehle zum Erstellen und Ausführen

Erstellen Sie Bibliotheken mit swift build und testen Sie sie mit swift test. Führen Sie ausführbare Produkte mit swift run <name> aus.

// Library: build & test
//   swift build
//   swift test
//
// Executable: run & release
//   swift run greeter Ana
//   swift build -c release
//
// Artifact:
//   .build/release/greeter
print("Use swift run for executables; import libraries into apps.")

Definition: Bibliothek vs. ausführbares Produkt

Kurze Überprüfung: Wodurch unterscheiden sich eine Bibliothek und ein ausführbares Produkt in SwiftPM?

Zusammenfassung

Zusammenfassung: Verwenden Sie eine Bibliothek, um Code über mehrere Apps hinweg zu teilen, und ein ausführbares Produkt, um eine CLI beziehungsweise ein Werkzeug bereitzustellen. Definieren Sie Produkte und Targets in Package.swift und hängen Sie über .package + .product von Bibliotheken ab.

Häufig gestellte Fragen

Ist die Lektion „Bibliotheks- und ausführbare Pakete“ kostenlos?

Ja — der vollständige Text von „Bibliotheks- und ausführbare Pakete“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Bibliotheks- und ausführbare Pakete“?

Verstehen Sie den Unterschied zwischen library - und executable -Paketen in SwiftPM: Deklarieren Sie Produkte/Ziele, verwenden Sie Bibliotheken und führen Sie ausführbare Dateien aus. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Bibliotheks- und ausführbare Pakete“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Bibliotheks- und ausführbare Pakete
  2. Semantische Versionierung und Release-Tags
  3. CI-Grundlagen mit swift test und Artefakten
← Zurück zu Swift Academy