Standard di codifica Swift - 10 errori di codifica comuni - Parte I

1. Uso dell'istruzione return su una funzione a riga singola

func add(_ a: Int, _ b: Int) -> Int {
   a + b
}

func fetchData(completion: () -> ()) {
  // fetch logic
  completion()
}

func fetchDataEscaping(@escaping completion: () -> ()) {
  // fetch logic
  completion()
}

func onButtonClick() {
  // call function with non-escaping (default) closure
  fetchData { 
    updateUI()
  }

  // call function with escaping closure
  fetchDataEscaping { [weak self]
    self?. updateUI()
  }
}

var optionalVar: String? = nil

enum ViewConstants {
   static let imageHeight = 212.0
}

let value = try XCTUnwrap(optionalValue)

if let value1 = optionalValue1 {
 if let value2 = optionalValue2 {
 if let value3 = optionalValue3 {
 // perform some operation using value1, value2, and value3
 } else {
 // handle case where value3 is nil
 }
 } else {
 // handle case where value2 is nil
 }
} else {
 // handle case where value1 is nil
}

if let value1 = optionalValue1,
 let value2 = optionalValue2,
 let value3 = optionalValue3 {
 // perform some operation using value1, value2, and value3
} else {
 // handle case where any of the optional values are nil
}

final class MyClass {
    // class implementation goes here
}

• Prestazioni migliorate: quando si contrassegna un metodo o una proprietà come `final`, il compilatore può apportare determinate ottimizzazioni che migliorano le prestazioni del codice.
• Migliore organizzazione del codice: questo può rendere il tuo codice più facile da leggere e comprendere, specialmente per altri sviluppatori che stanno lavorando sulla stessa base di codice.
• Maggiore sicurezza del codice: impedendo la sottoclasse o l'override del metodo, puoi ridurre il rischio di comportamenti imprevisti o vulnerabilità di sicurezza nel tuo codice.
• Manutenzione più semplice: questo può semplificare la manutenzione del codice nel tempo, poiché non è necessario preoccuparsi tanto degli effetti collaterali indesiderati derivanti dalle modifiche a quel codice.

• `public`: il livello di accesso pubblico consente l'accesso da qualsiasi file sorgente, modulo o framework. È possibile accedere a classi, proprietà e metodi contrassegnati come pubblici da qualsiasi altro modulo (ad esempio un pacchetto Swift) o framework.
• `internal`: il livello di accesso interno consente l'accesso dall'interno dello stesso modulo o framework. È possibile accedere a classi, proprietà e metodi contrassegnati come interni solo all'interno dello stesso modulo o framework.
• `private`: il livello di accesso privato limita l'accesso allo stesso blocco di dichiarazione. È possibile accedere a classi, proprietà e metodi contrassegnati come privati ​​solo all'interno della stessa classe, struttura o enumerazione. Quindi, ad esempio, se una funzione non viene utilizzata al di fuori di struct/class/enum, è necessario utilizzare `private`.