• 11. März 2025
  • Lesezeit 6 Minuten
Swift-Code-Prüfliste: Einfaches Verwalten

Möchten Sie Swift-Anwendungen entwickeln? Dann können wir Ihnen aus Erfahrung sagen, dass solider Code Ihre Grundlage ist. Effektive Code-Reviews sind der Schlüssel, egal ob Sie den Erfolg im App Store anstreben oder einfach nur schneller liefern wollen. Die Verwendung von Code-Reviews hilft Ihnen, Fehler frühzeitig zu erkennen, eine hohe Leistung aufrechtzuerhalten und eine Codebasis zu erstellen, mit der Sie gerne arbeiten. In diesem Artikel wird eine Checkliste für Swift-Code-Reviews vorgestellt, mit der Sie Ihre Prozesse straffen und schnell bessere Apps entwickeln können. Wir decken alle wesentlichen Punkte ab, darunter:

Inhaltsverzeichnis

Code-Klarheit und Stil

Behandeln Sie Ihren Swift-Code so, als ob Sie sich mit anderen Entwicklern oder Ihrem zukünftigen Ich unterhalten würden. Sauberer Code beschleunigt das Verständnis, verkürzt die Zeit für die Fehlersuche und macht Ihre Swift-Anwendung zukunftssicher. Beim Code-Stil geht es nicht nur darum, hübsch auszusehen; es geht darum, Ihre Anwendungen grundsolide und Ihr Team super-effizient zu machen.

Wichtige Best Practices:

  • Verwenden Sie den offiziellen Swift-Styleguide und die Konventionen für die Codierung
  • Benennen Sie eindeutig und beschreibend (camelCase für Variablen/Funktionen, PascalCase für Typen)
  • Priorisieren Sie die Lesbarkeit und Einfachheit des Codes
  • Strukturieren Sie den Code logisch, indem Sie Erweiterungen, Protokolle und eine angemessene Zugriffskontrolle verwenden
  • Dokumentieren Sie komplexe Logik und öffentliche APIs mit Dokumentationskommentaren im Swift-Stil
// Bad practice of function naming

func processData(arr: [Int]) -> [Int] { 
  // ... some complex data processing 
  return arr 
}
// Good practice of function naming

func calculateSquaredValues(inputNumbers: [Int]) -> [Int] {
  // ... squares each number in the input array ...
  return squaredNumbers
}

Sicherheit und Fehlerbehandlung

Abstürze und unerwartetes Verhalten sind die schnellsten Wege, um Benutzer zu frustrieren und Ihre Swift-Anwendung zu Fall zu bringen. Ihr Ruf steht auf dem Spiel, wenn ein Benutzer aufgrund eines einfachen Fehlers Daten verliert oder in eine Sackgasse gerät.
Intelligente Fehlerbehandlung in Swift verhindert Abstürze, führt Benutzer durch Probleme und vereinfacht die Fehlersuche.

Wichtige Best Practices:

  • Nutzen Sie die Fehlerbehandlung von Swift (do-try-catch, Result) für das Fehlermanagement
  • Verwenden Sie Optionals, um das Fehlen von Werten zu handhaben und erzwungenes Unwrapping zu vermeiden
  • Implementieren Sie eine Eingabevalidierung, um unerwartetes Verhalten und Abstürze zu vermeiden
  • Effektive Protokollierung von Fehlern und Warnungen mit der Swift-Protokollierung oder benutzerdefinierten Protokollierungslösungen
  • Erwägen Sie die Verwendung von Assertions und Vorbedingungen für die Fehlersuche sowie die Durchsetzung von Invarianten während der Entwicklung
// Bad practice of do-try-catch

enum FileError: Error {
    case notFound
    case invalidFormat 
} 

func loadData(fromFile path: String) throws -> String { 
    // Imagine this function might throw FileError.notFound or FileError.invalidFormat 
    if path == "bad_path.txt" {
        throw FileError.notFound 
    } 
    if path == "wrong_format.txt" {
        throw FileError.invalidFormat 
    }
    return "Data from \(path)" // Success case 
} 

func processFile(filePath: String) {
    do {
        try loadData(fromFile: filePath) 
        // ... imagine further processing of the loaded data ...
        print("File processed successfully!") 
    } catch {
        // Bad: Empty catch block - errors are silently ignored!
        // No error handling at all. 
    } 
} 
// Example usage: 
processFile(filePath: "bad_path.txt") // Prints "File processed successfully!" even though it should have failed!
// Good practice of do-try-catch

enum FileErrorGood: Error {
    case notFound
    case invalidFormat
    case unknown(Error) // To capture unexpected errors
}

func loadDataGood(fromFile path: String) throws -> String {
    // ... (same file loading logic as before, but using FileErrorGood) ...
    if path == "bad_path.txt" {
        throw FileErrorGood.notFound
    }
    if path == "wrong_format.txt" {
        throw FileErrorGood.invalidFormat
    }
    return "Data from \(path)"
}

func processFileGood(filePath: String) {
    do {
        let data = try loadDataGood(fromFile: filePath)
        // ... process data ...
        print("File processed successfully with data: \(data)")
    } catch let error as FileErrorGood { // Good: Catch specific FileErrorGood type
        switch error {
        case .notFound:
            print("Error: File not found at path: \(filePath)")
        case .invalidFormat:
            print("Error: File has an invalid format.")
        case .unknown(let underlyingError): // Good: Handle unexpected errors
            print("An unexpected file error occurred: \(underlyingError)")
        }
    } catch { // Good: Catch any other unexpected errors (as a fallback)
        print("An unexpected error occurred: \(error)") // Good: Log or display a general error message
    }
}

// Example usage:
processFileGood(filePath: "bad_path.txt")
// Output: Error: File not found at path: bad_path.txt

processFileGood(filePath: "good_path.txt")
// Output: File processed successfully with data: Data from good_path.txt

Leistung und Ressourcenmanagement

Leistung ist das A und O in der Swift-Welt, insbesondere auf iPhones und Macs. Benutzer erwarten, dass Apps blitzschnell und reibungslos funktionieren. Mit effizientem Code und Ressourcenmanagement können Sie dieses Erlebnis effektiv bieten. Die Swift-Ressourcenverwaltung verbessert die Reaktionsfähigkeit von Apps, verlängert die Akkulaufzeit, verringert die Speichernutzung und ermöglicht eine mühelose Skalierung.

Wichtige Best Practices:

  • Achten Sie auf Wert- und Referenztypen und deren Auswirkungen auf die Leistung in Swift
  • Optimieren Sie Algorithmen und Datenstrukturen auf Effizienz
  • Verwenden Sie „Lazy Loading“ und effiziente Datenabruftechniken
  • Verwalten Sie den Speicher effektiv, indem Sie das ARC (Automatic Reference Counting) von Swift verstehen
  • Verwenden Sie Profiling-Tools (wie Instruments), um Leistungsengpässe zu identifizieren
  • Gegebenenfalls Berücksichtigung von Parallelität und Parallelität unter Verwendung der Parallelitätsfunktionen von Swift (GCD, async/await, Actors)
// Bad practice of eager loading (loading upfront, even if not needed)

class MyViewController: UIViewController {
    let largeImage = UIImage(named: "very_large_image.png")! // ❌ Eagerly loaded

    override func viewDidLoad() {
        super.viewDidLoad()
        let imageView = UIImageView(image: largeImage)
        // ... rest of setup ...
    }
}
// Good practice of lazy loading (loading only when needed)

class MyViewController: UIViewController {
    lazy var largeImageView: UIImageView = { // ✅ Lazy loading using lazy var
        let imageView = UIImageView()
        imageView.image = UIImage(named: "very_large_image.png")
        return imageView
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        // largeImageView is NOT loaded yet!

        // ... later, when you need to display it:
        view.addSubview(largeImageView) // ✅ Image is loaded NOW, when imageView is accessed
        // ... rest of setup ...
    }
}

Sicherheit und Abhängigkeiten

Sicherheit ist das A und O für Swift-Anwendungen, insbesondere für solche, die mit Benutzerdaten umgehen oder sich mit Netzwerken verbinden. Die Verwaltung von Abhängigkeiten ist Ihre erste Verteidigungslinie. Sicherheit und Abhängigkeitsmanagement in Swift schaffen Vertrauen bei den Benutzern, verhindern Angriffe, schützen Daten und verbessern die Stabilität der Anwendung.

Wichtige Best Practices:

  • Bereinigen Sie Benutzereingaben, um Injektionsschwachstellen zu vermeiden (insbesondere in webbezogenen Swift-Kontexten oder bei der Interaktion mit externen Systemen)
  • Verwenden Sie sichere Kodierungsverfahren für die Datenspeicherung (Keychain für sensible Daten auf Apple-Plattformen)
  • Sorgen Sie für eine sichere Netzwerkkommunikation (HTTPS)
  • Verwalten Sie Abhängigkeiten mit dem Swift Package Manager (SPM) oder CocoaPods/Carthage
  • Regelmäßige Überprüfung und Aktualisierung von Abhängigkeiten auf Sicherheitslücken
  • Verwendung von Sperrdateien für Abhängigkeiten (Package.resolved in SPM) für konsistente Builds
// Bad practice of ignoring package.resolved (not committing to version control)

MySwiftProject/
├── Package.swift       // Defines dependencies
├── Sources/
│   └── ...Swift code...
└── .gitignore          //  ❌  Package.resolved is likely ignored here!
// Good practice of committing package.resolved to version control

MySwiftProject/
├── Package.swift       // Defines dependencies
├── Sources/
│   └── ...Swift code...
├── Package.resolved    // ✅  Package.resolved IS committed!
└── .gitignore

Testen und Barrierefreiheit

Was nützt exzellenter Swift-Code, wenn er nicht zuverlässig funktioniert oder Benutzer ihn nicht richtig nutzen können? Robuste Swift-Test- und Zugänglichkeitspraktiken ermöglichen es Ihnen, leistungsstarke, zuverlässige und integrative Anwendungen zu entwickeln, die alle Benutzer begeistern und Probleme frühzeitig erkennen.

Wichtige Best Practices:

  • Schreiben Sie Unit-Tests mit XCTest, um einzelne Komponenten zu überprüfen
  • Implementieren Sie UI-Tests, um das Verhalten der Benutzeroberfläche zu überprüfen.
  • Streben Sie eine angemessene Testabdeckung an und konzentrieren Sie sich auf kritische Pfade.
  • Verwenden Sie semantische UI-Elemente in SwiftUI oder UIKit für die Barrierefreiheit
  • Einbindung von Zugänglichkeitsattributen (UIAccessibility in UIKit, Zugänglichkeitsmodifikatoren in SwiftUI)
  • Testen Sie die Zugänglichkeit mit VoiceOver und anderen Zugänglichkeitstools
  • Sicherstellen, dass die Tastaturnavigation unterstützt wird (insbesondere bei macOS-Anwendungen)
// Bad practice of non-semantic (accessibility Ignored)

import SwiftUI

struct BadAccessibilityButton: View {
    var body: some View {
        HStack { // ❌ HStack is visually grouping, not semantically a button
            Image(systemName: "heart.fill") // ❌ Image alone has no semantic meaning
            Text("Like") // ❌ Text alone is just text, not a button's action
        }
        .onTapGesture {
            print("Like button tapped!")
        }
    }
}
// Good practice of semantic SwiftUI with Accessibility Modifiers

import SwiftUI

struct GoodAccessibilityButton: View {
    var body: some View {
        Button { // ✅ Button is the semantic element for actions
            print("Like button tapped!")
        } label: {
            Label("Like", systemImage: "heart.fill") // ✅ Label combines icon and text semantically
                .labelStyle(.iconOnly) // ✅ (Optional) Style to show icon and text visually
        }
        .accessibilityLabel("Like") // ✅ Explicitly set accessibility label (redundant in this case, but good practice)
        .accessibilityHint("Double tap to like this item") // ✅ Provide a hint for interaction
    }
}

Ihre Swift-Entwicklung & Audit-Dienstleistungen

Selbst einfache Anwendungen können Ihr Unternehmen voranbringen, und weltweit gibt es 5 Milliarden Mobiltelefonbenutzer. Wir bei Redwerk verfügen über zwei Jahrzehnte Erfahrung in der mobilen Entwicklung und können Ihre Idee in eine einwandfreie iOS-App, eine fortschrittliche Android-App oder beides verwandeln.

Unsere Redwerk-Entwickler, Designer, QA-Ingenieure und Projektmanager unterstützen Sie bei Ihrem Projekt. Wir machen anspruchsvolle Aufgaben einfacher und Deadlines weniger stressig. Unsere Dienstleistungen helfen unseren Kunden, ihre Ziele zu erreichen:

  • Ideation Development. Wir entwickeln kundenspezifische Softwarelösungen von Grund auf neu. Sehen Sie sich an, wie wir eine App für elektronische Nachhilfe, Gooroo, entwickelt haben, die die richtigen Nachhilfelehrer und Schüler auf der Grundlage ihrer Profile und Erwartungen zusammenbringt. Diese App erhielt eine 4,4-Sterne-Bewertung im App Store.
  • Code-Refactoring. Wir haben uns auf Code-Refactoring spezialisiert und verbessern Ihren Code mit den besten Methoden von heute. Mit über 20 iOS-App-Entwicklungsprojekten in 7 Ländern kann unser Team Ihre Codebasis modernisieren, um die Leistung zu verbessern und die Wartung zu erleichtern.
  • Erweitern der Funktionalität. Wir steigern die Attraktivität Ihres Produkts, indem wir neue Funktionen hinzufügen oder leicht skalierbare Lösungen entwickeln. My Bike Valet, ein intelligentes Fahrradparksystem, profitierte von unserer Erfahrung bei der Erstellung von iOS- und Android-MVP-Architekturen. Wir legten den Grundstein für grundlegende Funktionen und hielten die App skalierbar für erweiterte Funktionen.
  • Hybride und plattformübergreifende App-Entwicklung. Unser Redwerk-Team entwickelt erstklassige native iOS- und Android-Apps, die zuverlässig sind und genau das bieten, was Sie brauchen. Native Entwicklung garantiert höchste Geschwindigkeit und Funktionen. Wenn Sie plattformübergreifend arbeiten, sparen Sie Geld und können schneller mehr Nutzer erreichen. Wir unterstützen Sie dabei, die beste Entscheidung für Ihre Entwicklungs- und Geschäftsziele zu treffen.

Wir wissen, wie es ist, unter Termindruck zu stehen und schnell voranzukommen, ohne den Code zu ruinieren. Ganz gleich, ob Sie eine gründliche Codeprüfung, Ratschläge zu bewährten Verfahren, Unterstützung während der gesamten Entwicklung oder einen ganzen Entwicklungszyklus benötigen, wir haben die Swift-Profis, die Ihnen zur Seite stehen. Bereit für ein Gespräch? Wir sind gespannt auf Ihr Projekt und darauf, wie wir Ihnen dabei helfen können. Sprechen Sie uns jederzeit an.