Variables in Swift

·Oct 17, 2023·

6 min read

Using Var
Using let
Naming Rules
Type Inference
- Benefits
- When to Use Explicit Type Declaration
Summary
- More Swift Tutorials
- Follow me for more such content

In programming, a variable is like a labeled box in which you can put different kinds of information, such as numbers or words. You give the box a name, and you can change what's inside it as your program runs. Think of it as a way to store and use data in your computer program.

In Swift there are two ways to declare variables:

Using var - For Mutable Data
Using let - For Immutable (Constant) Data

Using Var

In Swift, you can declare variables using the var keyword. Variables are used to store and manage data that can change during the execution of your program. Here's how you declare and use variables in Swift:

Declaration:
```
 var variableName: DataType = initialValue
```
- variableName is the name of the variable.
- DataType is the data type of the variable, such as Int, String, Double, or a custom type.
- initialValue is an optional initial value you can assign to the variable when you declare it. If you don't provide an initial value, Swift will infer the data type based on the context.

Examples:

 var age: Int = 30
 var name: String = "John"
 var price = 19.99 // Swift infers the type as Double
 var isStudent: Bool = true

Changing the Value:

You can change the value of a variable after its initial declaration:
```
 age = 31
 name = "Jane"
 price = 29.99
 isStudent = false
```
Type Inference:

In many cases, you don't need to explicitly specify the data type because Swift can infer it from the initial value:
```
 var count = 10 // Swift infers the type as Int
 var greeting = "Hello" // Swift infers the type as String
```

Using let

If you want to declare a value that cannot be changed after its initial assignment, you can use the let keyword to declare constants. once a value is assigned to a constant using the let keyword, it cannot be changed. Constants are used when you have data that should not and cannot, be altered during the execution of your program.

Here's how you declare and use constants in Swift:

Declaration:
```
 let constantName: DataType = initialValue
```
- constantName is the name of the constant.
- DataType is the data type of the constant, such as Int, String, Double, or a custom type.
- initialValue is the initial value that you assign to the constant when you declare it.

Examples:

 let pi: Double = 3.14159
 let appName: String = "MyApp"

Constants are useful for values that should not change throughout the program's execution.

Naming Rules

Variable names can contain letters, numbers, and underscores.
Variable names must start with a letter or an underscore.
Variable names are case-sensitive, so myVar and myvar is considered different variables.
Avoid using Swift's reserved keywords as variable names.

Here's a simple example of variable usage in Swift:

var currentTemperature: Double = 25.5
currentTemperature = 26.0 // Variable value can be changed

In Swift, variables are a fundamental part of managing and manipulating data in your programs, and they provide flexibility to adapt to changing values as your code runs.

Type Inference

Type inference is a feature in Swift that allows the compiler to automatically determine the data type of a variable or constant based on its initial value. This means you don't always have to explicitly specify the data type when declaring variables and constants; the compiler can figure it out for you. This feature makes Swift's code more concise and readable.

Here's how type inference works in Swift:

Explicit Type Declaration:

You can declare a variable or constant with an explicit data type:
```
 var age: Int = 30
 let name: String = "Alice"
```
In these examples, you've explicitly specified the data types (Int and String) for the variables.
Type Inference:

Swift can infer the data type from the initial value. If you don't specify the data type, Swift will automatically determine it:

var age = 30 // Swift infers the type as Int
let name = "Alice" // Swift infers the type as String

Benefits

Type inference can make your code shorter and more readable.
It also helps prevent type-related errors because the compiler ensures that the inferred type matches the value you've assigned.

When to Use Explicit Type Declaration

While type inference is handy, there are cases where explicit type declaration is beneficial, such as when:

You want to make the code more explicit and self-documenting, especially for complex or unclear cases.
You need to use a specific data type, even if Swift could infer a different type (e.g. when working with numeric types).
You're declaring a variable with no initial value (in such cases, the data type must be explicit because there's no initial value to infer from).

Type inference simplifies your code by allowing you to focus on the values and their behaviour rather than explicitly specifying data types in many cases.

Summary

Here's a simplified summary of the concepts discussed above:

Variables in Swift:

Think of a variable as a labelled box to store different kinds of data, like numbers or words.
You give the box a name, and you can change what's inside as your program runs.
In Swift, you can use var it to declare variables for data that can change.
Example: var age: Int = 30, where age can store an integer value.
You can change the value of a variable after declaring it.
Type inference lets Swift figure out the data type if you don't specify it.

Constants in Swift:

Constants are like variables, but once you put something in, it can't be changed.
Use let to declare constants for data that shouldn't change during the program.
Example: let pi: Double = 3.14159, where pi can't be modified.
Constants are useful for values that should stay the same.
Type inference also works for constants in Swift.

Type Inference:

Type inference is Swift's ability to figure out the data type based on the initial value.
You don't always need to tell Swift the data type; it can guess.
It helps make code shorter and prevents type-related errors.
You can still specify the data type explicitly when needed.

In summary, variables are like labelled boxes for data you can change, constants are for unchanging values, and type inference in Swift helps make your code more concise and less error-prone.

Blog