Daha iyi bir Swift geliştiricisi olmak için ipuçları

Swift, geliştiricilerin, Objective-C'ye göre daha güvenli, daha hızlı, daha okunaklı ve güvenilir kodlamalarına yardımcı olan özellikleri sunar. İşte bu yeni dili (Swift) kullanarak tecrübemizle topladığımız bazı özet ipuçları. Kodu daha güvenli ve temiz bir şekilde yazmamıza yardımcı oldular.

Bu tartışmayı iki bölüme ayırdım. Birincisinde, hızlı bir şekilde başlayanlara, ikincisinde ise zaten kullananlar için tartışıyoruz.

Yeni başlayanlar için ipuçları

1. Doğrulamak için Oyun Alanı kullanın:

Ne zaman herhangi bir mantık deneyi yapacak ve oyun alanında doğrulayacaksanız, öğrenme amacıyla da kullanabilirsiniz.
Oyun alanı hızlı için çok kolay ve etkileşimli bir araçtır. Oyun alanının yeni bir proje yaratmasına gerek yok . Oyun alanı basit oluşturmak için Xcode başlatmaktan bir seçenek olarak seçin:

Oyun alanı Xcode içinde de oluşturulabilir:

Oyun alanına girdikten sonra, kodu sol tarafa yazabilir ve sonuç sağ tarafta ve alt kısmında olur:

2. Opsiyonları Güvenle Kullanın:

İsteğe bağlı, geçerli bir değeri olan veya hiçbir şey olmayan bir özelliktir (nil). Ne zaman bir isteğe bağlı baskı yapacağız. İsteğe bağlı (değer) olarak bazı ekstra metinlerle değeri yazdırır. İsteğe bağlı özellik adının sonunda bir ünlem işareti (!) Kullanarak isteğe bağlı olarak paketten paketini açabiliriz, ancak bundan kaçınmalıyız. Zorla açılmamış olarak bilinen bu, uygulama çökmelerine yol açar. Bu nedenle ünlem işareti (!) İşaretinin kullanılması tehlikelidir .

Ünlem (!) İşaretinin kullanıldığı bazı özel durumlar vardır.
Örneğin: IBOutlet, arayüz oluşturucusundan bir çıkış oluşturduğunuzda, dolaylı olarak açılmamış bir isteğe bağlı olacaktır, çünkü UIKit, çıkışınızı arayüz oluşturucuya bağladığınızı / bağladığınızı varsayar . Bu nedenle, isteğe bağlı bir değerin örtük olarak açılmasını kullanmak risklidir.
Bunu ele almak için izin verirseniz kullanabilirsiniz:

var adı: Dize? = "Sevinç"
var lastName: Dize?
print (name) // Sonuç: İsteğe bağlı ("Joy")
print (name!) // Sonuç: Sevinç
Eğer let = = {
    Baskı (değer)
} Başka {
    Yazdır ("ad ayarlanmadı")
}
// Sonuç: Sevinç, çünkü adın değeri var
eğer izin verirse lastNameNew = lastName {
    yazdırmak (lastNameNew)
} Başka {
    yazdır ("soyadı belirlenmedi")
}
// Sonuç: soyad ayarlanmadı, çünkü soyad herhangi bir değere sahip değil

3. Sabitleri tek bir dosyada yönetin:

Projenizin sabitlerini yönetmek için bir dosya oluşturun ve tüm sabitleri burada yönetin. Tüm sabitleri yapı ya da enum olarak düzenleyin:

enum AppConstants {
   static let AppName = "MyFirstApp"
   static let NoInternetMessage = "Üzgünüz! İnternet bağlantısı yok"
}

Kodunuzun okunabilirliğini yönetmek ve sürdürmek için tam bir yardım.
Uygulama kodunuzdaki birçok yerde NoInternetMessage'i kullandığınızı ve şimdi mesajda bazı değişiklikler yapmanız gerektiğini varsayalım, mesajı yalnızca tek bir yerde kolayca değiştirebiliyorsunuz, otomatik olarak her yere yansıtılıyor.

4. İç içe geçmiş fonksiyonun kullanımı:

İç içe geçmiş işlev olarak bilinen, diğer işlevlerin gövdelerinde bir işlevi tanımlayabilirsiniz.
İç içe işlevler dış dünyadan gizlenir, ancak çevreleme işlevleri tarafından çağrılabilir ve kullanılabilir. Bir çevreleme işlevi iç içe geçmiş işlevini de döndürebilir, böylece dış dünyada veya başka bir kapsamda kullanılabilir.
Kodunuzun okunabilirliğini ve yeniden kullanılabilirliğini artıracaktır.

func chooseStepFunction (geriye doğru: Bool) -> (Int) -> Int {
   func stepForward (giriş: Int) -> Int {dönüş girişi + 1}
   func stepBackward (giriş: Int) -> Int {dönüş girişi - 1}
   geri dönüş? stepBackward: stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction (geriye: currentValue> 0)
// moveNearerToZero şimdi iç içe stepForward () işlevine atıfta bulunuyor
currentValue! = 0 {
   Yazdır ("\ (currentValue) ...")
   currentValue = moveNearerToZero (currentValue)
}
( "Sıfır!") Yazdırmak
//Sonuç:
// -4 ...
// -3 ...
// -2 ...
// -1 ...
// sıfır!
Sizin için son bir ipucu daha, profesyonellerin tavsiyelerine de gidebilirsiniz.

Profesyoneller için ipuçları

  1. Muhafız kullanımı:

Herhangi bir işlem yapıldığında, gerekli tüm verilerin uygun şekilde çalışabildiğinden emin olmak istersiniz. Daha sonra, genel olarak geliştiriciler bunu iki şekilde çözdüler:

a. Kıyamet piramitleri:

Geliştirici, ihtiyaç duyulan her veriden emin olmak istediğinde, kullanılan her özelliği şöyle doğrular:

var userName: String?
var email: String?
var parola: String?
var policyAccepted: Bool = yanlış
func checkAndSave () {
   eğer uname olsun = userName {
      eğer posta = e-posta ise {
         eğer izin verirseniz pwd = şifre {
            politika kabul edilirse {
               // harika şeyler yapın, kaydolma gibi
            }
         }
      }
   }
}

Bu, kıyamet piramitleri olarak bilinir, çünkü koşulların piramidini yaratırız. ”

b. Koşullu İade:

Daha sonra kıyamet piramitleri üzerinde, geliştiriciler onu koşullu geri dönüşüme dönüştürdüler, kullanılan her özellik için doğruladılar ve geri dönüşleri:

func checkAndSave () {
   eğer uname olsun = userName {return}
   eğer posta = e-postaya giderse {return}
   izin verirseniz pwd = şifre {return}
   policyAccepted {return} ise
   
   // harika şeyler yapın, kaydolma gibi
}

Koşullu iade olarak bilinir, çünkü her koşul başarısızlığına geri dönüyoruz .
- İlk çözüm, kod okunabilirliği ve hata ayıklama anlamında iyi değil, bu yüzden buna devam edemeyiz.
- İkinci çözüm de yeterince iyi değil, çünkü işlevden gereksiz yere geri geliyorlar, neden geri verdiğimizi bulamıyor musunuz?
- Başka bir çözüm, izin verirsek kullanabiliriz, ancak değişken kapsamının if bloğunda olduğu gibi bazı kısıtlamaları da vardır, bu yüzden tekrar doom piramitine eds piramit gerekir.

Öyleyse, işte hızlıca 2.0'da tanıtılan koruma izni kavramı geliyor. Kullanımı çok basit ve kolaydır, koşullar ve let deyimleri bir arada kullanılabilir.

func checkAndSave () {
bekçi uname let = userName, let mail = email, let pwd = şifre, policyAccepted {
   dönüş
}
// harika şeyler yapın, kaydolma gibi
}

2. Erteleme bloğunun kullanımı:

erteleme bir bloktur, “Ne olursa olsun daha sonra uygulamak istediğim bazı talimatlar?” anlamına gelir. Tek bir kod satırı veya bir sürü kod satırı içerebilir. İşlev yürütme bittiğinde meydan okuyacağınız bir işlevdeki bir erteleme bloğu tanımlayabiliriz. Ayrıca kod yedekliliğini de azaltır.
- Diyelim ki, bir işlevde herhangi bir kaynağın nesnesi oluşturuyorsunuz ve bir şeyi kontrol etmek için guard anahtar sözcüğünü kullanıyorsunuz ya da herhangi bir koşuldan yürütmeyi geri veriyorsanız, o zaman ya kaynağınız bellekte olacaktır ya da işlevin yerine getirilmesinden önce onu serbest bırakmalısınız. Böylece kod yedekliliğine yol açarsınız ya da yanlışlıkla kaynağı bellekte bırakabilirsiniz . Bu durumu önlemek için kaynak serbest bırakma kodunu erteleme bloğuna yazabiliriz. gibi:

func processFile (dosyaadı: Dize), {
   eğer varsa (dosya adı) {
      let file = open (dosya adı)
      // açık dosyayı kapatmak için burada erteleme bloğu tanımlandı
      ertelemek
         dosyayı kapat)
      }
      let userName = getUserName ()
      guard userName! = "" else {return}
      file.write (kullanıcı adı)
      let userAge = getUserName ()
      guard userAge> = 18 else {return}
      file.write (userAge)
      
      // close (file) burada kapsamın sonunda denir.
   }
}

3. wherekeyword:

Koşulla örüntü eşleme kullanmak istiyorsanız, daha önce hızlı bir şekilde kullanın, ardından iki if ifadesini ayrı olarak kullanmalısınız:

var webUrl: String? = "https://medium.com"
eğer izin verilsin yolu = webUrl {
   eğer path.hasPrefix ("https") {
      // harika şeyi yap
   }
}

Daha sonra, Swift 2.0 sürümündeki anahtar kelimenin tek bir ifadede aynı şeyi yapması için nerede:

eğer let path = webUrl nerede path.hasPrefix ("https") {
   // harika şeyi yap
}

Şimdi, Swift, anahtar kelimenin yerini (virgül) işareti ile değiştirdi:

eğer izin ver path = webUrl, path.hasPrefix ("https") {
   // harika şeyi yap
}

Öyleyse, nerede daha fazla kullanım dolu. Where. hakkında devamını oku

4. Özel temsilciliği zayıflatın:

Bekle… zayıf ve delege nedir? Kesin tanım için elma geliştiricisinde kontrol edelim.
Zayıf bir referans, başvurduğu örnek üzerinde güçlü bir tutuma sahip olmayan ve bu nedenle ARC'nin başvurulan örneği elden çıkarmasını durdurmayan bir referanstır.
Temsil yetkisi, bir sınıfın veya yapının başka türdeki bir örneğe karşı sorumluluklarının bir kısmını vermesini (veya devretmesini) sağlayan bir tasarım desenidir.

B sınıfında herhangi bir A sınıfının temsilcisini atadığınızda, B sınıfında A sınıfının güçlü referansını saklarsınız ve A sınıfı da B sınıfının güçlü referansını temsilci olarak tutar. Bu yüzden nesneler için alıkoyma döngüsüne sahip olacak ve hafıza ile ilgili sorunlar olacak ve uygulama çökecek .

Bu nedenle, bir dahaki sefere özel delegelerinizi oluşturacağınız zaman, onları zayıf bir referans olarak oluşturduğunuzdan emin olun:

protokol myCustomDelegation: sınıf {
   func newFunction (vaueToBeShare: String)
}
a sınıfı {
   zayıf var delege: myCustomDelegation?
   // temsilciyi tutma döngüsünü kırmak için zayıf yapmak
}
B sınıfı: myCustomDelegation {
   dahili işlev newFunction (vaueToBeShare: String) {
      // delege ateşlendiğinde burada bir şeyler yapın
   }
   let obj = A () // A sınıfı güçlü bir referansı tutmak
   içinde() {
      obj.delegate = self // A sınıfı A'nın B temsilcisine atanması
   }
}

5. KVO Kullanmayı Atlayın:

KVO (Anahtar Değer Gözlemcisi), herhangi bir tuş için ayarlayabilir ve gözlemleyebilir ve bu tuşun değeri değiştiğinde işlem gerçekleştirebilirsiniz. Hızlı ancak iyi bir yaklaşım değil çünkü biraz zaman uygulamanın çökmesine yol açacak gözlemciyi çıkarmayı unuttuk ya da gözlemciler her zaman yayınlandı, bu yüzden başa çıkmak için acı dolu.

KVO'nun mülk gözlemcisi olan süratle değiştirileceğini düşünüyoruz. Kullanarak, mülkün değeri değiştiğinde işlem yapabiliriz. Var :

  • willSet, değer kaydedilmeden hemen önce çağrılır.
  • Yeni değer kaydedildikten hemen sonra didSet çağrılır.
newClass sınıfı {
   var myNewObj: Int = 0 {
      willSet (newValue) {
         print ("newValue = \ (newValue), oldValue = \ (myNewObj)")
      }
 
      didSet {
         print ("oldValue = \ (oldValue), currentValue = \ (myNewObj)")
      }
   }
}
let obj = newClass ()
obj.myNewObj = 5
// Sonuç: newValue = 5, oldValue = 0
// Sonuç: oldValue = 0, currentValue = 5
obj.myNewObj = 8
// Sonuç: newValue = 8, oldValue = 5
// Sonuç: oldValue = 5, currentValue = 8

Özelliğe yeni bir değer atandığında myNewObj için willSet ve didSet gözlemcileri çağrılır. Bu, yeni değer şu anki değer ile aynı olsa bile geçerlidir.

Mülkiyet1 değerini mülk gözlemcisinde mülk2 ve mülk2 mülkünü mülk1 örneğinde değiştiriyorsanız, bir zincir oluşturacak, derleme zamanında hiçbir şey söyleyemeyeceğiniz bir zincir yapacaktır.

6. Birden Çok storyboard kullanın:

Film şeridi, bir iOS uygulamasının kullanıcı arayüzünün, içerik ekranlarını ve bu ekranlar arasındaki bağlantıları gösteren görsel bir temsilidir.
Xcode varsayılan olarak bir hikaye tahtası oluşturur ve geliştiriciler bunu eksiksiz uygulama için kullanırlar, böylece bir canavar haline gelir ve projeniz için Xcode'da yükleme süresini ve bunun yanı sıra cihaza uygulamanızın başlama süresini de arttırır,
Bu nedenle, uygulamanızda birden fazla storyboard oluşturmaya çalışın.

“tam bir proje için değil, tam bir hikaye için storyboard kullanın”

Birden fazla storyboard kullanırken, birden fazla storyboard kullanımı hakkındaki bu makaleyi derinden okumak için görünüm denetleyicilerini birçok şekilde oluşturabiliriz.
Birden çok film şeridi şu şekilde kullanılabilir:

enum AppStoryboards: String {
   Büyük / küçük harf = "Main"
   case PreLogin = "PreLogin"
   var örnek: UIStoryboard {
      dönmek
   }
}
// KULLANIM:
Let Storyboard = AppStoryboard.Main.instance
loginVC = AppStoryboard.PreLogin.instance.instantiateViewController (withIdentifier: "LoginVC") izin ver
// Eski yol
let storyboard = UIStoryboard (ad: “Ana”, paket: Bundle.main)

7. Globals'ı kullanarak atlayın:

Global değişkenleri ve işlevleri kullanmak iyi bir uygulamadır, temiz kod oluşturmamıza ve kod yeniden kullanılabilirliğini arttırmamıza yardımcı olabilir. Ama bunun için uzatma kullanmak daha iyi olacağım. Çünkü Global bir sınıf oluşturarak “GOD Class” yapıyoruz. Bu sayede Global sınıf görevlerini uzantıları kullanarak bölelim, kodu daha temiz, okunaklı ve tekrar kullanılabilir hale getirin.

Sevmek:

// Ortalama Uygulama
func square (x: Int) -> Int {return x * x}
let square3 = square (x: 3) // Yazdır: 9
kare (x: kare3) // Yazdır: 81
// Büyük Uygulama
uzantı Int {
   var square: Int {dönüş öz * öz}
}
3.square // Yazdır: 9
3.square.square // Yazdır: 81

GitHub'dan bazı uzantılar alın.

8. Genrics Kullan:

Jenerikler, yürütme sırasında bizim tarafımızdan tanımlanan bir dizi gruba atanabilecek bir değişken tanımlamanıza izin verir.

// Ortalama Uygulama
var stateName = ["Uttar Pradesh", "Kerala", "Assam", "Pencap"]
var areaArray = [240928, 38863, 78438, 50362]
var büyüme = [20.1, 4.9, 16.9, 13.7]
func printStateName (obj: [String]) {print ("stateNames: \ (obj)")}
func printStateArea (obj: [Int]) {print ("alanlar: \ (obj)")}
func printStateGrowth (obj: [Double]) {print ("nüfus artışı: \ (obj)")}
printStateName (obj: durumAdı)
printStateArea (obj: areaArray)
printStateGrowth (obj: büyüme)
// Büyük Uygulama
func printArray  (_ obj: T, mesaj: String = "") {print ("\ (mesaj) \ (obj)")}
printArray (stateName, message: "stateNames:")
printArray (areaArray, message: "areas:")
printArray (büyüme, mesaj: "nüfus artışı:")

Okuduğunuz için teşekkür ederiz, lütfen bu koleksiyona benziyorsa önerilen simgeye tıklayın