¿Cómo se accede a los argumentos de la línea de comandos en Swift?

¿Cómo se accede a los argumentos de la línea de comandos para una aplicación de línea de comandos en Swift?

Apple ha lanzado la ArgumentParserbiblioteca para hacer precisamente esto:

Estamos encantados de anunciar ArgumentParseruna nueva biblioteca de código abierto que lo hace sencillo, ¡incluso agradable! - para analizar los argumentos de la línea de comandos en Swift.

https://swift.org/blog/argument-parser/

Analizador de argumentos veloz

https://github.com/apple/swift-argument-parser

Comience declarando un tipo que defina la información que necesita recopilar desde la línea de comando. Decore cada propiedad almacenada con uno de ArgumentParserlos envoltorios de propiedad y declare la conformidad con ParsableCommand.

La ArgumentParserbiblioteca analiza los argumentos de la línea de comandos, crea una instancia de su tipo de comando y luego ejecuta su run()método personalizado o sale con un mensaje útil.

Actualización 17/01/17: Se actualizó el ejemplo de Swift 3. Processha cambiado de nombre CommandLine.

Actualización 30/09/2015: Se actualizó el ejemplo para que funcione en Swift 2.

De hecho, es posible hacer esto sin Foundation o C_ARGV y C_ARGC.

La biblioteca estándar de Swift contiene una estructura CommandLineque tiene una colección de Strings llamados arguments. Entonces podrías activar argumentos como este:

for argument in CommandLine.arguments {
    switch argument {
    case "arg1":
        print("first argument")

    case "arg2":
        print("second argument")

    default:
        print("an argument")
    }
}

En Swift 3 use CommandLineenum en lugar deProcess

Entonces:

let arguments = CommandLine.arguments

Utilice las constantes de nivel superior C_ARGCy C_ARGV.

for i in 1..C_ARGC {
    let index = Int(i);

    let arg = String.fromCString(C_ARGV[index])
    switch arg {
    case "this":
        println("this yo");

    case "that":
        println("that yo")

    default:
        println("dunno bro")
    }
}

Tenga en cuenta que estoy usando el rango de 1..C_ARGCporque el primer elemento de la C_ARGV"matriz" es la ruta de la aplicación.

La C_ARGVvariable no es en realidad una matriz, sino que es sub-programable como una matriz.

Cualquiera que quiera usar el antiguo "getopt" (que está disponible en Swift) puede usarlo como referencia. Hice un puerto Swift del ejemplo de GNU en C que se puede encontrar en:

http://www.gnu.org/software/libc/manual/html_node/Example-of-Getopt.html

con una descripción completa. Está probado y es completamente funcional. Tampoco requiere Fundación.

var aFlag   = 0
var bFlag   = 0
var cValue  = String()

let pattern = "abc:"
var buffer = Array(pattern.utf8).map { Int8($0) }

while  true {
    let option = Int(getopt(C_ARGC, C_ARGV, buffer))
    if option == -1 {
        break
    }
    switch "\(UnicodeScalar(option))"
    {
    case "a":
        aFlag = 1
        println("Option -a")
    case "b":
        bFlag = 1
        println("Option -b")
    case "c":
        cValue = String.fromCString(optarg)!
        println("Option -c \(cValue)")
    case "?":
        let charOption = "\(UnicodeScalar(Int(optopt)))"
        if charOption == "c" {
            println("Option '\(charOption)' requires an argument.")
        } else {
            println("Unknown option '\(charOption)'.")
        }
        exit(1)
    default:
        abort()
    }
}
println("aflag ='\(aFlag)', bflag = '\(bFlag)' cvalue = '\(cValue)'")

for index in optind..<C_ARGC {
    println("Non-option argument '\(String.fromCString(C_ARGV[Int(index)])!)'")
}

Puede crear un analizador de argumentos utilizando CommandLine.argumentsArray y agregar la lógica que desee.

Puedes probarlo. Crea un archivoarguments.swift

//Remember the first argument is the name of the executable
print("you passed \(CommandLine.arguments.count - 1) argument(s)")
print("And they are")
for argument in CommandLine.arguments {
    print(argument)
}

compílelo y ejecútelo:

$ swiftc arguments.swift
$ ./arguments argument1 argument2 argument3

El problema con la construcción de su propio analizador de argumentos es tener en cuenta todas las convenciones de argumentos de la línea de comandos. Recomendaría usar un analizador de argumentos existente.

Podrías usar:

• Módulo de consola de Vapor
• Analizador de argumentos de TSCUtility utilizado por el administrador de paquetes Swift
• El analizador de argumentos Swift de código abierto de Apple

He escrito sobre cómo construir herramientas de línea de comandos en los tres. Deberías echarles un vistazo y decidir qué estilo te queda mejor.

Si está interesado aquí están los enlaces:

•  Construyendo una herramienta CLI usando el módulo Consola de Swift y Vapor 
• Análisis de argumentos de la línea de comandos utilizando el módulo TSCUtility de Swift Package Manager 
• Comprender el analizador de argumentos Swift y trabajar con STDIN