How to Create and Use Global Variables in Swift

When building an app in Swift, you might come across a scenario where you need to store data that should be accessible throughout the entire app. For such cases, Swift global variables can be highly useful.

In this blog, you'll learn how to create and use global variables, along with tips on best practices to avoid common pitfalls.

We'll also explore how to properly manage global state, when to use the static keyword, and how to store things like user preferences across your app. But before we dive into the code, let’s first understand what global variables are and how they work in Swift.

What is a Global Variable in Swift?

A global variable is a variable that is defined outside any function, class, or struct. It has global scope, meaning it can be accessed from anywhere in the entire app. Global variables are typically used when data needs to be shared across multiple parts of your app without passing it as a parameter to each function or class.

While this might seem convenient, it’s important to use global variables cautiously as they can lead to thread-safety issues and make your code harder to maintain. In most cases, using global variables is generally discouraged, except for situations where they simplify your design without introducing unnecessary complexity.

Why Use Global Variables?

There are several reasons you might want to use a global variable:

• Storing user preferences that need to be accessed throughout your app.

• Managing a global state like configuration settings or flags.

• Providing a shared instance of a class or singleton pattern for common use across the app.

How to Create a Global Variable in Swift

To create a global variable in Swift, you declare it outside any class, struct, or function. The following example shows how to define a simple global variable:

Copy
1
2
// Global variable defined outside of any class or function
var appTheme: String = "Light Mode"

Here, appTheme is a global variable that can be accessed and modified by any part of the app. Let's see how you can use it.

Copy
1
2
3
4
5
6
7
func toggleTheme() {
    if appTheme == "Light Mode" {
        appTheme = "Dark Mode"
    } else {
        appTheme = "Light Mode"
    }
}

In this case, appTheme holds a value that can be changed from anywhere within your app, providing a global scope for that data. You might use a global variable like this to store user interface settings.

Using the static Keyword for Global Data

While global variables are one approach, they aren't the only way to handle global data. In Swift, you can also use the static keyword within a class or struct to create a variable that behaves similarly to a global variable, but is more tightly scoped to a specific type context.

Here's how you might use the static var keyword within a class:

Copy
1
2
3
class AppConfig {
    static var defaultTheme: String = "Light Mode"
}

With AppConfig.defaultTheme, you’re using a static variable. The main benefit here is that this variable is tied to the type context of AppConfig, rather than being available globally, which can help with organization and thread-safety concerns. You can access it like this:

Copy
1
print(AppConfig.defaultTheme)

Using static variables can be particularly useful for defining constants or settings that should remain consistent across your entire app.

The Singleton Pattern in Swift

In some cases, you might want to control global state in a more structured way. This is where the singleton pattern comes into play. A singleton is a class that ensures a single shared instance is created, which can be accessed globally within the app.

Here’s how to implement a singleton in Swift:

Copy
1
2
3
4
5
6
7
class UserManager {
    static let shared = UserManager()

    private init() {}

    var username: String = "Guest"
}

In this example, the UserManager class provides a shared instance that can be accessed globally via UserManager.shared. The private initializer ensures that only one instance of the class is ever created. You can use this pattern to manage user preferences or other data that needs to be globally available but controlled within a class.

Accessing Global Variables and Thread Safety

When using global variables, one thing you must be cautious of is thread safety. If multiple threads can access and modify the same variable, it can lead to unpredictable behavior. One way to make your global variables thread-safe is by using synchronization mechanisms such as locks, or better yet, limit your use of global variables in most cases.

Here’s a simplified version of how to handle thread-safe access in Swift:

Copy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class SafeCounter {
    private var value: Int = 0
    private let queue = DispatchQueue(label: "com.example.counterQueue")

    func increment() {
        queue.sync {
            value += 1
        }
    }

    func getValue() -> Int {
        return queue.sync { value }
    }
}

This class ensures that the value is updated in a thread-safe way by using a serial dispatch queue. Instead of making value a global variable, it is kept private, and safe access is provided through methods that handle concurrency.

Best Practices for Using Global Variables in Swift

Even though global variables can be helpful in some cases, their use should be minimized. Here are some best practices to follow:

1. Use the Singleton Pattern: For managing shared data or services, a singleton can offer better control and encapsulation than a raw global variable.

2. Use Static Variables: If you only need a variable accessible from within a specific class or struct, prefer using static var to keep it scoped properly.

3. Avoid Overusing Global Variables: Too many global variables can make your code difficult to manage, leading to unexpected behavior and bugs.

4. Thread Safety: Ensure that your global variables are thread-safe by using synchronization techniques or keeping global state minimal.

The Bottom Line!

Swift global variables can be useful for storing shared data that needs to be accessible across the entire app. However, it's essential to use them wisely to avoid complications such as thread safety issues or tangled code. When appropriate, consider alternatives like static var, the singleton pattern, or encapsulating shared data within a class.

With this knowledge, you should feel more confident about when and how to use Swift global variables in your projects. Remember, while global variables provide convenience, you must carefully evaluate whether they're the right tool for your specific situation.

By following these best practices, you can keep your app's architecture clean and maintainable.