Organizing Your Swift Global Constants for Beginners

Let’s clean up that code

This article is aimed at those beginners looking to better organize their app’s important data and resources, such as colors, fonts, images, strings, URLs, etc.

There are a few different ways of going about organizing these items. I think that each has its own merit. This solution I’m presenting here is thoroughly organized using Swift structs.

You can read more about the power and use of structs here in the documentation but for keeping this tutorial focused, let's move on.

Getting Started

Before we get started creating our file, let's go over why this is important. We don’t want to be using the same string, color, or image in ten different places, you want to have one definition, which is then referenced in ten different places.

If you have the string value of Title, or a comment icon image that is used in various areas of your app and need to make a change, you’d have to find all the different definitions and change them individually.

But if we have one Constant definition that's then referenced, all we have to do is change the Constant and all references are updated. Simple, right.

Data to Be Referenced

Let's go over the kind of data we might want to create Constants for.

Colors

static let blue = UIColor.rgba(red: 0, green: 255, blue: 255, alpha: 1)
// this definition utilizes a great little RGBA Extensions, is provided below

Images

static let icoStar = UIImage(named: "ico_imageName")
static let icoComment = UIImage(named: "ico_imageName")

Fonts

static let Body = UIFont.systemFont(ofSize: 16, weight: .regular)
static let headingOne = UIFont.systemFont(ofSize: 22, weight: .semibold)

Content strings

static let email = "Email Address"
static let typeMessage = "Type a message…"
// if you want to Localize your Strings, i'd suggest just reading up on that if you need it. we won't be covering it here

API

static let twitterApiUrl = URL(string: “https://api.twitter.com/")
static let DB_REF = Firestore.firestore()
static let USERS_DB_REF = DB_REF.collection(USERS_REF)

So, this should give you a pretty good picture of how each constant is defined. Next, we’ll get into structures and how to organize all the data.

Creating Our App Constant File

Start off by creating a new file, File > New > File, choose Swift File.

Name the file AppConstants.swift into a folder named something like Utils.

Make sure to import UIKit.

Create the Parent/Root struct that will contain each struct type. You can call it whatever works for you App, Main, Constants, whatever. Let’s just call ours Constants.

Now, let's add three structs, called Design, Content, and API.

Within Design, we want to organize our Design constants into three different structs, Color, Image, and Font.

Now add three to the color struct, Primary, Secondary, and Grayscale.

You could always just use Color, but personally, I try to be as organized as possible, that way when you use the Constant, you get a really clear understanding and context of the Constant.

This is really good for someone not familiar with your code, it quickly gives them context.

An example would be:

button.backgroundColor = Constants.Design.Color.Primary.Blue
button.font = Constants.Design.Font.HeadingOne

This way of organization and naming lets our Constants give useful information to what it is. OK, this is Design-related, it’s a Color, a Primary Color.

Time to Add Constant Values

Adding the Design Constants:

Referencing Colors:

textField.backgroundColor = Constants.Design.Color.Grayscale.Light
textField.borderColor = Constants.Design.Color.Grayscale.Mid

Referencing Fonts:

label.font = Constants.Design.Font.HeadingTwo

Adding Content and API Constants

Content usually is anything that requires a text string. Labels, Buttons, TextViews, etc.

static let Email= "Email Address"
static let Login= "Login"

Another use for string Constants is for using dummy text. If you need to test long character lengths, you can do so with dummy text.

static let dummyText = "Lorem ipsum"
static let dummyTextMedium = "Lorem ipsum dolor sit amet"

API is a section that I'll use for anything related to outside services; API calls, database calls, anything related to those two. You might see an API struct that looks like this:

And you’d reference these Constants like this:

Also, best practice when defining API Constants is to uppercase them.

The full template:

Also, here's an extension I created for handling RGBA colors:

This wraps up this tutorial. I think there are other options for handling Constants, such as using enumerations or extensions, but for any beginners out there looking to get up and running quickly, this is a great little solution that will, hopefully, make your life easier.

One last tip I can give is to try and actually create this file first thing when you’re starting a new project.

That way, you’ve defined a lot of your design elements upfront and can move forward without needing to stop and create these constants, or constantly change them. It’s a good foundation to get yourself started. Cheers.