Comment accéder aux arguments de ligne de commande dans Swift?

Comment accéder aux arguments de ligne de commande pour une application de ligne de commande dans Swift?

Apple a publié la ArgumentParserbibliothèque pour faire exactement cela:

Nous sommes ravis d'annoncer ArgumentParser, une nouvelle bibliothèque open-source qui la rend simple - même agréable! - pour analyser les arguments de ligne de commande dans Swift.

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

Analyseur d'argument rapide

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

Commencez par déclarer un type qui définit les informations que vous devez collecter à partir de la ligne de commande. Décorez chaque propriété stockée avec l'un des ArgumentParserwrappers de propriété de et déclarez la conformité à ParsableCommand.

La ArgumentParserbibliothèque analyse les arguments de ligne de commande, instancie votre type de commande, puis exécute votre run()méthode personnalisée ou quitte avec un message utile.

Mise à jour 17/01/17: mise à jour de l'exemple pour Swift 3. Processa été renommé en CommandLine.

Mise à jour 30/09/2015: mise à jour de l'exemple pour qu'il fonctionne dans Swift 2.

Il est en fait possible de faire cela sans Foundation ou C_ARGV et C_ARGC.

La bibliothèque standard Swift contient une structure CommandLinequi a une collection de Strings appelée arguments. Vous pouvez donc activer des arguments comme celui-ci:

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

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

    default:
        print("an argument")
    }
}

Dans Swift 3, utilisez CommandLineenum au lieu deProcess

Alors:

let arguments = CommandLine.arguments

Utilisez les constantes de niveau supérieur C_ARGCet 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")
    }
}

Notez que j'utilise la plage de 1..C_ARGCcar le premier élément du C_ARGV"tableau" est le chemin de l'application.

La C_ARGVvariable n'est pas réellement un tableau mais est sous-scriptable comme un tableau.

Quiconque souhaite utiliser l'ancien "getopt" (qui est disponible dans Swift) peut l'utiliser comme référence. J'ai fait un portage Swift de l'exemple GNU en C que l'on peut trouver sur:

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

avec une description complète. Il est testé et entièrement fonctionnel. Cela ne nécessite pas non plus de Fondation.

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)])!)'")
}

Vous pouvez créer un analyseur d'arguments à l'aide du CommandLine.argumentstableau et ajouter la logique de votre choix.

Vous pouvez le tester. Créer un fichierarguments.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)
}

compilez-le et exécutez-le:

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

Le problème avec la construction de votre propre analyseur d'arguments est de prendre en compte toutes les conventions d'argument de ligne de commande. Je recommanderais d'utiliser un analyseur d'arguments existant.

Vous pouvez utiliser:

• Module de console de Vapor
• Analyseur d'arguments TSCUtility utilisé par le gestionnaire de paquets Swift
• Le Swift Argument Parser open-source par Apple

J'ai écrit sur la façon de créer des outils de ligne de commande sur les trois. Vous devriez les vérifier et décider quel style vous convient le mieux.

Si vous êtes intéressé, voici les liens:

•  Construire un outil CLI à l'aide du module de console Swift et Vapor 
• Analyse des arguments de ligne de commande à l'aide du module TSCUtility de Swift Package Manager 
• Comprendre l'analyseur d'arguments Swift et travailler avec STDIN