Συμβουλές για να γίνετε καλύτερος προγραμματιστής Swift

Το Swift παρέχει τα χαρακτηριστικά που βοηθούν τους προγραμματιστές να κωδικοποιούν ασφαλέστερο, ταχύτερο, πιο αναγνώσιμο και αξιόπιστο σεβασμό στο Στόχο-C. Ακολουθούν ορισμένες συμβουλές Swift που έχουμε συλλέξει μέσω της εμπειρίας μας χρησιμοποιώντας αυτή τη νέα γλώσσα (Swift). Μας βοήθησαν να γράψουμε τον κώδικα πιο ασφαλές και καθαρό.

Έχω χωρίσει αυτή τη συζήτηση σε δύο ενότητες. Στην πρώτη, συζητάμε για εκείνους που ξεκινούν με το γρήγορο και στη δεύτερη, συζητώντας για ποιοι χρησιμοποιούν ήδη.

Συμβουλές για τον αρχάριο

1. Χρησιμοποιήστε την παιδική χαρά για να επιβεβαιώσετε:

Κάθε φορά που πρόκειται να εφαρμόσετε οποιοδήποτε λογικό πείραμα και να το επικυρώσετε στην παιδική χαρά, μπορείτε να το χρησιμοποιήσετε και για εκπαιδευτικούς σκοπούς.
Η παιδική χαρά είναι ένα πολύ εύκολο και διαδραστικό εργαλείο για γρήγορη. Η παιδική χαρά δεν χρειάζεται να δημιουργήσει ένα νέο έργο . Για να δημιουργήσετε απλή παιδική χαρά, επιλέξτε ως επιλογή από την εκκίνηση του Xcode:

Παιδική χαρά μπορεί επίσης να δημιουργηθεί μέσα Xcode:

Μόλις είστε στην παιδική χαρά, μπορείτε να γράψετε τον κώδικα στην αριστερή πλευρά και το αποτέλεσμα θα είναι στη δεξιά πλευρά και στο κάτω μέρος του:

2. Χρησιμοποιήστε προαιρετικά τα προαιρετικά:

Ένα προαιρετικό είναι μια ιδιότητα που μπορεί να έχει μια έγκυρη τιμή ή τίποτα (μηδέν). Κάθε φορά που πρόκειται να εκτυπώσετε ένα προαιρετικό. Θα εκτυπώσει την τιμή με κάποιο επιπλέον κείμενο ως Προαιρετική (τιμή). Μπορούμε σιωπηρά να αναδιπλώσουμε το προαιρετικό χρησιμοποιώντας ένα θαυμαστικό (!) Στο τέλος του προαιρετικού ονόματος ιδιότητας, αλλά πρέπει να το αποφύγουμε. Αυτό το γνωστό ως το ισχυρό ξετύλιγμα, οδηγεί σε συντριβές εφαρμογών. Έτσι, η χρήση του θαυμασμού (!) Αποτελεί κίνδυνο .

Υπάρχουν ορισμένες ειδικές συνθήκες στις οποίες χρησιμοποιείται το θαυμαστικό (!).
Για παράδειγμα: IBOutlet όταν θα δημιουργήσετε μια πρίζα από το περιβάλλον δημιουργίας διεπαφών τότε θα είναι σιωπηρώς ανοιχτό προαιρετικό επειδή η UIKit αναλαμβάνει τη σύνδεση / σύνδεση της πρίζας σας με τον οικοδόμο διεπαφής . Επομένως, είναι επικίνδυνο να χρησιμοποιήσετε σιωπηρά την αναδίπλωση μιας προαιρετικής αξίας.
Μπορούμε να χρησιμοποιήσουμε εάν αφήσουμε το μοτίβο να το χειριστεί αυτό:

όνομα var: Σειρά; = "Χαρά"
var lastName: String;
print (όνομα) // Αποτέλεσμα: Προαιρετικό ("Joy")
print (όνομα!) // Αποτέλεσμα: Χαρά
εάν ας τιμή = όνομα {
    εκτύπωση (αξία)
} else {
    εκτύπωση ("όνομα δεν έχει οριστεί")
}}
// Αποτέλεσμα: Χαρά, επειδή το όνομα έχει μια τιμή
αν let lastNameNew = lastName {
    εκτύπωση (lastNameNew)
} else {
    εκτύπωση ("το επίθετο δεν έχει οριστεί")
}}
// Αποτέλεσμα: το επώνυμο δεν έχει οριστεί, επειδή το lastName δεν έχει καμία τιμή

3. Διαχείριση σταθερών σε ένα αρχείο:

Για να διαχειριστείτε τις σταθερές του έργου σας, δημιουργήστε ένα αρχείο και διαχειριστείτε όλες τις σταθερές μόνο εδώ. Οργάνωση όλων των σταθερών σε δομή ή enum όπως:

enum AppConstants {
   static ας AppName = "MyFirstApp"
   static let NoInternetMessage = "Λυπούμαστε, δεν υπάρχει σύνδεση στο διαδίκτυο"
}}

Είναι πολύ μεγάλη βοήθεια για να διαχειριστείτε και να διατηρήσετε την αναγνωσιμότητα του κώδικα σας.
Ας υποθέσουμε ότι έχετε χρησιμοποιήσει NoInternetMessage σε πολλά σημεία του κώδικα της εφαρμογής σας και τώρα πρέπει να κάνετε κάποιες αλλαγές στο μήνυμα, τότε μπορείτε εύκολα να αλλάξετε το μήνυμα μόνο σε ένα μέρος, αυτό θα αντανακλάται αυτόματα παντού.

4. Χρήση της ένθετης λειτουργίας:

Μπορείτε να ορίσετε μια συνάρτηση με άλλα όργανα, γνωστά ως λειτουργία ένθεσης.
Οι ενσωματωμένες λειτουργίες θα αποκρύπτονται από τον εξωτερικό κόσμο, αλλά μπορούν να καλούνται και να χρησιμοποιούνται από τη λειτουργία εγκλεισμού τους. Μια λειτουργία περικλείσεων μπορεί επίσης να επιστρέψει τη λειτουργία τους, έτσι ώστε να μπορεί να χρησιμοποιηθεί σε εξωτερικό κόσμο ή σε άλλο πεδίο.
Αυξάνει την αναγνωσιμότητα και την επαναχρησιμοποίηση του κώδικα σας.

func ΕπιλέξτεStepFunction (πίσω: Bool) -> (Int) -> Int {
   step stepΠαραγωγή (είσοδος: Int) -> Int {επιστροφή εισόδου + 1}
   func stepBackward (είσοδος: Int) -> Int {επιστροφή εισόδου - 1}
   επιστροφή πίσω; stepBackward: stepForward
}}
var currentValue = -4
αφήστε moveNearerToZero = chooseStepFunction (προς τα πίσω: currentValue> 0)
// moveNearerToZero τώρα αναφέρεται στη λειτουργία embedded stepForward ()
ενώ currentValue! = 0 {
   εκτύπωση ("\ (currentValue) ...")
   currentValue = moveNearerToZero (τρέχουσα τιμή)
}}
εκτύπωση ("μηδέν!")
//Αποτέλεσμα:
// -4 ...
// -3 ...
// -2 ...
// -1 ...
// μηδέν!
Μια ακόμη τελευταία συμβουλή για εσάς, μπορείτε να πάτε για επαγγελματικές συμβουλές επίσης.

Συμβουλές για τους επαγγελματίες

  1. Χρήση φύλακα αφήστε:

Όταν οποιαδήποτε ενέργεια εκτελεί, θέλετε να είστε βέβαιοι ότι όλα τα απαραίτητα δεδομένα είναι διαθέσιμα εκεί για να λειτουργήσει σωστά. Στη συνέχεια, συνήθως οι προγραμματιστές λύνουν αυτό με δύο τρόπους, που είναι:

ένα. Πυραμίδες της μοίρας:

Όταν ο προγραμματιστής θέλει να είναι σίγουρος για κάθε απαραίτητο στοιχείο, επικυρώνει το κάθε χρησιμοποιούμενο ακίνητο, όπως:

var όνομα χρήστη: Σειρά;
var email: Η συμβολοσειρά;
var password: String;
Πολιτική varAccept: Bool = false
funk checkAndSave () {
   αν ας uname = userName {
      αν αφήσουμε mail = email {
         αν αφήσουμε pwd = password {
            αν το policyAccepted {
               // κάνει το μεγάλο πράγμα, όπως η εγγραφή
            }}
         }}
      }}
   }}
}}

Είναι γνωστό ως πυραμίδες της μοίρας γιατί δημιουργούμε την πυραμίδα των συνθηκών

σι. Υποχρεωτική επιστροφή:

Αργότερα στις πυραμίδες της μοίρας, οι προγραμματιστές τη μετατράπηκαν σε υπό όρους επιστροφή, επικυρώνουν για κάθε χρησιμοποιούμενη περιουσία και επιστροφή, όπως:

funk checkAndSave () {
   αν ας uname = userName {επιστροφή}
   αν αφήσετε mail = email {επιστροφή}
   αν αφήσουμε pwd = password {return}
   if policyAccepted {επιστροφή}
   
   // κάνει το μεγάλο πράγμα, όπως η εγγραφή
}}

Είναι γνωστό ως υπό όρους επιστροφή επειδή επιστρέφουμε σε κάθε αποτυχία condition.
- Η πρώτη λύση δεν είναι καλή από την άποψη της αναγνωσιμότητας του κώδικα και του εντοπισμού σφαλμάτων, επομένως δεν πρόκειται να το χρησιμοποιήσουμε.
- Δεύτερη λύση δεν είναι αρκετά καλή, γιατί είναι περιττή η επιστροφή από τη λειτουργία, δεν μπορούμε να το πάρουμε γιατί μας το επέστρεψα;
- Μια άλλη λύση, μπορούμε να χρησιμοποιήσουμε αν αφήσουμε, αλλά έχει επίσης μερικούς περιορισμούς καθώς το εύρος της μεταβλητής θα είναι με το if μπλοκ, Έτσι θα leeds πάλι σε πυραμίδα της μοίρας .

Έτσι, εδώ έρχεται η έννοια του φρουρού ας, που εισήχθη στην ταχεία 2.0. Είναι τόσο απλό και εύκολο στη χρήση, οι συνθήκες και οι δηλώσεις μπορούν να χρησιμοποιηθούν από κοινού , μπορούν να χρησιμοποιηθούν ως:

funk checkAndSave () {
guard let uname = userName, αφήστε το mail = email, αφήστε pwd = κωδικό πρόσβασης, πολιτικήΈγκριση αλλού {
   ΕΠΙΣΤΡΟΦΗ
}}
// κάνει το μεγάλο πράγμα, όπως η εγγραφή
}}

2. Χρήση του μπλοκ αναβολής:

η αναβολή είναι ένα μπλοκ, σημαίνει "κάποιες οδηγίες που θέλω να εκτελέσω αργότερα ανεξάρτητα από το τι είναι;". Μπορεί να περιέχει μια μόνο γραμμή κώδικα ή δέσμη γραμμών κώδικα. Μπορούμε να ορίσουμε ένα μπλοκ αναβολής σε μια συνάρτηση η οποία θα καλείται προκλητικά όταν η εκτέλεση της λειτουργίας τελειώνει . Μειώνει επίσης τον πλεονασμό του κώδικα.
- Ας πούμε, δημιουργείτε ένα αντικείμενο οποιουδήποτε πόρου σε μια λειτουργία και χρησιμοποιείτε τη φρουρά λέξης-κλειδιού για να ελέγξετε κάτι ή να επιστρέψετε την εκτέλεση από οποιαδήποτε συνθήκη τότε είτε είστε πηγή θα είναι στη μνήμη ή θα πρέπει να την απελευθερώσετε πριν τελειώσετε την εκτέλεση της λειτουργίας. Έτσι θα οδηγήσει στον πλεονασμό του κώδικα ή κατά λάθος μπορείτε να αφήσετε πόρους στη μνήμη . Για να αποφύγουμε αυτή την κατάσταση μπορούμε να γράψουμε τον κώδικα απελευθέρωσης πόρων στο block deferment . όπως και:

func processFile (όνομα αρχείου: String) ρίχνει {
   αν υπάρχει (όνομα αρχείου) {
      αφήστε το αρχείο = ανοιχτό (όνομα αρχείου)
      // εδώ ορίζεται το block defer για να κλείσει το ανοιχτό αρχείο
      να αναβάλει {
         κλείσιμο (αρχείο)
      }}
      let usernameName = getUserName ()
      guard userName! = "" αλλιώς {επιστροφή}
      file.write (όνομα χρήστη)
      let userAge = getUserName ()
      guard userAge> = 18 άλλο {επιστροφή}
      file.write (userAge)
      
      // κλείνει (αρχείο) καλείται εδώ, στο τέλος του πεδίου.
   }}
}}

3. wherekeyword:

Νωρίτερα σε γρήγορη αν θέλετε να χρησιμοποιήσετε το μοτίβο που ταιριάζει με την προϋπόθεση τότε θα πρέπει να χρησιμοποιήσετε δύο if δηλώσεις ξεχωριστά, όπως:

var webUrl: String; = "https://medium.com"
αν αφήσουμε διαδρομή = webUrl {
   αν path.hasPrefix ("https") {
      // κάνει το μεγάλο πράγμα
   }}
}}

Αργότερα, ο Swift εισήγαγε τη λέξη-κλειδί στην έκδοση 2.0 για να κάνει το ίδιο πράγμα μέσα σε μία δήλωση, όπως:

αν αφήσουμε path = webUrl όπου path.hasPrefix ("https") {
   // κάνει το μεγάλο πράγμα
}}

Τώρα, η Swift έχει αντικαταστήσει τη λέξη-κλειδί με το σύμβολο (κόμμα), ως εξής:

αν αφήσουμε path = webUrl, path.hasPrefix ("https") {
   // κάνει το μεγάλο πράγμα
}}

Έτσι, όπου είναι μεγαλύτερη χρήση πλήρης. Διαβάστε περισσότερα σχετικά με το where.

4. Κάντε την προσαρμοσμένη εξουσιοδότηση αδύνατη:

Περιμένετε ... τι είναι αδύναμο και αντιπροσωπεύει; Ας το ελέγξουμε στον προγραμματιστή μήλων για ακριβή ορισμό.
Μια αδύναμη αναφορά είναι μια αναφορά που δεν διατηρεί ισχυρή στάση στην περίπτωση στην οποία αναφέρεται και επομένως δεν εμποδίζει την ARC να εκποιήσει την αναφερόμενη περίπτωση.
Η αντιπροσωπεία είναι ένα σχέδιο σχεδιασμού που επιτρέπει σε μια τάξη ή μια δομή να εκχωρεί (ή να μεταβιβάζει) ορισμένες από τις ευθύνες της σε μια περίπτωση άλλου τύπου.

Κάθε φορά που εκχωρείτε τον εκπρόσωπο οποιασδήποτε κατηγορίας Α στην κατηγορία Β, τότε κρατάτε την ισχυρή αναφορά της κατηγορίας Α στην κατηγορία Β, και η τάξη Α θα διατηρήσει επίσης την ισχυρή αναφορά της κατηγορίας Β ως εκπρόσωπος. Έτσι, θα leeds στον κύκλο συγκράτησης για τα αντικείμενα και θα υπάρξουν προβλήματα που σχετίζονται με την μνήμη και η εφαρμογή θα σβήσει .

Έτσι, την επόμενη φορά που πρόκειται να δημιουργήσετε τους εξειδικευμένους αντιπροσώπους σας, φροντίστε να τις δημιουργήσετε ως αδύναμη αναφορά , όπως:

πρωτόκολλο myCustomDelegation: class {
   func newfunction (vaueToBeShare: String)
}}
τάξη Α {
   ασθενής var εκπρόσωπος: myCustomDelegation;
   // καθιστώντας τον εκπρόσωπο ως αδύναμο να σπάσει τον κύκλο συγκράτησης
}}
κατηγορία Β: myCustomDelegation {
   εσωτερική λειτουργία newFunction (vaueToBeShare: String) {
      // κάνετε κάτι εδώ όταν ο εκπρόσωπος απολύθηκε
   }}
   ας obj = A () // διατηρώντας ισχυρή αναφορά της κλάσης Α
   μέσα σε αυτό() {
      obj.delegate = self // εκχωρώντας την κλάση Α στον εκπρόσωπο της κατηγορίας Β
   }}
}}

5. Παραλείψτε χρησιμοποιώντας το KVO:

KVO (παρατηρητής τιμής κλειδιού), όπου μπορείτε να ρυθμίσετε και παρατηρητή για οποιοδήποτε πλήκτρο και τη δράση όταν αλλάζει η τιμή αυτού του κλειδιού. Είναι καλή, αλλά όχι καλύτερη προσέγγιση στο γρήγορο επειδή κάναμε κάποιο χρόνο να ξεχάσουμε να αφαιρέσουμε τον παρατηρητή που θα οδηγήσει σε συντριβή της εφαρμογής, ή οι παρατηρητές πάντα μεταδίδονται έτσι είναι ένας πόνος πλήρης για να χειριστεί.

Έχουμε ένα αντικαταστάτη για το ΚΒΟ σε ταχεία που είναι παρατηρητής ακινήτων. Χρησιμοποιώντας το μπορούμε να πάρουμε τη δράση όταν η αξία της ιδιοκτησίας πρόκειται να αλλάξει. Υπάρχουν :

  • Το willSet καλείται ακριβώς πριν την αποθήκευση της τιμής.
  • Το didSet καλείται αμέσως μετά την αποθήκευση της νέας τιμής.
class newClass {
   var myNewObj: Int = 0 {
      willSet (newValue) {
         εκτύπωση ("newValue = \ (newValue), oldValue = \ (myNewObj)")
      }}
 
      didSet {
         εκτύπωση ("oldValue = \ (oldValue), currentValue = \ (myNewObj)")
      }}
   }}
}}
ας obj = newClass ()
obj.myNewObj = 5
// Αποτέλεσμα: newValue = 5, oldValue = 0
// Αποτέλεσμα: oldValue = 0, currentValue = 5
obj.myNewObj = 8
// Αποτέλεσμα: newValue = 8, oldValue = 5
// Αποτέλεσμα: oldValue = 5, currentValue = 8

Οι παρατηρητές willSet και didSet για το myNewObj ονομάζονται όποτε η ιδιότητα έχει εκχωρηθεί μια νέα τιμή. Αυτό ισχύει ακόμα και αν η νέα τιμή είναι ίδια με την τρέχουσα τιμή .

Αν αλλάζετε την τιμή της ιδιότητας1 στον παρατηρητή ιδιότητας property2 και property2 στον παρατηρητή ιδιότητας property1, θα κάνει μια αλυσίδα, δίνουν το λάθος της κακής εκτέλεσης στο χρόνο εκτέλεσης, τίποτα δεν θα λέει κατά το compile time.

6. Χρήση πολλαπλών storyboard:

Ένας πίνακας προβολής είναι μια οπτική αναπαράσταση του περιβάλλοντος εργασίας χρήστη μιας εφαρμογής iOS, εμφανίζοντας οθόνες περιεχομένου και τις συνδέσεις μεταξύ αυτών των οθονών.
Το Xcode δημιουργεί έναν πίνακα ιστοριών από προεπιλογή και οι προγραμματιστές το χρησιμοποιούν για πλήρη εφαρμογή, ώστε να γίνει ένα τέρας και να αυξήσει το χρόνο φόρτωσης για το έργο σας στο Xcode καθώς και να ξεκινήσει την ώρα της εφαρμογής σας στη συσκευή,
Προσπαθήστε λοιπόν να δημιουργήσετε πολλαπλές ιστορίες στην εφαρμογή σας.

"χρησιμοποιήστε το storyboard για μια πλήρη ιστορία όχι για ένα ολοκληρωμένο έργο"

Όταν χρησιμοποιούμε πολλαπλά ιστογράμματα, μπορούμε να δημιουργήσουμε τους ελεγκτές προβολής με πολλούς τρόπους, για να διαβάσουμε βαθιά αυτό το άρθρο σχετικά με τη χρήση πολλαπλών storyboards.
Πολλοί ιστορικοί μπορούν να χρησιμοποιηθούν ως εξής:

enum AppStoryboard: String {
   υπόθεση Κύριο = "Κύριο"
   περίπτωση PreLogin = "PreLogin"
   παράδειγμα: UISboard {
      επιστροφή UISboard (όνομα: self.rawValue, δέσμη: μηδέν)
   }}
}}
// ΧΡΗΣΗ:
αφήστε storyboard = AppStoryboard.Main.instance
αφήστε loginVC = AppStoryboard.PreLogin.instance.instantiateViewController (μεIdentifier: "LoginVC")
// Old Way
αφήστε storyboard = UIStoryboard (όνομα: "Main", δέσμη: Bundle.main)

7. Παραλείψτε χρησιμοποιώντας το Globals:

Είναι μια καλή πρακτική να χρησιμοποιούμε τις μεταβλητές και τις λειτουργίες του Παγκοσμίου Ιστού, μπορεί να μας βοηθήσει να κάνουμε καθαρό κώδικα και να αυξήσουμε την επαναχρησιμοποίηση κώδικα. Αλλά θα είναι καλύτερα να χρησιμοποιήσω επέκταση για το ίδιο. Διότι δημιουργώντας μια παγκόσμια τάξη κάνουμε μια "τάξη GOD". Επομένως, επιτρέπει τη διάσπαση των καθηκόντων παγκόσμιας κλάσης χρησιμοποιώντας επεκτάσεις, θα καταστήσει τον κώδικα πιο καθαρό, ευανάγνωστο και επαναχρησιμοποιούμενο.

Αρέσει:

// Μέση Πρακτική
τετράγωνο func (x: Int) -> Int {επιστροφή x * x}
ας square3 = τετράγωνο (x: 3) // Εκτύπωση: 9
τετράγωνο (χ: τετράγωνο3) // Εκτύπωση: 81
// Μεγάλη Πρακτική
επέκταση Int {
   var square: Int {επιστρέφει μόνος * αυτο}
}}
3.square // Εκτύπωση: 9
3.square.square // Εκτύπωση: 81

Λάβετε μερικές επεκτάσεις από το GitHub.

8. Χρήση γενικών:

Τα Generics σας επιτρέπουν να δηλώσετε μια μεταβλητή η οποία, κατά την εκτέλεση, μπορεί να αντιστοιχιστεί σε ένα σύνολο τύπων που ορίζονται από εμάς.

// Μέση Πρακτική
var stateName = "Uttar Pradesh", "Kerala", "Assam", "Punjab"]
var areaArray = [240928, 38863, 78438, 50362]
var ανάπτυξη = [20,1, 4,9, 16,9, 13,7]
func printStateName (obj: [String]) {print ("stateNames: \ (obj)")}
()) {print ("περιοχές: \ (obj)")}
func printStateGrowth (obj: [Double]) {print ("αύξηση πληθυσμού: \ (obj)")}
printStateName (obj: stateName)
printStateArea (obj: areaArray)
printStateGrowth (obj: ανάπτυξη)
// Μεγάλη Πρακτική
()) () () () () () () () ()
printArray (stateName, μήνυμα: "stateNames:")
printArray (περιοχήArray, μήνυμα: "περιοχές:")
printArray (ανάπτυξη, μήνυμα: "αύξηση του πληθυσμού:")

Σας ευχαριστούμε που διαβάζετε, παρακαλώ πατήστε το σύμβολο εικονίδιο, αν θέλετε όπως αυτή τη συλλογή