0Pricing
Swift Academy · Lección

Paquetes de biblioteca frente a paquetes ejecutables

Comprenda los paquetes de library y executable de SwiftPM: cómo declarar productos/targets, consumir bibliotecas y ejecutar ejecutables.

Paquetes de biblioteca frente a paquetes ejecutables es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 3 lecciones en total.

Dos tipos de producto

Los paquetes de SwiftPM pueden distribuirse como una biblioteca (código que se puede importar) o como un ejecutable (una herramienta que se puede ejecutar).

  • Declare los productos en Package.swift
  • Organice los targets y el código fuente
  • Consuma bibliotecas; ejecute ejecutables

Conceptos básicos de los productos de biblioteca

Una biblioteca expone módulos que otros pueden import. No se requiere un punto de entrada.

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

Conceptos básicos de los productos ejecutables

Un ejecutable tiene un punto de entrada (main.swift) y genera un binario ejecutable (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)")

Depender de bibliotecas

Utilice .package y .product en el consumidor para importar una biblioteca. Fije la versión mediante versiones semánticas (por ejemplo, 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.")

Separe las responsabilidades

Comparta el código: coloque la lógica principal en una biblioteca y mantenga el ejecutable como una envoltura delgada.

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

Comandos de compilación y ejecución

Compile las bibliotecas con swift build y pruébelas con swift test. Ejecute los ejecutables mediante 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.")

Definición de biblioteca frente a ejecutable

Comprobación rápida: ¿Qué diferencia una biblioteca de un ejecutable en SwiftPM?

Resumen

Resumen: Utilice una biblioteca para compartir código entre aplicaciones y un ejecutable para distribuir una CLI o herramienta. Declare los productos y los targets en Package.swift y dependa de bibliotecas mediante .package + .product.

Preguntas frecuentes

¿La lección «Paquetes de biblioteca frente a paquetes ejecutables» es gratis?

Sí — el texto completo de «Paquetes de biblioteca frente a paquetes ejecutables» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 3 lecciones en total.

¿Qué aprenderé en «Paquetes de biblioteca frente a paquetes ejecutables»?

Comprenda los paquetes de library y executable de SwiftPM: cómo declarar productos/targets, consumir bibliotecas y ejecutar ejecutables. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 3.

¿Cuánto tiempo toma la lección «Paquetes de biblioteca frente a paquetes ejecutables»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Paquetes de biblioteca frente a paquetes ejecutables
  2. Versionado semántico y etiquetado de versiones
  3. Conceptos básicos de CI con swift test y artefactos
← Volver a Swift Academy