While developing programs in any programming language, the utilization of variables is necessary for storing data. Variables are nothing but reserved memory locations to store data. This means that when we create a variable, we reserve some amount of space in memory.

Subsequently, when desiring to store data in the variable we can enter data of any type such as string, character, wide character, integer, floating point, Boolean, etc. Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory.

Built-in Data Types in Swift

Swift offers the programmer a rich assortment of built-in data types, also known as primitive data types. They represent the basic values and are directly supported by the Swift language. Swift provides seven types of built-in data types and they are −

Bound Values

The following table shows the data type, how much memory it takes to store the value in memory, and what is the maximum and minimum values that can be stored in such types of variables.

User-Defined Data Types in Swift

User-defined data types allow us to create customized data types according to their requirements. They provide more flexibility and abstraction. Following are some user-defined data types supported by Swift −

Defining Data Types

Defining a data type is a process in which we specify what type of data will be stored in the variable. As we know, Swift supports two types of data – built-in and user-defined data types. So we will see how to define built-in data types −

Syntax

Following is the syntax of the built-in data type −

var name : dataType = Value

Example

Defining built-in data types −

var index : Int = 10
var str   : String = "Learn Swift!"
var char  : Character = "S"
var num   : Float = 23.45
var nums  : Double = 32.233434
var value : Bool = true

Now we will see how to define user-defined data types −

Syntax

Following is the syntax of the user-defined data type −

struct Student {
   var name: String
   var age: Int
}

var myData = Student(name: "Mona", age: 23)

Example

Defining built-in user-defined data types −

// Structure	
struct Employee {
   var name: String
   var age: Int
}

// Structure data type
var myData = Employee(name: "Seema", age: 23)

// Class
class Student {
   var name: String
   var age: Int
    
   init(name: String, age: Int) {
      self.name = name
      self.age = age
   }
}

// Class data type
var myInfo = Student(name: "Alice", age: 25)

// Enumeration
enum Rectangle {
   case length, width, breadth
}

// Enum data type
var side: Rectangle = .length

Type Safety in Swift

Swift is a type-safe language. It means that if a variable of your program expects a String, you can”t pass int in it by mistake because Swift performs type-checks while compiling your code and displays an error message if it finds any type mismatch.

However, this does not imply that you have to specify the type of every variable or constant. Swift applies type inference which automatically determines the type of the variable or constant if it is not specified explicitly.

Example

Swift program to demonstrate type Safety.

var varA = 42

// Here compiler will show an error message because varA 
// variable can only store integer type value
varA = "This is hello"

print(varA)

Output

main.swift:5:8: error: cannot assign value of type ''String'' to type ''Int''
varA = "This is hello"

Type Inference in Swift

Type inference is a special feature of Swift language; it allows the compiler to automatically deduce the type of the given expression at the time of compilation. It means you do not need to explicitly define the type of the variable at the time of declaration and still Swift will provide string type safety.

It is useful when you declare a constant or variable with its initial value.

Example

Swift program to demonstrate type inference.

import Foundation

// varA is inferred to be of type Int
var varA = 42
print("Type of varA variable is:", type(of:varA))

// varB is inferred to be of type Double
var varB = 3.14159
print("Type of varB variable is:", type(of:varB))

// varC is also inferred to be of type String
var varC = "TutorialsPoint"
print("Type of varC variable is:", type(of:varC))

Output

Type of varA variable is: Int
Type of varB variable is: Double
Type of varC variable is: String