Punto de entrada en Swift

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

r8vnhill/swift-dibs

Swift está diseñado para permitirte comenzar rápido. A diferencia de otros lenguajes donde siempre debes definir una función main, en Swift puedes escribir código directamente en un archivo llamado main.swift, y ese será automáticamente el punto de entrada del programa.

Esto simplifica la escritura de scripts y herramientas pequeñas, sin sacrificar la posibilidad de estructurar programas más complejos gracias al uso de anotaciones como @main. En esta lección, exploraremos ambas formas de definir el punto de entrada en Swift: la implícita (mediante código a nivel superior) y la estructurada (usando @main). También aprenderás cómo recibir argumentos desde la línea de comandos, una herramienta clave para hacer tus programas más versátiles.

Esta sección te prepara para escribir tanto pequeños scripts como aplicaciones modulares más avanzadas, manteniendo un enfoque idiomático y reutilizable en el desarrollo de bibliotecas de software.

🛠️ ¿Cómo ejecutar estos ejemplos?

Para poder ejecutar los ejemplos mostrados, es útil saber cómo crear un proyecto básico en Swift y cómo estructurarlo en módulos reutilizables. Estos recursos te guiarán paso a paso:

📦 Crear un Proyecto Básico en Swift
Aprende a iniciar un proyecto desde cero usando Swift Package Manager.
🧩 Modularizar tu Proyecto Swift
Descubre cómo dividir tu código en módulos separados para mejorar la organización, reutilización y mantenibilidad.

🧬 Declaración de `main` en Swift

En Swift, no necesitas declarar una función main de forma explícita cuando escribes scripts o aplicaciones sencillas. El archivo main.swift se considera automáticamente el punto de entrada, y todo el código que escribas a nivel superior se ejecuta directamente.

Script Swift simple (Sources/TypeFundamentals/main.swift)
print("What cannot change can only be broken.")

Luego, puedes ejecutar este script directamente desde la terminal:

Desde la terminal
swift run TypeFundamentals

🧳 Accediendo a argumentos de línea de comandos

Al igual que en Kotlin, Swift permite recibir argumentos desde la terminal para modificar dinámicamente el comportamiento de un programa. Esto es útil para crear herramientas reutilizables, probar componentes con distintos datos, o construir scripts de ejemplo.

Script Swift con argumentos (Sources/TypeFundamentals/main.swift)
import Foundation

let args = CommandLine.arguments.dropFirst()

if args.isEmpty {
    print("You know nothing, Jon Snow.")
} else {
    let name = args.joined(separator: " ")
    print("Winter is coming for you, \(name).")
}

¿Qué acabamos de hacer?

Este script lee los argumentos de la línea de comandos y genera un mensaje personalizado según el input recibido.

CommandLine.arguments es un arreglo de cadenas que incluye todos los argumentos con los que fue invocado el programa. El primer elemento (arguments[0]) corresponde al nombre del ejecutable.
dropFirst() se usa para ignorar ese primer elemento y trabajar solo con los argumentos reales.
Si no se entregan argumentos, el programa imprime un mensaje predeterminado.
Si se entregan uno o más, los concatena y muestra una respuesta personalizada.

Esta técnica es equivalente al uso de main(args: Array<String>) en Kotlin, aunque Swift no requiere una función explícita main: simplemente coloca el código en main.swift y comienza desde ahí.

Para ejecutar este script, puedes usar el comando:

Desde la terminal
swift run TypeFundamentals Syrio Forel

Compatibilidad con sistemas de ejecución

En Swift, puedes definir el punto de entrada de un programa utilizando un tipo estructural anotado con @main, como una struct o una class. Este enfoque es especialmente útil cuando deseas una estructura más formal y compatible con herramientas de ejecución más exigentes.

Estructura con @main (Sources/TypeFundamentals/main.swift)
@main
struct Launcher {
    static func main() {
        print("Static main detected.")
    }
}

¿Qué es un tipo estructural?

Un tipo estructural en Swift es cualquier tipo que define una estructura clara de datos y comportamiento, como struct, class o enum. En el contexto de @main, se espera que el tipo tenga un método static func main() que actúe como punto de entrada del programa.

Esto permite que Swift compile el programa en un binario ejecutable que puede ser invocado desde la línea de comandos o herramientas externas, similar a cómo funciona el método public static void main en Java o Kotlin con @JvmStatic.

Error: 'main' attribute cannot be used in a module that contains top-level code

Swift no permite combinar la anotación @main con código a nivel superior (es decir, fuera de funciones, clases o estructuras) dentro del mismo archivo. Esto incluye incluso líneas en blanco o comentarios mal ubicados.

✅ Asegúrate de que el archivo que contiene el tipo con @main no tenga ningún otro código fuera de ese tipo.

📊 Resumen comparativo

Característica	Kotlin	Swift
¿Requiere una función `main` explícita?	✅ Sí, siempre debe declararse una función `main`	❌ No, el archivo `main.swift` ejecuta directamente el código
Forma básica de punto de entrada	`fun main()` o `fun main(args: Array<String>)`	Código a nivel superior en `main.swift`
Recepción de argumentos por consola	`args: Array<String>`	`CommandLine.arguments`
Herramienta de ejecución	Gradle (`./gradlew :app:run --args="..."`)	SwiftPM (`swift run NombreDelTarget`)

✅ Beneficios / ❌ Limitaciones

Beneficios

Permite escribir scripts simples sin declarar funciones o clases.
Sintaxis más directa y concisa para casos rápidos o exploratorios.
El soporte de @main permite compatibilidad con binarios más estructurados.

Limitaciones

Menos explícito: el punto de entrada puede ser implícito, lo que puede generar confusión en proyectos grandes.
Errores sutiles si se mezcla @main con código a nivel superior en el mismo archivo.

🎯 Conclusiones

En esta lección exploramos cómo se declara y estructura el punto de entrada en programas escritos en Swift, destacando su naturaleza más flexible y concisa en comparación con otros lenguajes como Kotlin o Java.

Swift permite una experiencia de scripting más directa al ejecutar código ubicado en main.swift sin necesidad de funciones explícitas. Esta simplicidad lo hace ideal para scripts, experimentación y prototipado rápido, mientras que el uso de @main permite adoptar una estructura más tradicional cuando se necesita mayor control o integración con sistemas de ejecución avanzados.

También aprendimos a manejar argumentos desde la línea de comandos, una técnica esencial para construir programas reutilizables, interactivos y fáciles de testear.

🔑 Puntos clave

Swift no requiere una función main explícita: basta con colocar código en el archivo main.swift.
El acceso a los argumentos de línea de comandos se hace mediante CommandLine.arguments, ignorando el nombre del ejecutable con dropFirst().
Se puede usar @main con un struct, class o enum que defina un static func main() como punto de entrada alternativo.
Swift prohíbe el uso de @main en archivos que contengan código a nivel superior.
La simplicidad de main.swift facilita la escritura de scripts, pero puede volverse ambigua en proyectos más grandes si no se organiza con cuidado.

🧰 ¿Qué nos llevamos?

Swift ofrece una entrada al programa mucho más sencilla que muchos lenguajes tradicionales, pero eso viene con ciertos compromisos:

Para scripts y herramientas rápidas, Swift brilla por su bajo ruido sintáctico y fluidez.
Para aplicaciones más estructuradas, su sistema basado en @main y tipos estructurales permite mantener un diseño robusto.
Comprender las reglas sobre main.swift, @main y CommandLine.arguments es esencial para evitar errores y sacarle el máximo provecho tanto a proyectos pequeños como a aplicaciones modulares más complejas.

El diseño de Swift refleja una decisión deliberada: permitir a quien desarrolla comenzar de forma inmediata sin sacrificar la posibilidad de escalar hacia estructuras formales. Esta elección lo convierte en un lenguaje pragmático y adaptable para la creación de bibliotecas reutilizables, scripts, y herramientas de línea de comandos.

📖 Referencias

🔥 Recomendadas

🌐 "#1 Swift Programming - Application Entry Point - Main Function" en YouTube por Davids Videos: Este video explica cómo definir el punto de entrada de una aplicación en Swift. Comienza mostrando el uso tradicional del archivo main.swift, donde el compilador espera encontrar el código de inicio, y luego presenta una alternativa mediante el uso de la anotación @main en una estructura o clase que implemente una función static func main(). También se aclaran las restricciones de Swift respecto al uso de expresiones a nivel superior fuera del archivo principal, y se muestra cómo evitar conflictos si hay múltiples anotaciones @main. Es una guía práctica útil para quienes desean personalizar el archivo de entrada, como en proyectos que usan entry-point.swift.

🛠️ ¿Cómo ejecutar estos ejemplos?​

🧬 Declaración de main en Swift​

🧳 Accediendo a argumentos de línea de comandos​

📊 Resumen comparativo​

✅ Beneficios / ❌ Limitaciones​