Best Practices

📅
- Journey through 7
Best Practices
- The Bigger Picture

Unwrap an
optional that
should never be nil

Undeﬁned state
Nil auth token
Failure to load
payment data
Data Corruption

guard let token = token else {
fatalError(“You must supply a token”)
}
print(token)

let number = number !! "Number should never be nil"

What if you can’t
provide a good
error message?

guard let number = number else {
fatalError("Number should never be nil")
}
Vs
number!

1. Never force unwrap when you
can provide a useful error
message

let url = URL(string: “http://www.google.com”)
let image = UIImage(named: “icon")

Validate with test or script
let url = URL(string: “http://www.google.com”)!
let image = UIImage(named: “icon”)!

1. Never force unwrap when you
can provide a useful error
message or its not a static
developer typo

2. Document all public methods

Is your documentation
actually useful?

/// Create item
///
/// - Parameters:
/// - author: The item's author
/// - title: The item's title
/// - length: The item's length
func createItem(author: String, title: String,
length: TimeInterval) {
}

2. Document all public methods
if the documentation adds value

3. Aim for high unit test code
coverage.

Are your tests
actually useful?

func testConstructor() {
let viewController = factory.makeViewContoller()
XCTAssertTrue(viewController is TestViewController)
}

Only test things that
might actually fail.

3. Cover a unit’s behaviour
with good unit tests.

One shared instance.
Globally Accessible.

class UserData {
static let shared = UserData()
var authToken: String?
var name: String?
var image: UIImage?
}

class UserData {
static let shared = UserData()
var authToken: String?
var name: String?
var image: UIImage?
}
Why it’s ‘bad'
- Mutable shared state
- Implicit lifetime
- Difﬁculty testing
- Implicit dependency

UIApplication.shared
UserDefaults.standard
FileManager.default

Represents a
single property of
the environment.

4. Avoid Singletons for objects
that are not single properties
of the environment

But what if you’re
working on open
source framework?

import Kingfisher
imageView.kf.setImage(with: url)

let task = KingfisherManager.shared.retrieveImage(
with: source,
options: options,
completionHandler: { result in
CallbackQueue.mainCurrentOrAsync.execute {
completionHandler?(result)
}
}
)

4. Avoid Singletons for objects
that are not single properties
of the environment unless it
improves the API and
integration of your framework
for third party apps

5. Prefer structs over classes

Structs -> Value
Classes -> Reference

Similarities
- Stored / Computed Properties
- Methods
- Subscripts
- Initialisers
- Extensions.
- Protocol conformance.

Struct beneﬁts
- No shared state
- Generally faster/lighter
- Multi threading

struct Germany {
let towns = ["Cologne", "Düsseldorf" , "Wuppertal"]
}

Replacing singletons:
FileManager /
BluetoothManager etc.

Properties should be value
types too for some of the
beneﬁts

struct SwiftConf {
var text: String
}
var a = SwiftConf(text: "StructText")
var b = a
b.text = "ModifiedStructText"
print(a.text)
print(b.text)

class TextContainer {
var text: String
init(text: String) {
self.text = text
}
}
struct SwiftConf {
var textContainer: TextContainer
}
var a = SwiftConf(textContainer:
TextContainer(text: "ClassText"))
var b = a
b.textContainer.text = "ModifiedClassText"
print(a.textContainer.text)
print(b.textContainer.text)

when the thing it represents
and its properties have value
semantics

Until we’re talking about
complex nested structs

Arrays, dictionaries, and strings
use copy-on-write optimization

struct User {
var name: String?
}

class UserStorage {
var name: String?
init() {}
}
struct User {
public var storage: UserStorage
init() {
self.storage = UserStorage()
}
public var name: String? {
get {
return storage.name
}
set {
if isKnownUniquelyReferenced(&storage) {
storage.name = newValue
}
else {
storage = UserStorage()
storage.name = newValue
}
}
}
}

when the thing it represents
and its properties have value
semantics unless it’s a complex
nested struct, which should be
backed by a class

Mutable data
model
- Shared state
- Multi threading

struct User
{
let name: String
}

struct User
{
let name: String
}
extension User
{
func withName(_ name: String) -> User {
return User(name: name)
}
}

Value types are
always ‘immutable’ *

struct User
{
var name: String
}

7.Don’t store things in user
defaults

UserDefaults.standard.set("SwiftConf", forKey: "Conference")
let name = UserDefaults.standard.value(forKey: "Conference")

Alternatives
- Writing to a ﬁle
- Keychain
- Sqlite
- Core Data

Loads into memory the
entire suite on ﬁrst read.
🐌

7.Don’t store a lot of data or
anything sensitive in user
defaults

class Wurst: NSObject, Edible, Purchasable, UIToolbarDelegate {
func eat() {
// Eat
}
func buy() {
// Buy
}
func position(for bar: UIBarPositioning) -> UIBarPosition {
return .top
}
}

class Wurst: NSObject {
}
//MARK: Purchasable Conformance
extension Wurst: Purchasable {
func buy() {
// Buy
}
}
//MARK: Edible Conformance
extension Wurst: Edible {
func eat() {
// Eat
}
}
//MARK: UIToolbarDelegate Conformance
extension Wurst: UIToolbarDelegate {
func position(for bar: UIBarPositioning) -> UIBarPosition {
return .top
}
}

9. Use extensions for better
code structure 🆕

They can also fall
out of favour

var someString = "a String "
someString.stringByAppendingString("anotherString")

var someString = "a String "
someString.append("another String")

Best practices are a
snapshot of what the
community currently
believes

Software Engineering
community

They are good
general guidelines

Challenge and
help evolve better
programming
practices

Best Practices

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Best Practices

Similar a Best Practices (20)

Último

Último (20)

Best Practices