26.11.2024

Aula 148: Construindo Ferramentas de Linha de Comando em Swift

Nesta aula, vamos explorar como construir ferramentas de linha de comando utilizando Swift. Ferramentas de linha de comando são aplicações que são executadas no terminal, recebendo entradas do padrão de entrada (STDIN) e fornecendo saídas para o padrão de saída (STDOUT). Swift facilita a criação dessas ferramentas com sua rica biblioteca padrão e sintaxe simples.

Pré-Requisitos

Certifique-se de que você tenha o Swift instalado na sua máquina. Você pode verificar isso executando o seguinte comando no seu terminal:

swift --version

Configurando Seu Projeto

1. Crie um novo diretório para seu projeto:

mkdir MinhaFerramentaDeLinhaDeComando
cd MinhaFerramentaDeLinhaDeComando

2. Crie um novo Pacote Swift:

swift package init --type executable

Isso cria uma estrutura básica de pacote Swift com um alvo Executável.

3. Navegue para a pasta do seu projeto:

cd MinhaFerramentaDeLinhaDeComando

Escrevendo Sua Ferramenta de Linha de Comando

Abra o arquivo Sources/MinhaFerramentaDeLinhaDeComando/main.swift no seu editor de texto preferido. Vamos escrever uma ferramenta de linha de comando simples que recebe a entrada do usuário, processa e retorna um resultado.

Exemplo 1: Uma Ferramenta Calculadora

Vamos criar uma calculadora simples que realiza adição, subtração, multiplicação e divisão.

import Foundation

func calcular(_ operacao: String, _ a: Double, _ b: Double) -> Double? {
    switch operacao {
    case "adicionar":
        return a + b
    case "subtrair":
        return a - b
    case "multiplicar":
        return a * b
    case "dividir":
        guard b != 0 else {
            print("Erro: Divisão por zero.")
            return nil
        }
        return a / b
    default:
        print("Operação desconhecida. Use 'adicionar', 'subtrair', 'multiplicar' ou 'dividir'.")
        return nil
    }
}

// Verifique o número necessário de argumentos
if CommandLine.argc != 5 {
    print("Uso: MinhaFerramentaDeLinhaDeComando <operacao> <num1> <num2>")
    exit(1)
}

// Leia a operação e os números dos argumentos da linha de comando
let operacao = CommandLine.arguments[1]
guard let num1 = Double(CommandLine.arguments[2]),
      let num2 = Double(CommandLine.arguments[3]) else {
    print("Erro: Números inválidos.")
    exit(1)
}

// Realiza o cálculo
if let resultado = calcular(operacao, num1, num2) {
    print("Resultado: \(resultado)")
}

Executando a Ferramenta

Para compilar e executar sua ferramenta de linha de comando, execute os seguintes comandos no seu terminal:

swift build
swift run MinhaFerramentaDeLinhaDeComando adicionar 10 5

Você deverá ver a seguinte saída:

Resultado: 15.0

Você pode experimentar diferentes operações substituindo adicionar por subtrair, multiplicar ou dividir.

Usando Swift ArgumentParser

Para ferramentas de linha de comando mais avançadas, você pode querer usar a biblioteca Swift ArgumentParser. Esta biblioteca fornece uma maneira de declarar e analisar argumentos de linha de comando de forma fácil.

1. Adicione a dependência ArgumentParser ao seu Package.swift:

dependencies: [
    .package(url: "https://github.com/apple/swift-argument-parser", from: "1.0.0")
],
targets: [
    .target(
        name: "MinhaFerramentaDeLinhaDeComando",
        dependencies: [
            .product(name: "ArgumentParser", package: "swift-argument-parser"),
        ]),
    .testTarget(
        name: "MinhaFerramentaDeLinhaDeComandoTests",
        dependencies: ["MinhaFerramentaDeLinhaDeComando"]),
]

2. Atualize seu main.swift para usar ArgumentParser:

import ArgumentParser

struct Calculadora: ParsableCommand {
    @Argument(help: "A operação a ser realizada (adicionar, subtrair, multiplicar, dividir).")
    var operacao: String

    @Argument(help: "O primeiro número.")
    var num1: Double

    @Argument(help: "O segundo número.")
    var num2: Double

    func validate() throws {
        let operacoesValidas = ["adicionar", "subtrair", "multiplicar", "dividir"]
        if !operacoesValidas.contains(operacao) {
            throw ValidationError("Operação inválida. Use 'adicionar', 'subtrair', 'multiplicar' ou 'dividir'.")
        }
    }

    func run() throws {
        let resultado: Double?
        switch operacao {
        case "adicionar":
            resultado = num1 + num2
        case "subtrair":
            resultado = num1 - num2
        case "multiplicar":
            resultado = num1 * num2
        case "dividir":
            guard num2 != 0 else {
                throw ValidationError("Divisão por zero não é permitida.")
            }
            resultado = num1 / num2
        default:
            resultado = nil
        }

        if let resultado = resultado {
            print("Resultado: \(resultado)")
        }
    }
}

Calculadora.main()

3. Reconstrua e execute sua ferramenta:

swift build
swift run MinhaFerramentaDeLinhaDeComando adicionar 10 5

Conclusão

Nesta aula, abordamos os conceitos básicos de construção de ferramentas de linha de comando em Swift. Começamos com uma calculadora simples e então encapsulamos nossa lógica em uma estrutura utilizando a biblioteca Swift ArgumentParser para um manuseio avançado de argumentos de linha de comando. As ferramentas de linha de comando são versáteis e podem ser usadas para variados propósitos, proporcionando uma ótima maneira de automatizar tarefas ou realizar cálculos rápidos diretamente do terminal. Boa codificação!

Video

Navigation