Toate Comenzile Swift CLI și Ecosistemul de Librării: Ghid Complet de la SPM la Producție în Swift (iOS & macOS)

# Rularea automată a executabilului implicit al pachetului curent:
$ swift run

# Rularea unui executabil specific dintr-un proiect cu target-uri multiple:
$ swift run ServerApp

# Rularea în mod Release (cu optimizări complete ale compilatorului):
$ swift run -c release ServerApp

# Transmiterea de argumente și parametri către aplicația finală (după separatorul --):
$ swift run CliApp --port 8080 --mediu productie --verbose

# Rularea directă a unui fișier Swift independent în mod script:
$ swift run script_procesare.swift

# Compilare rapidă în mod Debug (include simboluri DWARF de depanare):
$ swift build

# Compilare optimizată pentru producție (nivel de optimizare -O):
$ swift build -c release

# Compilarea unui singur modul/target dintr-un pachet complex:
$ swift build --target CoreNetworking

# Compilarea target-urilor de teste fără rularea lor:
$ swift build --build-tests

# Transmiterea de flag-uri avansate compilatorului intern swiftc:
$ swift build -Xswiftc -strict-concurrency=complete -Xswiftc -warnings-as-errors

# Rularea tuturor testelor din pachet:
$ swift test

# Rularea în mod paralel pentru accelerarea execuției pe procesoare multi-core:
$ swift test --parallel

# Filtrarea testelor după nume (regex sau subsir):
$ swift test --filter AutentificareTests.testLoginSucces

# Activarea analizei gradului de acoperire al codului (Code Coverage):
$ swift test --enable-code-coverage

# Exportul rezultatului acoperirii în format JSON:
$ xcrun llvm-cov export -format=text .build/debug/ProiectPackageTests.xctest \
    -instr-profile=.build/debug/codecov/default.profdata

$ swift repl
Welcome to Swift! Type :help for assistance.
  1> import Foundation
  2> let orase = ["București", "Cluj-Napoca", "Timișoara", "Iași"]
  3> let formate = orase.map { $0.uppercased() }.joined(separator: ", ")
formate: String = "BUCUREȘTI, CLUJ-NAPOCA, TIMIȘOARA, IAȘI"
  4> :type formate
String
  5> :quit

# Compilarea a două fișiere independente într-un binar executabil:
$ swiftc main.swift utilitare.swift -o program_final

# Compilare cu optimizări maxime și suprimarea verificărilor de runtime (-Ounchecked):
$ swiftc -O -parse-as-library server.swift -o server_bin

# Inspectarea reprezentării intermediare SIL (Swift Intermediate Language):
$ swiftc -emit-sil main.swift > main.sil

# Generarea codului de asamblare (Assembly) pentru arhitectura curentă (ARM64 / x86_64):
$ swiftc -emit-assembly main.swift -o main.s

# 1. Inițializarea unui nou proiect (tipuri: executable, library, macro, tool, empty):
$ mkdir ServiciuPlati && cd ServiciuPlati
$ swift package init --type executable

# 2. Descărcarea și rezolvarea arborelui de dependențe (creează Package.resolved):
$ swift package resolve

# 3. Actualizarea dependențelor la cea mai nouă versiune compatibilă conform regulilor SemVer:
$ swift package update

# 4. Afișarea ierarhică a arborelui complet de dependențe:
$ swift package show-dependencies --format text

# 5. Generarea reprezentării structurale a pachetului în format JSON:
$ swift package describe --type json

# 6. Calcularea sumei de control SHA-256 pentru binaryTarget (XCFramework distribuit):
$ swift package compute-checksum FrameworkNativ.xcframework.zip

# 7. Editarea locală a unei dependențe externe (desprindere din cache pentru debug live):
$ swift package edit Alamofire --path ../AlamofireLocal

# 8. Revenirea dependenței la versiunea oficială clonată:
$ swift package unedit Alamofire

# 9. Curățarea artefactelor de compilare temporare:
$ swift package clean

# 10. Resetarea completă a depozitului de pachete (șterge directorul .build și clonele externe):
$ swift package reset

# Verificarea conformității codului sursă fără modificarea fișierelor:
$ swift-format lint --recursive Sources/ Tests/

# Formatarea automată directă a tuturor fișierelor din proiect (in-place):
$ swift-format format --in-place --recursive Sources/ Tests/

# Previzualizarea documentației pe un server web local (port 8080):
$ swift package --disable-sandbox preview-documentation --target ModululMeu

# Exportul documentației statice HTML pentru publicare pe GitHub Pages sau server web:
$ swift package generate-documentation --target ModululMeu --output-path ./docs

import Collections

// O structură Deque garantează inserare și ștergere O(1) atât la început cât și la sfârșit:
var coadaPrioritati = Deque<String>()

coadaPrioritati.append("Client Regular")
coadaPrioritati.prepend("Urgență Medicală") // O(1) spre deosebire de Array.insert(..., at: 0) care este O(n)

if let prim = coadaPrioritati.popFirst() {
    print("Se procesează cazul prioritar: \(prim)") // "Urgență Medicală"
}

import Algorithms

let tranzactiiBancare = [120, 450, 30, 890, 1200, 50, 410, 95]

// Împărțirea listei în loturi de procesare de dimensiune fixă (ex. 3 elemente per lot):
let loturi = tranzactiiBancare.chunks(ofCount: 3)

for lot in loturi {
    print("Lot transmis spre validare: \(Array(lot))")
}
// Ieșire:
// Lot: [120, 450, 30]
// Lot: [890, 1200, 50]
// Lot: [410, 95]

import Testing

struct CalculFinanciarTests {
    // Teste parametrizate: verifică automat toate intrările fără cod duplicat:
    @Test("Validarea calculului de TVA pentru diverse cote", arguments: [
        (100.0, 0.19, 119.0),
        (200.0, 0.09, 218.0),
        (50.0, 0.05, 52.5)
    ])
    func calculeazaTVA(baza: Double, cota: Double, rezultatAsteptat: Double) {
        let total = baza * (1.0 + cota)
        #expect(total == rezultatAsteptat)
    }
}

import ArgumentParser

@main
struct AnalizorFisiere: ParsableCommand {
    static let configuration = CommandConfiguration(
        abstract: "Utilitar rapid de inspecție și indexare documente în rețea.",
        version: "1.0.0"
    )

    @Argument(help: "Calea către fișierul țintă de analizat.")
    var caleFisier: String

    @Option(name: .shortAndLong, help: "Nivelul de detaliere a jurnalului (1-3).")
    var nivelDetaliu: Int = 1

    @Flag(name: .shortAndLong, help: "Activarea modului silențios fără ieșire în consolă.")
    var silentios: Bool = false

    mutating func run() throws {
        if !silentios {
            print("Analizăm fișierul '\(caleFisier)' la nivelul de detaliu \(nivelDetaliu)...")
        }
    }
}

import Vapor

// Configurare server web minimalist de înaltă performanță:
func routes(_ app: Application) throws {
    app.get("api", "sanatate") { req async -> [String: String] in
        return [
            "status": "activ",
            "motor": "Vapor 4.100+",
            "concurrency": "Swift 6 Strict Data-Race Free"
        ]
    }
    
    app.post("api", "utilizatori") { req async throws -> Response in
        struct CerereUtilizator: Content {
            let nume: String
            let email: String
        }
        let date = try req.content.decode(CerereUtilizator.self)
        req.logger.info("Utilizator nou înregistrat: \(date.email)")
        return Response(status: .created)
    }
}