0Pricing
Swift Academy · Lezione

Pacchetti library e executable

Comprenda la differenza tra pacchetti library ed executable di SwiftPM: come dichiarare product/target, utilizzare le librerie ed eseguire gli eseguibili.

Pacchetti library e executable è una lezione Swift Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Swift Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Swift Academy include 3 lezioni in totale.

Due tipi di prodotto

I pacchetti SwiftPM possono essere distribuiti come libreria (codice da importare) o come eseguibile (uno strumento eseguibile).

  • Dichiari i prodotti in Package.swift
  • Organizzi i target e i sorgenti
  • Utilizzi le librerie; esegua gli eseguibili

Nozioni di base sui prodotti libreria

Una libreria espone moduli che altri possono import. Non è richiesto alcun punto di ingresso.

// 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

Nozioni di base sui prodotti eseguibili

Un eseguibile ha un punto di ingresso (main.swift) e genera un binario eseguibile (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)")

Dipendere dalle librerie

Utilizzi .package e .product nel progetto che usa la libreria per importarla. Blocchi la versione con versioni semantiche (ad esempio, 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.")

Separare le responsabilità

Condivida il codice: inserisca la logica principale in una libreria e mantenga l'eseguibile come un wrapper sottile.

// 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.")

Comandi di compilazione ed esecuzione

Generi le librerie con swift build ed esegua i test con swift test. Esegua gli eseguibili tramite swift run <name>.

// 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.")

Definizione di libreria ed eseguibile

Verifica rapida: che cosa distingue una libreria da un eseguibile in SwiftPM?

Riepilogo

Riepilogo: utilizzi una libreria per condividere il codice tra le app e un eseguibile per distribuire una CLI o uno strumento. Dichiari prodotti e target in Package.swift e dipenda dalle librerie tramite .package + .product.

Domande Frequenti

La lezione «Pacchetti library e executable» è gratuita?

Sì — il testo completo di «Pacchetti library e executable» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Swift Academy, passa a CoddyKit PRO. Il corso Swift Academy include 3 lezioni in totale.

Cosa imparerò in «Pacchetti library e executable»?

Comprenda la differenza tra pacchetti library ed executable di SwiftPM: come dichiarare product/target, utilizzare le librerie ed eseguire gli eseguibili. Eserciti Swift Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Swift Academy?

Non è richiesta alcuna esperienza precedente. Swift Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «Pacchetti library e executable»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Swift Academy?

Sì. Ogni lezione Swift Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Pacchetti library e executable
  2. Versionamento semantico e tagging delle release
  3. Nozioni di base sulla CI con swift test e gli artefatti
← Torna a Swift Academy