In this article, we will see how to declare variables and constants in Swift.
1. Declaring Variables and Constants in Swift
Swift makes it quite easy for us to declare variables and constants. Variables are declared with the
var keyword, while constants are declared with the
let keyword. A variable can change its value to another value of the same type, while a constant can never change once it’s declared.
To declare a variable with a name
myVariable we would write the following:
var myVariable: String = "This is a variable"
Similarly, for a constant named
let myConstant: String = "This is a constant"
In our case, our
myVariable has a
String value of
"This is a variable" while our
myConstant constant has a
String value of
"This is a constant".
As we said, a variable can change its value but a constant cannot. So, in this example, we could do the following to our variable:
myVariable = "I have a new value"
But, that’s impossible to do in a constant, since it cannot change its value, so the following will throw a compilation error:
myConstant = "I can't change my value"
It’s also possible to declare multiple variables and constants in Swift on the same line, by simply separating them with commas:
var variable1: Int = 1, variable2: String = "another variable", variable3: Bool = false let constant1: Int = 5, constant2: Bool = true
As you can see, there is no restriction on the number or types of variables and constants that appear on a single line. However, you cannot have both variables and constants on the same line; you have to pick a side and go on with that.
Lastly, we can declare a variable or constant, based on another variable or constant; not only with literal values (known as “literals”) like
"Hello world" or
true. The syntax is the same for both variables and constants and we are able to do all of the four possible combinations, as demonstrated below:
var numberFive: Int = 5 let numberTen: Int = 10 var numberFiveVariable: Int = numberFive // 5 - declaring a variable from another variable var numberTenVariable: Int = numberTen // 10 - declaring a variable from a constant let numberFiveConstant: Int = numberFive // 5 - declaring a constant from a variable let numberTenConstant: Int = numberTen // 10 - declaring a constant from another constant
However, there is a restriction here: we cannot declare a variable or constant with one type and assign it from a variable or constant of a different type. In other words, we cannot do the following:
let myDouble: Double = 4.5 let myNumber: Int = myDouble
myDouble is a
myNumber is an
Int. Therefore, this assignment would cause a compilation error.
2. Type Annotations of Variables and Constants in Swift
As you may have noticed, all variables and constants we have declared so far, have explicitly declared their types as well by writing their type (we will talk about all types further below) after a colon (
:). This kind of syntax is useful when we want to make sure that a variable or constant is of the type we want them to be. However, it’s not really necessary to explicitly declare the types of variables and constants, as they are implicitly declared by Swift.
var anIntVariable: Int = 55 var anotherIntVariable = 12
As you can see, despite not declaring the type of the second variable (
anotherIntVariable), Swift will implicitly declare its type as
Int because we assigned it with an integer number. So, if we assigned a
Bool value to a variable, that variable would become a
Bool variable as well. All these apply to constants as well.
As you might expect, this works in a similar way if we declared a variable or constant from another variable or constant:
let message = "Hello world" let copiedMessage = message // copiedMessage is a String variable now
Due to the fact that
message is a
String, assigning it to another variable or constant, in our case
copiedMessage, will also make that variable or constant a
String. If we wanted to make sure that our
copiedMessage must have a specific type, we should explicitly declare it with a colon (
:), followed by its type.
3. Types of Variables and Constants in Swift
We have already mentioned some types of variables and constants in Swift. The basic type of variables and constants are:
- For integers,
Double, for decimals
- For letter based variables and constants,
3.1 Int and UInt
Those types of variables and constants represent integers. The difference between them is that the
Int type has both negative and positive integers, while the
UInt type only has positive (or unsigned) numbers. Both of those types can be found in various sizes, depending on the number of bits they use to represent their values (8, 16, 32, or 64 bits). Respectively the names of those types are
UInt64. The size of
UInt depends on the machine, so it’s either 32 or 64 bits.
//Int let smallestInt = Int.min // -9223372036854775808 let largestInt = Int.max // 9223372036854775807 // UIInt let smallestUInt = UInt.min // 0 let largestUInt = UInt.max // 18446744073709551615
Whenever declaring a variable or constant with an integer literal, without declaring its type explicitly, it automatically becomes an
let anInteger: Int = 5 // this is an Int let anotherInteger = 5 // this is also an Int let aUInteger: UInt = 5 // this is a UInt
3.2 Float and Double
Those types represent decimal numbers, known as floating-point numbers. Their difference is in their precision/size: a
Float has a precision/size of 32 bits while a
Double has a precision/size of 64 bits.
let aFloatNumber: Float = -5.2 // this a Float let aDoubleNumber: Double = 15.986 // this a Double let anotherDouble = 54.0 // this is also a Double
As with the integers, a decimal number is by default a
Double. If we want to create a
Float variable or consonant, we have to explicitly declare it as such.
3.3 Character and String
Character represents a simple character while a
String represents an array of characters, forming words. A
String value must be enclosed in quotation marks (
""). Once again, a single character value in quotation marks is considered a
String, if we do not define the type of variable or constant. You can read more about String and Character in Swift in our article here.
let letterD: Character = "D" // this is a Character let aWord: String = "Let's learn Swift" // this is a String let letterString = "C" // this is also a String
Bool type represents a Boolean value, which is a value of either
false. No other values are acceptable in this type.
let aTrueBool = true let aFalseBool = false
4. Naming Variables and Constants
In Swift, the names of variables and constants have to obey the following rules:
- They have to start with a letter or an underscore (
- Starting with a number isn’t allowed, however, they can contain a number inside them.
- They cannot contain whitespaces ( ) or special symbols including arrows or mathematical symbols.
- They cannot be the same as the reserved keywords, like
trueetc. The only way to use those names is by surrounding them in backticks (
let _underscoreConstant = "_" // names can begin with an underscore let year2022 = 2022 // numbers that are not in the beginning of the name (the first character of the can't be a number) let 😏 = "smirk" // names of variables can be emojis let ελληνικά = "greek" // different alphabets var `for` = "for" // even reserved keywords, surrounded in backticks (`) `for` = "for loop" // always used with backticks
A few conventions that should be followed when naming variables and constants are:
- Try to avoid using reserved keywords as variable and constant names.
- Give descriptive names to variables, instead of names such as
num. A good descriptive name makes the code much easier to read and clearly defines the purprose of the variable/constant.
- Finally, if the name of your variable or constant is more than one word, use the camel case to name them. For instance, if your variable or constant defines the favourite food of a person, it should be named
5. Printing Variables and Names
One of the most common commands of any programming language is the command to print a value to the console. In Swift, this can be done with the
print() function (there are multiple different
Whenever we want to print a variable or constant on its own, we can simply use the
print() function with the variable or constant as its parameter. On the other hand, if we have to include our variable or constant within another
String, we have to use a backslash (
\) and then enclose the variable or constant in parentheses.
let myMessage = "Swift is fun!" print(myMessage) // printing only our constant print("My message to the world is: \(myMessage)") // printing our constant as part of another String
For the second
print() function, Swift uses string interpolation in order to replace the variable or constant with its value when needed.
By now, you should be able to declare and use variables and constants in Swift without any issue. You can find the source code (Playground) on our GitHub page.