10 Swift extensions we use at Livefront

Hello, Habr. Translation prepared as part of an online course “iOS Developer. Basic”.

We invite everyone to a free two-day intensive “Creation of the simplest application without a single line of code.” On the first day we will find out:

1. What is Xcode?
2. How “screens are drawn”
3. Add buttons and input fields to the screens. Let’s create an authorization screen.
4. Let’s create a second screen of our application and add a transition to it from the authorization window.
You can register here.

Add your own flavor to Swift

Let’s be honest. The Swift and Apple frameworks do not have all the functionality needed to create the best software for Apple devices. Fortunately, Swift supports extensions so that we can add the missing pieces we need for a better experience.

If you are new to Swift, please refer to documentationto learn more about Extensions before continuing.

In this article, I will focus on extensions that add additional functionality to existing types. Extensions can also add default functionality for protocols, add restrictions on protocol types, and more.

When creating your own extensions, I would recommend creating some unit tests to test their execution to make sure you get the desired result.

In an effort to keep the content below relatively short, I have not included our unit tests in the description.

you can find Xcode Playgroundused in this article on my GitHub page.

Here are just 10 of the many extensions we use at Livefront.

1. UIView – Limitations

Adding constraints to UIView

import PlaygroundSupport
import UIKit

// Extension #1 - A helper method to add a view to another with top, left, bottom, and right constraints.
extension UIView {

    /// Add a subview, constrained to the specified top, left, bottom and right margins.
    /// - Parameters:
    ///   - view: The subview to add.
    ///   - top: Optional top margin constant.
    ///   - left: Optional left (leading) margin constant.
    ///   - bottom: Optional bottom margin constant.
    ///   - right: Optional right (trailing) margin constant.
    func addConstrained(subview: UIView,
                        top: CGFloat? = 0,
                        left: CGFloat? = 0,
                        bottom: CGFloat? = 0,
                        right: CGFloat? = 0) {
        subview.translatesAutoresizingMaskIntoConstraints = false

        if let top = top {
            subview.topAnchor.constraint(equalTo: topAnchor, constant: top).isActive = true
        if let left = left {
            subview.leadingAnchor.constraint(equalTo: leadingAnchor, constant: left).isActive = true
        if let bottom = bottom {
            subview.bottomAnchor.constraint(equalTo: bottomAnchor, constant: bottom).isActive = true
        if let right = right {
            subview.trailingAnchor.constraint(equalTo: trailingAnchor, constant: right).isActive = true

// Implementation
class ViewController: UIViewController {

    let newView = UIView()

    override func viewDidLoad() {
        view.backgroundColor = .systemBlue

        newView.backgroundColor = .systemTeal
        view.addConstrained(subview: newView, top: 50, left: 100, right: -100)

let viewController = ViewController()
PlaygroundPage.current.liveView = viewController

Instead of remembering to install translatesAutoresizingMaskIntoConstraints in false, add a display to the parent view and set all individual constraints, this helper method will do all of this for you. This method allows you to set top, front, back and bottom constraints on the parent view. If you omit one of the constraint parameters, the constraint will be null, attaching the display to the edge of the parent view. To completely close the parent view, omit all constraint options.

2. Date – Date according to the universal coordinate time (UTC Date)

Creating a Date object from a string in UTC timezone

import Foundation

// Extension #2 - Create a date object from a date string with the UTC timezone.
//Inspired by: https://developer.apple.com/library/archive/qa/qa1480/_index.html
extension Date {
    /// Returns a date from the provided string.
    /// - Parameter utcString: The string used to create the date.
    /// - Returns: A date from the provided string.
    static func utcDate(from utcString: String) -> Date? {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZ"
        formatter.locale = Locale(identifier: "en_US_POSIX")
        formatter.timeZone = TimeZone(abbreviation: "UTC")!
        return formatter.date(from: utcString)

// Implementation
let utcDateString = "2021-04-03T14:00:00.000Z"
let utcDate = Date.utcDate(from: utcDateString) //Playgrounds will show this in the machine's timezone.

The REST API usually returns a date string in UTC timezone. The above static method allows you to convert a string to an object Date… If you are having problems with this extension in your own project, make sure to dateFormat matches the format of the date string you receive.

3. String – Get URLs

Get valid urls from string

import Foundation

// Extension #3 - Retrieves valid URLs from a given string.
//Credit - Thanks to Paul Hudson for the core functionality on this extension.
//Source - https://www.hackingwithswift.com/example-code/strings/how-to-detect-a-url-in-a-string-using-nsdatadetector
extension String {
    /// Searches through a string to find valid URLs.
    /// - Returns: An array of found URLs.
    func getURLs() -> [URL] {
        var foundUrls = [URL]()
        guard let detector = try? NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue) else {
            return foundUrls

        let matches = detector.matches(
            in: self,
            options: [],
            range: NSRange(location: 0, length: self.utf16.count)

        for match in matches {
            guard let range = Range(match.range, in: self),
                  let retrievedURL = URL(string: String(self[range])) else { continue }

        return foundUrls

// Implementation
let unfilteredString = "To get the best search results, go to https://www.google.com, www.duckduckgo.com, or www.bing.com"
let urls = unfilteredString.getURLs()

This helper method comes in very handy when you have multiple URLs in a given string. I would highly recommend writing some unit tests to make sure this method fetches the intended URLs for your particular JSON response.

4. UIStackView – removing views

Removing all subviews from UIStackView

import UIKit

// Extension #4 - Removes all views from a UIStackView.
extension UIStackView {
    /// Removes all arranged subviews and their constraints from the view.
    func removeAllArrangedSubviews() {
        arrangedSubviews.forEach {

// Implementation
let view1 = UIView()
let view2 = UIView()
let view3 = UIView()

let stackView = UIStackView()

//Add subviews to stackView

//Confirm stackView contains 3 views
stackView.arrangedSubviews.count    //3
//Remove views from stackView

//Confirm stackView doesn't contain any subviews now
stackView.arrangedSubviews.count    //0

There are several steps to be followed when removing mappings from UIStackViewsuch as removing them from the stack mapping itself, deactivating any constraints, and completely removing them from the parent mapping. This helper method takes care of all these steps for you.

5. Bundle – Application version and build number

Get app version and build number

import Foundation

// Extension #5 - retrieve the app version # and build #.
//Inspired by https://stackoverflow.com/questions/25965239/how-do-i-get-the-app-version-and-build-number-using-swift
extension Bundle {
    /// Retrieve the app version # from Bundle
    var releaseVersionNumber: String? {
        return infoDictionary?["CFBundleShortVersionString"] as? String

    /// Retrieve the build version # from Bundle
    var buildVersionNumber: String? {
        return infoDictionary?["CFBundleVersion"] as? String

// Implementation
let releaseVersionNumber = Bundle.main.releaseVersionNumber
let buildVersionNumber = Bundle.main.buildVersionNumber

This is one of those features that should be included in Bundle… Rather than trying to remember an incomprehensible dictionary key, these computed properties will help you retrieve the application version and build number. Many apps include a version number in the settings menu.

6. Calendar – previous year

Determining last year as Integer

import Foundation

// Extension #6 - Get the prior year as an integer
extension Calendar {
    /// Returns the prior year as an integer.
    /// - Returns: Returns last year's year as an integer.
    func priorYear() -> Int {
        guard let priorYear = date(byAdding: .year, value: -1, to: Date()) else {
            return component(.year, from: Date()) - 1
        return component(.year, from: priorYear)

let priorYearAsNumber = Calendar.current.priorYear()

Everything is pretty straightforward here. The method will return the previous year as an Integer.

7. UIStackView – Convenience Init

Convenience Init (initialization) to simplify creation

import PlaygroundSupport
import UIKit

// Extension #7 - Make UIStackView creation a lot easier.
extension UIStackView {

    /// `UIStackView` convenience initializer for creating a stack view with arranged subviews, an
    /// axis and spacing.
    /// - Parameters:
    ///   - alignment: The alignment of the arranged subviews perpendicular to the stack view’s
    ///                axis.
    ///   - arrangedSubviews: The subviews to arrange in the `UIStackView`.
    ///   - axis: The axis that the subviews should be arranged around.
    ///   - distribution: The distribution of the arranged views along the stack view’s axis.
    ///   - spacing: The spacing to place between each arranged subview. Defaults to 0.
    convenience init(alignment: UIStackView.Alignment = .fill,
                     arrangedSubviews: [UIView],
                     axis: NSLayoutConstraint.Axis,
                     distribution: UIStackView.Distribution = .fill,
                     spacing: CGFloat = 0) {
        arrangedSubviews.forEach { $0.translatesAutoresizingMaskIntoConstraints = false }
        self.init(arrangedSubviews: arrangedSubviews)
        self.alignment = alignment
        self.axis = axis
        self.distribution = distribution
        self.spacing = spacing

// Implementation
let view1 = UIView()
view1.backgroundColor = .systemPink
let view2 = UIView()
view2.backgroundColor = .systemOrange
let view3 = UIView()
view3.backgroundColor = .systemTeal

let stackView = UIStackView(alignment: .leading,
                            arrangedSubviews: [view1, view2, view3],
                            axis: .vertical,
                            distribution: .fill,
                            spacing: 20)

let view = UIView(frame: CGRect(x: 0, y: 0, width: 500, height: 500))
view.backgroundColor = .systemBlue
stackView.translatesAutoresizingMaskIntoConstraints = false

    view1.heightAnchor.constraint(equalToConstant: 50),
    view1.widthAnchor.constraint(equalToConstant: 150),
    view2.heightAnchor.constraint(equalToConstant: 50),
    view2.widthAnchor.constraint(equalToConstant: 150),
    view3.heightAnchor.constraint(equalToConstant: 50),
    view3.widthAnchor.constraint(equalToConstant: 150),
    stackView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
    stackView.centerYAnchor.constraint(equalTo: view.centerYAnchor),

PlaygroundPage.current.liveView = view

Remember what properties you need to set for UIStackViewcan be tricky. This convenience initializer includes common properties as its parameters. The initializer also sets translatesAutoresizingMaskIntoConstraints in false for each of the views.

8.UIColor – Hex

Getting the Hex (hexadecimal) value of UIColor

import UIKit

// Extension #8 - generates a string with the hex color value.
//Inspired by: https://stackoverflow.com/a/26341062
extension UIColor {
    // MARK: - Helper Functions
    /// Returns the hex string for this `UIColor`. For example: `#FFFFFF` or `#222222AB` if the alpha value is included.
    /// - Parameter includeAlpha: A boolean indicating if the alpha value should be included in the returned hex string.
    /// - Returns: The hex string for this `UIColor`. For example: `#FFFFFF` or
    ///            `#222222AB` if the alpha value is included.
    func hexString(includeAlpha: Bool = false) -> String {
        let components = cgColor.components
        let red: CGFloat = components?[0] ?? 0.0
        let green: CGFloat = components?[1] ?? 0.0
        let blue: CGFloat = components?[2] ?? 0.0
        let alpha: CGFloat = components?[3] ?? 0.0
        let hexString = String.init(
            format: "#%02lX%02lX%02lX%02lX",
            lroundf(Float(red * 255)),
            lroundf(Float(green * 255)),
            lroundf(Float(blue * 255)),
            lroundf(Float(alpha * 255))
        return includeAlpha ? hexString : String(hexString.dropLast(2))

// Implementation
let whiteColor = UIColor(displayP3Red: 1, green: 1, blue: 1, alpha: 1)

let whiteHexString = whiteColor.hexString() //#FFFFFF
let blackColor = UIColor(displayP3Red: 0, green: 0, blue: 0, alpha: 1)

let blackHexString = blackColor.hexString() //#000000

This method retrieves the hexadecimal value UIColor and returns it as String… This can be very useful if you want to store and remember the meaning of a color for the user. Thus, you only need to store the hex string instead of the three RGB integer values.

9.UIViewController – Dark Mode

Check if dark mode is on

import UIKit

// Extension #9
extension UIViewController {
    /// Gets a flag indicating whether or not the UI is in dark mode.
    public var isDarkMode: Bool {
        if #available(iOS 12.0, *) {
            return traitCollection.userInterfaceStyle == .dark
        return false

UIColors, such as the .label, .systemBlue etc. are automatically configured when the user switches between light and dark mode, but you may want to add additional functionality when the user switches the look of the device. This computed property will allow you to check which appearance is active so you can react appropriately.

10.UICollectionView – Last IndexPath

Get last indexPath for collectionView

import PlaygroundSupport
import UIKit

// Extension #10 - get the last valid indexPath in a UICollectionView.
extension UICollectionView {

    /// Validates whether an `IndexPath` is a valid index path for an item in a collection view.
    /// - Parameter indexPath: The index path to validate.
    /// - Returns: `true` if the index path represents an item in the collection view or false
    ///     otherwise.
    func isValid(_ indexPath: IndexPath) -> Bool {
        guard indexPath.section < numberOfSections,
              indexPath.item < numberOfItems(inSection: indexPath.section)
        else {
            return false

        return true

    /// Provides the last valid `indexPath` in the collection view.
    /// - Parameter section: The section used to provide the last `indexPath`.
    /// - Returns: the last valid `indexPath` in the collection view or nil if not a valid `indexPath`.
    func lastIndexPath(in section: Int) -> IndexPath? {
        let lastIndexPath = IndexPath(row: numberOfItems(inSection: section) - 1, section: section)
        guard isValid(lastIndexPath) else { return nil }
        return lastIndexPath

// Implementation
class CollectionViewController: UICollectionViewController {

    let items = Array(1...100)

    override func viewDidLoad() {

        collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: "cell")

    override func numberOfSections(in collectionView: UICollectionView) -> Int {
        return 1

    override func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return items.count

    override func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let cell = collectionView.dequeueReusableCell(withReuseIdentifier: "cell", for: indexPath)
        cell.backgroundColor = .systemBlue
        return cell

let collectionViewController = CollectionViewController(collectionViewLayout: UICollectionViewFlowLayout())
let lastIndexPath = collectionViewController.collectionView.lastIndexPath(in: 0)
lastIndexPath?.section  //0
lastIndexPath?.row      //99
PlaygroundPage.current.liveView = collectionViewController

Finally, in UICollectionView added a method that returns the last valid one indexPath… This is another of those features that seems to already exist in UIKit. While this can be achieved by counting the number of items in collectionView and subtracting one in the view controller; adding it via an extension is a little safer.


I would say that it is almost impossible to create a project without adding at least one extension. Adding functionality through extensions makes Swift more powerful and allows you to create new functionality in a safe way. I advise you to search the Internet for “Swift Extensions” and enjoy all the creative solutions our fellow developers have come up with.

Feel free to share your favorite extension (s) in the comment below.


Protocol extensions

Swift extensions

Type Constraints Using Extensions

Learn more about the course “iOS Developer. Basic”

Participate in an intensive “Creating the simplest application without a single line of code”

Similar Posts

Leave a Reply