Tips om een ​​betere Swift-ontwikkelaar te worden

Swift biedt de functies die ontwikkelaars helpen om veiliger, sneller, beter leesbaar en betrouwbaar te zijn ten opzichte van de Objective-C. Hier zijn enkele geschetste Swift-tips die we hebben verzameld via onze ervaring met deze nieuwe taal (Swift). Ze hebben ons geholpen de code veiliger en overzichtelijker te schrijven.

Ik heb deze discussie in twee secties verdeeld. In de eerste bespreken we voor degenen die aan de slag gaan met de swift en in de tweede bespreken we voor wie al gebruik maakt.

Tips voor de beginner

1. Gebruik Playground om te valideren:

Wanneer u een logisch experiment gaat implementeren en dit op een speelplaats valideert, kan dit ook worden gebruikt voor leerdoeleinden.
Speeltuin is een zeer eenvoudige en interactieve tool voor snel. Speeltuin hoeft geen nieuw project te maken . Kies eenvoudig een optie uit de Xcode-lancering om een ​​speeltuin te maken:

Speeltuin kan ook worden gemaakt binnen Xcode:

Zodra u op de speelplaats bent, kunt u de code aan de linkerkant schrijven en het resultaat aan de rechterkant en onderaan het:

2. Gebruik opties veilig:

Een optioneel is een eigenschap die een geldige waarde of niets (nul) kan hebben. Wanneer we een optionele afdrukken. Het zal de waarde afdrukken met wat extra tekst als Optioneel (waarde). We kunnen het optionele impliciet uitpakken door een uitroepteken (!) Te gebruiken aan het einde van de optionele eigenschapsnaam, maar we moeten het vermijden. Dit staat bekend als het krachtig uitpakken en leidt tot vastlopen van applicaties. Het gebruik van een uitroepteken (!) Is dus een gevaar .

Er zijn enkele speciale omstandigheden waarin het uitroepteken (!) Wordt gebruikt.
Bijvoorbeeld: IBOutlet wanneer u een outlet van interfacebuilder gaat maken, is dit een impliciet uitgepakte optie omdat UIKit ervan uitgaat dat u uw outlet heeft gekoppeld / verbonden met interfacebuilder . Het is dus riskant om een ​​optionele waarde impliciet uit te pakken.
We kunnen het patroon laten gebruiken om dit aan te pakken:

var name: String? = "Vreugde"
var lastName: String?
print (naam) // Resultaat: Optioneel ("Joy")
print (naam!) // Resultaat: Vreugde
if let value = name {
    druk (value)
} anders {
    print ("naam niet ingesteld")
}
// Resultaat: Vreugde, omdat naam een ​​waarde heeft
if let lastNameNew = lastName {
    afdrukken (lastNameNew)
} anders {
    print ("achternaam niet ingesteld")
}
// Resultaat: achternaam niet ingesteld, omdat achternaam geen waarde heeft

3. Beheer constanten in een enkel bestand:

Als u constanten van uw project wilt beheren, maakt u een bestand en beheert u alle constanten hier alleen. Organiseer alle constanten in structuur of een opsomming als:

enum AppConstants {
   static let AppName = "MyFirstApp"
   static let NoInternetMessage = "Sorry! Geen internetverbinding"
}

Het is een hele hulp om de leesbaarheid van uw code te beheren en te behouden.
Laten we zeggen dat je NoInternetMessage op veel plaatsen in je applicatiecode hebt gebruikt en nu je enkele wijzigingen in het bericht moet aanbrengen, dan kun je het bericht eenvoudig op slechts één plek wijzigen, het wordt overal automatisch weerspiegeld.

4. Gebruik van geneste functie:

U kunt een functie definiëren met in een andere functie, ook wel geneste functie genoemd.
Geneste functies worden verborgen voor de buitenwereld, maar kunnen worden opgeroepen en gebruikt door hun omsluitende functie. Een insluitende functie kan ook hun geneste functie retourneren, zodat deze kan worden gebruikt in de buitenwereld of een ander bereik.
Het verhoogt de leesbaarheid en herbruikbaarheid van uw code.

func kiest StepFunction (achteruit: Bool) -> (Int) -> Int {
   func stepForward (input: Int) -> Int {return input + 1}
   func stepBackward (input: Int) -> Int {return input - 1}
   achteruit? stepBackward: stepForward
}
var currentValue = -4
let moveNearerToZero = kiesStepFunction (achteruit: currentValue> 0)
// moveNearerToZero verwijst nu naar de geneste functie stepForward ()
terwijl currentValue! = 0 {
   print ("\ (currentValue) ...")
   currentValue = moveNearerToZero (currentValue)
}
afdrukken ( "nul!")
//Resultaat:
// -4 ...
// -3 ...
// -2 ...
// -1 ...
// nul!
Nog een laatste tip voor jullie, jullie kunnen ook terecht voor professionele tips.

Tips voor de professionals

  1. Gebruik van bewaker laat:

Wanneer een actie wordt uitgevoerd, wilt u er zeker van zijn dat alle benodigde gegevens daar beschikbaar zijn om goed te werken. Vervolgens hebben ontwikkelaars dit meestal op twee manieren opgelost, namelijk:

een. Piramides van doom:

Wanneer de ontwikkelaar zeker wil zijn voor elke benodigde gegevens, valideert de gebruikte eigenschap, zoals:

var userName: String?
var email: String?
var wachtwoord: String?
var policyAccepted: Bool = false
func checkAndSave () {
   if let uname = userName {
      if let mail = email {
         if let pwd = wachtwoord {
            if policyAccepted {
               // doe het geweldige, zoals aanmelden
            }
         }
      }
   }
}

Het staat bekend als de piramides van de ondergang omdat we de piramide van de voorwaarden maken

b. Voorwaardelijke terugkeer:

Later op doompiramides, ontwikkelden ontwikkelaars het in voorwaardelijk rendement, valideren voor elke gebruikte eigenschap en retourneren, als:

func checkAndSave () {
   if let uname = userName {return}
   if let mail = email {return}
   if let pwd = wachtwoord {return}
   if policyAccepted {return}
   
   // doe het geweldige, zoals aanmelden
}

Het staat bekend als voorwaardelijke terugkeer omdat we terugkeren bij elke voorwaardefout .
- De eerste oplossing is niet goed in de zin van leesbaarheid van codes en foutopsporing, dus we gaan er niet voor.
- Tweede oplossing is ook niet goed genoeg, omdat het onnodig is om terug te keren uit de functie, kunnen we niet begrijpen waarom we het hebben geretourneerd?
- Een andere oplossing die we kunnen gebruiken als laten, maar het heeft ook enkele beperkingen, omdat de reikwijdte van de variabele zich in het if-blok bevindt, dus het gaat weer naar de dooppiramide .

Dus hier komt het concept van bewaker laten, geïntroduceerd in swift 2.0. Het is zo eenvoudig en gemakkelijk te gebruiken, voorwaarden en de let-statements kunnen samen worden gebruikt , kunnen worden gebruikt als:

func checkAndSave () {
bewaker let uname = gebruikersnaam, laat mail = email, laat pwd = wachtwoord, beleid Aanvaard anders {
   terugkeer
}
// doe het geweldige, zoals aanmelden
}

2. Gebruik van uitstelblok:

uitstel is een blok, betekent "Sommige instructies die ik later wil uitvoeren, ongeacht wat het is?". Het kan een enkele coderegel of een aantal coderegels bevatten. We kunnen een uitstelblok definiëren in een functie die uitdagend wordt aangeroepen wanneer de functie-uitvoering eindigt . Het vermindert ook de redundantie van de code.
- Laten we zeggen, u maakt een object van een willekeurige bron in een functie en gebruikt het bewakingssleutelwoord om iets te controleren of retourneert de uitvoering vanuit een willekeurige voorwaarde, dan staat uw bron in het geheugen of moet u deze vrijgeven voordat de uitvoering van de functie is voltooid. Dus het zal leiden tot de redundantie van de code of per ongeluk kunt u middelen in het geheugen achterlaten . Om deze situatie te voorkomen, kunnen we de code voor het vrijgeven van bronnen in het uitstelblok write schrijven. net zo:

func processFile (bestandsnaam: String) gooit {
   indien bestaat (bestandsnaam) {
      let file = open (bestandsnaam)
      // uitstelblok wordt hier gedefinieerd om het open bestand te sluiten
      uitstel {
         close (file)
      }
      let userName = getUserName ()
      guard userName! = "" else {return}
      file.write (userName)
      let userAge = getUserName ()
      bewaak userAge> = 18 anders {retour}
      file.write (userAge)
      
      // close (bestand) wordt hier aan het einde van het bereik genoemd.
   }
}

3. welk sleutelwoord:

Eerder al snel als u patroonovereenkomst met de voorwaarde wilt gebruiken, moet u twee if-instructies afzonderlijk gebruiken, zoals:

var webUrl: String? = "https://medium.com"
if let path = webUrl {
   if path.hasPrefix ("https") {
      // doe het geweldige
   }
}

Later introduceerde Swift waar trefwoord in versie 2.0 hetzelfde zou doen binnen een enkele instructie, zoals:

if let path = webUrl where path.hasPrefix ("https") {
   // doe het geweldige
}

Nu heeft Swift waar trefwoord vervangen door het, (komma) teken, als:

if let path = webUrl, path.hasPrefix ("https") {
   // doe het geweldige
}

Dus, waar is meer gebruik volledig. Lees meer over de where.

4. Maak aangepaste delegatie zwak:

Wacht ... wat is zwak en delegeren? Laten we het bij de Apple-ontwikkelaar controleren voor de exacte definitie.
Een zwakke referentie is een referentie die de instantie waarnaar deze verwijst niet sterk vasthoudt en ARC er dus niet van weerhoudt de instantie waarnaar wordt verwezen te verwijderen.
Delegatie is een ontwerppatroon waarmee een klasse of structuur sommige van zijn verantwoordelijkheden kan overdragen (of delegeren) aan een instantie van een ander type.

Wanneer u de afgevaardigde van een klasse A in klasse B toewijst, behoudt u de sterke referentie van klasse A in klasse B en behoudt klasse A ook de sterke referentie van klasse B als de afgevaardigde. Het gaat dus naar de bewaarcyclus voor de objecten en er zijn geheugengerelateerde problemen en de app crasht .

Dus de volgende keer dat u uw aangepaste afgevaardigden gaat maken, moet u ze vervolgens maken als een zwakke referentie , zoals:

protocol myCustomDelegation: class {
   func newFunction (vaueToBeShare: String)
}
klasse A, eerste klasse {
   zwakke var-afgevaardigde: myCustomDelegation?
   // afgevaardigde zo zwak maken om de wachtcyclus te doorbreken
}
klasse B: myCustomDelegation {
   interne functie newFunction (vaueToBeShare: String) {
      // doe hier iets wanneer de afgevaardigde wordt ontslagen
   }
   let obj = A () // sterke verwijzing naar klasse A behouden
   in het() {
      obj.delegate = self // klasse A toewijzen aan gemachtigde klasse B.
   }
}

5. Weglaten met KVO:

KVO (Key Value Observer), waar u elke sleutel en de actie kunt instellen en observeren wanneer de waarde van die sleutel verandert. Het is een goede maar niet betere aanpak omdat we de vergissing zijn vergeten te verwijderen die tot applicatiecrash zal leiden, of waarnemers altijd uitzonden, dus het is lastig om ermee om te gaan.

We hebben snel een vervanger voor de KVO die eigenschapwaarnemer is. Met behulp hiervan kunnen we de actie krijgen wanneer de waarde van de eigenschap wordt gewijzigd. Er zijn :

  • willSet wordt aangeroepen net voordat de waarde wordt opgeslagen.
  • didSet wordt onmiddellijk opgeroepen nadat de nieuwe waarde is opgeslagen.
class newClass {
   var myNewObj: Int = 0 {
      willSet (newValue) {
         print ("newValue = \ (newValue), oldValue = \ (myNewObj)")
      }
 
      didSet {
         print ("oldValue = \ (oldValue), currentValue = \ (myNewObj)")
      }
   }
}
let obj = newClass ()
obj.myNewObj = 5
// Resultaat: newValue = 5, oldValue = 0
// Resultaat: oldValue = 0, currentValue = 5
obj.myNewObj = 8
// Resultaat: newValue = 8, oldValue = 5
// Resultaat: oldValue = 5, currentValue = 8

De waarnemers willSet en didSet voor myNewObj worden aangeroepen wanneer aan de eigenschap een nieuwe waarde wordt toegewezen. Dit geldt zelfs als de nieuwe waarde gelijk is aan de huidige waarde .

Als u de waarde van property1 in property observer van property2 en property2 in property observer van property1 wijzigt, wordt er een ketting gemaakt, wordt de foutieve uitvoeringsfout weergegeven tijdens runtime, niets zegt tijdens het compileren.

6. Gebruik meerdere storyboards:

Een storyboard is een visuele weergave van de gebruikersinterface van een iOS-toepassing, met schermen met inhoud en de verbindingen tussen die schermen.
Xcode maakt standaard een storyboard en ontwikkelaars gebruiken het voor de volledige applicatie, dus het wordt een monster en verhoogt de laadtijd voor uw project in Xcode en de starttijd van uw applicatie op het apparaat,
Probeer dus meerdere storyboards in uw applicatie te maken.

"gebruik storyboard voor een compleet verhaal niet voor een compleet project"

Wanneer we meerdere storyboards gebruiken, kunnen we de viewcontrollers op veel manieren maken om dit artikel over het gebruik van meerdere storyboards diep te lezen.
Meerdere storyboards kunnen worden gebruikt als:

enum AppStoryboards: String {
   case Main = "Main"
   case PreLogin = "PreLogin"
   var instance: UIStoryboard {
      retour UIStoryboard (naam: self.rawValue, bundel: nul)
   }
}
// GEBRUIK:
let storyboard = AppStoryboard.Main.instance
laat loginVC = AppStoryboard.PreLogin.instance.instantiateViewController (withIdentifier: "LoginVC")
// Oude weg
let storyboard = UIStoryboard (naam: "Main", bundle: Bundle.main)

7. Weglaten met Globals:

Het is een goede gewoonte om globale variabelen en functies te gebruiken, ons kan helpen schone code te maken en de herbruikbaarheid van code te vergroten. Maar ik zal een betere extensie voor hetzelfde gebruiken. Omdat we door een Global-klasse te maken een "GOD-klasse" maken. Dus laten we de Global class-taken splitsen met behulp van extensies, waardoor de code schoner, leesbaarder en herbruikbaar wordt.

Vind leuk:

// Gemiddelde praktijk
func square (x: Int) -> Int {return x * x}
let square3 = square (x: 3) // Print: 9
vierkant (x: vierkant3) // Afdrukken: 81
// Geweldige praktijk
extensie Int {
   var square: Int {return self * self}
}
3. vierkant // Afdrukken: 9
3.vierkant.vierkant // Afdrukken: 81

Download enkele extensies van GitHub.

8. Gebruik statistieken:

Met generieken kunt u een variabele declareren die bij uitvoering kan worden toegewezen aan een door ons gedefinieerde set typen.

// Gemiddelde praktijk
var stateName = ["Uttar Pradesh", "Kerala", "Assam", "Punjab"]
var areaArray = [240928, 38863, 78438, 50362]
var groei = [20.1, 4.9, 16.9, 13.7]
func printStateName (obj: [String]) {print ("stateNames: \ (obj)")}
func printStateArea (obj: [Int]) {print ("areas: \ (obj)")}
func printStateGrowth (obj: [Double]) {print ("bevolkingsgroei: \ (obj)")}
printStateName (obj: stateName)
printStateArea (obj: areaArray)
printStateGrowth (obj: growth)
// Geweldige praktijk
func printArray  (_ obj: T, message: String = "") {print ("\ (message) \ (obj)")}
printArray (stateName, message: "stateNames:")
printArray (areaArray, bericht: "areas:")
printArray (groei, bericht: "bevolkingsgroei:")

Bedankt voor het lezen, klik op het pictogram aanbevelen als je deze verzameling leuk vindt