• 11 de Marzo de 2025
  • Se lee en 7 minutos
Lista de comprobación para la revisión del código Swift: Gestionarla fácilmente

¿Quieres crear aplicaciones Swift? Entonces, podemos decirte por experiencia que un código sólido es tu base. Las revisiones de código efectivas son la clave, ya sea para lograr el éxito en la App Store o simplemente para acelerar los envíos. Utilizar revisiones de código te ayudará a detectar errores a tiempo, mantener un alto rendimiento y producir una base de código agradable con la que trabajar. Este artículo muestra una lista de comprobación de revisión de código Swift que le permitirá agilizar sus procesos y crear rápidamente mejores aplicaciones. Cubriremos todo lo esencial, incluyendo:

Contenido

Claridad y estilo del código

Trata tu código Swift como si estuvieras conversando con otros desarrolladores o con tu yo del futuro. Un código limpio acelera la comprensión, reduce el tiempo de depuración y prepara tu aplicación Swift para el futuro. El estilo del código no se trata sólo de que parezca bonito; se trata de que tus aplicaciones sean sólidas como una roca y tu equipo sea súper eficiente.

Mejores prácticas clave:

// 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
}

Seguridad y gestión de errores

Los bloqueos y los comportamientos inesperados son las formas más rápidas de frustrar a los usuarios y hundir su aplicación Swift. Tu reputación está en juego si un usuario pierde datos o llega a un callejón sin salida por un simple error.
La gestión inteligente de errores en Swift evita los bloqueos, guía a los usuarios a través de los problemas y agiliza la depuración.

Mejores prácticas clave:

  • Utilizar el manejo de errores de Swift (do-try-catch, Result) para la gestión de errores
  • Utiliza Optionals para gestionar la ausencia de valores y evitar el desenvolvimiento forzado
  • Implementar la validación de entrada para evitar comportamientos inesperados y bloqueos
  • Registrar errores y advertencias de forma efectiva utilizando el registro de Swift o soluciones de registro personalizadas
  • Considera el uso de aserciones y precondiciones para la depuración, así como la aplicación de invariantes durante el desarrollo
// 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

Rendimiento y gestión de recursos

El rendimiento es el rey en el mundo Swift, especialmente en iPhones y Macs. Los usuarios esperan que las aplicaciones sean rápidas como el rayo y fluidas; con un código y una gestión de recursos eficientes, puedes ofrecer esa experiencia de forma eficaz. La gestión de recursos Swift mejora la capacidad de respuesta de las aplicaciones, prolonga la duración de la batería, reduce el uso de memoria y permite escalar sin esfuerzo.

Mejores prácticas clave:

  • Ten en cuenta los tipos de valor frente a los tipos de referencia y sus implicaciones para el rendimiento en Swift
  • Optimizar algoritmos y estructuras de datos para mejorar la eficiencia
  • Emplear técnicas de carga lenta y obtención eficiente de datos.
  • Gestionar la memoria de forma efectiva, entendiendo el ARC de Swift (Automatic Reference Counting)
  • Utilizar herramientas de perfilado (como Instruments) para identificar cuellos de botella en el rendimiento
  • Cuando proceda, considerar la concurrencia y el paralelismo utilizando las funciones de concurrencia de 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 ...
    }
}

Seguridad y dependencias

La seguridad es primordial para las aplicaciones Swift, especialmente las que manejan datos de usuarios o se conectan a redes. La gestión de dependencias es tu primera línea de defensa. La seguridad en Swift y la gestión de dependencias generan confianza en el usuario, evitan ataques, protegen los datos y mejoran la estabilidad de la aplicación.

Mejores prácticas clave:

  • Desinfectar la entrada del usuario para evitar vulnerabilidades de inyección (especialmente en contextos Swift relacionados con la web o al interactuar con sistemas externos)
  • Utilizar prácticas de codificación seguras para el almacenamiento de datos (Keychain para datos confidenciales en plataformas Apple)
  • Garantizar una comunicación de red segura (HTTPS)
  • Gestionar las dependencias utilizando Swift Package Manager (SPM) o CocoaPods/Carthage
  • Auditar y actualizar periódicamente las dependencias en busca de vulnerabilidades de seguridad
  • Utilizar archivos de bloqueo de dependencias (Package.resolved en SPM) para obtener compilaciones coherentes
// 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

Pruebas y accesibilidad

¿De qué sirve un código Swift excelente si no funciona de forma fiable o si los usuarios no pueden utilizarlo correctamente? Las sólidas prácticas de pruebas y accesibilidad de Swift le permiten crear aplicaciones potentes, fiables e inclusivas que satisfacen a todos los usuarios y detectan los problemas a tiempo.

Mejores prácticas clave:

  • Escribir pruebas unitarias utilizando XCTest para verificar los componentes individuales
  • Implementar pruebas de interfaz de usuario para validar el comportamiento de la interfaz de usuario
  • Intentar que la cobertura de las pruebas sea razonable, centrándose en las rutas críticas
  • Utilizar elementos de interfaz de usuario semánticos en SwiftUI o UIKit para la accesibilidad
  • Incorporar atributos de accesibilidad (UIAccessibility en UIKit, modificadores de accesibilidad en SwiftUI)
  • Pruebe la accesibilidad utilizando VoiceOver y otras herramientas de accesibilidad
  • Asegúrese de que la navegación por teclado es compatible (especialmente para aplicaciones macOS)
// 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
    }
}

Sus servicios de desarrollo y auditoría de Swift

Incluso las aplicaciones básicas pueden hacer crecer su negocio, y existe una audiencia de 5.000 millones de usuarios de teléfonos móviles en todo el mundo. En Redwerk, contamos con dos décadas de experiencia en desarrollo móvil que pueden convertir su idea en una aplicación iOS impecable, una aplicación Android avanzada, o ambas.

Nuestros desarrolladores, diseñadores, ingenieros de control de calidad y gestores de proyectos de Redwerk se pondrán manos a la obra para ayudarle en su proyecto. Hacemos que las tareas difíciles sean más fáciles y los plazos menos estresantes. Así es como nuestros servicios ayudan a los clientes a alcanzar sus objetivos:

  • Desarrollo de ideas. Creamos soluciones de software personalizadas desde cero. Vea cómo creamos una aplicación de tutoría electrónica, Gooroo, que pone en contacto a los tutores y estudiantes adecuados en función de sus perfiles y expectativas. Esta aplicación obtuvo 4,4 estrellas en la App Store.
  • Refactorización de código. Nos especializamos en la refactorización de código y elevar su código a través de las mejores prácticas de hoy. Con un historial de más de 20 proyectos de desarrollo de aplicaciones iOS en 7 países, nuestro equipo puede modernizar su código base para mejorar el rendimiento y facilitar el mantenimiento.
  • Ampliación de la funcionalidad. Aumentaremos el atractivo de su producto añadiendo nuevas funcionalidades o construyendo soluciones fácilmente escalables. My Bike Valet, un sistema inteligente de aparcamiento de bicicletas, aprovechó nuestra experiencia en la creación de arquitectura MVP para iOS y Android. Sentamos las bases para las funcionalidades esenciales y mantuvimos la aplicación escalable para las características avanzadas.
  • Desarrollo de aplicaciones híbridas y multiplataforma. Nuestro equipo de Redwerk crea aplicaciones nativas de iOS y Android de primera categoría que son fiables y exactamente lo que necesita. Las aplicaciones nativas garantizan la máxima velocidad y funcionalidad. El desarrollo multiplataforma le ahorrará dinero y le permitirá llegar a más usuarios con mayor rapidez. Le guiaremos en la toma de la mejor decisión para su desarrollo y objetivos de negocio.

Entendemos lo que es tener la presión de los plazos, así como la necesidad de moverse rápido sin destrozar su código. Tanto si necesita una auditoría en profundidad del código, asesoramiento sobre las mejores prácticas, asistencia durante todo el proceso o un ciclo de desarrollo completo, contamos con los profesionales de Swift para respaldarle. ¿Listo para hablar? Somos todo oídos para que nos cuentes tu proyecto y cómo podemos ayudarte a conseguirlo. Póngase en contacto con nosotros.