Swift Overview

Keywords are reserved words with predefined meanings in Swift. They cannot be used as variable names or identifiers.

Examples of Keywords:

class, func, let, public, struct, return, for, while, if, else, true, false

Every programming language has a set of reserved words used for internal processes or predefined actions. These reserved words, known as keywords, cannot be used as variable names, constant names, or other identifiers. To use a keyword as an identifier, enclose it in backticks (). For instance, while structis a keyword, “struct“ is a valid identifier. Note that backticks do not change the case sensitivity of identifiers (e.g.,aanda` are treated the same).

In Swift, keywords are categorized into the following groups:

1. Keywords in declaration
2. Keywords in statements
3. Keywords in expressions and types
4. Keywords in specific contexts
5. Keywords starting with the number sign (#)
6. Keywords used in patterns (_)

1. Keywords Used in Declarations: Keywords used in declarations include:

associatedtype, class, deinit, enum, extension, fileprivate, func, import,
init, inout, internal, let, open, operator, private, precedencegroup,
protocol, public, rethrows, static, struct, subscript, typealias, var

Example:

import Swift

// Creating a structure using the `struct` keyword
struct Employee {
    var name = "John"
    var id = 1234
}

// Creating an instance of the structure
var instance = Employee()

// Accessing properties of the structure
print("Employee Name:", instance.name)
print("Employee ID:", instance.id)

Output:

Employee Name: John
Employee ID: 1234

2. Keywords Used in Statements: Keywords used in statements include:

break, case, catch, continue, default, defer, do, else, fallthrough, for,
guard, if, in, repeat, return, throw, switch, where, while

Example:

import Swift

// Finding the age group
let age = 70

if age >= 60 {
    print("Senior Citizen")
} else if age >= 40 {
    print("Middle-aged")
} else {
    print("Young")
}

Output:

Senior Citizen

3. Keywords Used in Expressions and Types: Keywords in expressions and types include:

Any, as, catch, false, is, nil, rethrows, self, Self, super, throw, throws,
true, try

Example:

import Swift

// Creating a class
class Person {
    func name() {
        print("Hello! My name is Alice")
    }
}

// Creating a subclass
class Employee: Person {
    override func name() {
        // Accessing the parent class method using `super`
        super.name()
        print("I work in the IT department")
    }
}

// Creating an instance of the subclass
let employee = Employee()
employee.name()

Output:

Hello! My name is Alice
I work in the IT department

4. Keywords Used in Specific Contexts: Keywords used in specific contexts include:

associativity, convenience, didSet, dynamic, final, get, indirect, infix,
lazy, left, mutating, none, nonmutating, optional, override, postfix,
precedence, prefix, Protocol, required, right, set, some, Type, unowned,
weak, willSet

Example:

import Swift

// Creating a structure
struct Data {
    var value: String

    // Using the `mutating` keyword
    mutating func updateValue() {
        self.value = "Updated Value"
    }
}

var data = Data(value: "Initial Value")
data.updateValue()
print(data.value)

Output:

Updated Value

5. Keywords Starting with the Number Sign (#): Keywords starting with # include:

#available, #colorLiteral, #column, #dsohandle, #elseif, #else, #endif,
#error, #fileID, #fileLiteral, #filePath, #file, #function, #if,
#imageLiteral, #keyPath, #line, #selector, #sourceLocation, #warning

Example:

import Swift

// Using `#function` to display the function name
func displayFunctionName() {
    print("You are in the function: \(#function)")
}

displayFunctionName()

Output:

You are in the function: displayFunctionName

6. Keywords Used in Patterns (_): The underscore (_) is used as a wildcard in patterns.

Example:

import Swift

// Printing a message 10 times
for _ in 1...10 {
    print("Swift Programming")
}

Output:

Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming
Swift Programming

Literals represent fixed values in a program, such as integers, decimals, strings, or booleans. These values can be directly used without computation. By default, literals in Swift don’t have a type. Primitive type variables can be assigned literals. For instance:

• 12 is an integer literal.
• 3.123 is a floating-point literal.
• “Swift” is a string literal.
• true is a boolean literal.

Swift Protocols for Literals

Literals must conform to specific protocols depending on their type:

• ExpressibleByIntegerLiteral: For integer literals.
• ExpressibleByFloatLiteral: For floating-point literals.
• ExpressibleByStringLiteral: For string literals.
• ExpressibleByBooleanLiteral: For boolean literals.

Example:

let number: Int32 = 25

Types of Literals in Swift

1. Integer Literals: Used to represent whole numbers. If no alternate base is specified, they default to base-10 (decimal). Negative integers are represented using a minus sign (-).

Examples:

let positiveNumber = 25
let negativeNumber = -25
let numberWithUnderscore = 2_500 // Same as 2500

Alternate Representations:

• Binary: Prefix with 0b
• Octal: Prefix with 0o
• Hexadecimal: Prefix with 0x

Example

let decimalNumber = 10
let binaryNumber = 0b1010
let octalNumber = 0o12
let hexadecimalNumber = 0xA

print("Decimal Number:", decimalNumber)
print("Binary Number:", binaryNumber)
print("Octal Number:", octalNumber)
print("Hexadecimal Number:", hexadecimalNumber)

Comments make code more understandable. They are ignored by the compiler.

Single-line comment syntax:

Decimal Number: 10
Binary Number: 10
Octal Number: 10
Hexadecimal Number: 10

2. Floating-Point Literals: Represent numbers with a decimal point. The default type is Double. You can explicitly specify the type as Float.

Examples:

let number: Int32 = 25

Exponential Representation:

let scientificNumber1 = 1.25e3 // 1250
let scientificNumber2 = 1.25e-3 // 0.00125

Hexadecimal Floating-Point:

• Prefix: 0x
• Exponent: p

let hexFloat1 = 0xFp1 // 30.0
let hexFloat2 = 0xFp-1 // 7.5

Example:

let decimalFloatingNumber = 0.123
let scientificNotation = 1.23e2
let hexFloat = 0xFp1

print("Decimal Floating-Point:", decimalFloatingNumber)
print("Scientific Notation:", scientificNotation)
print("Hexadecimal Floating-Point:", hexFloat)

Output:

\Decimal Floating-Point: 0.123
Scientific Notation: 123.0
Hexadecimal Floating-Point: 30.0

3. String Literals: Represent a sequence of characters enclosed in double quotes. Strings can be multi-line, escape special characters, or use interpolation.

• Single-Line String:

let message = "Hello, World!"

• Multi-Line String:

vlet multilineString = """
This is a
multi-line string.
"""

• Escape Sequences:

let escapedString = "Hello,\nWorld!"

• String Interpolation:

let name = "Swift"
let greeting = "Welcome to \(name) programming!"

Example:

let singleLine = "Learning Swift"
let multiLine = """
Multi-line
String Example
"""
let interpolated = "The value is \(42)"

print(singleLine)
print(multiLine)
print(interpolated)

Output:

Learning Swift
Multi-line
String Example
The value is 42

4. Boolean Literals: Boolean literals can be true or false. The default type is Bool.

Examples:

let value1 = true
let value2 = false

print("Value 1:", value1)
print("Value 2:", value2)

Output:

Value 1: true
Value 2: false

Constants and variables in Swift are used to store data with specific types, such as numbers, characters, or strings. A constant cannot be changed after it has been assigned a value, whereas a variable can be modified during the program execution.

Declaring Constants & Variables in Swift

Constants and variables must be declared within their scope before being used. The let keyword is used for constants, and the var keyword is used for variables. Swift does not require semicolons (;) to terminate statements.

let temperature = 20 // Declaring a constant
var count = 0        // Declaring a variable

You can declare multiple constants or variables in a single line, separated by commas:

let x = 10, y = 20, z = 30 // Multiple constants
var p = 1, q = 2, r = 3    // Multiple variables

Type Annotation

Type annotation explicitly specifies the type of a constant or variable at the time of declaration. For example:

var name: String // Declares a string variable without initialization
var age: Int     // Declares an integer variable

If multiple constants or variables are of the same type, you can declare them in one line:

var firstName, lastName, city: String

Naming Constants & Variables

Names can contain any character except mathematical symbols, private Unicode scalar values, arrows, or whitespace characters:

let pi = 3.14159
print("Value of pi: \(pi)")

Printing Constants & Variables

print() Function

The print(_:separator:terminator:) function is used to display the value of constants or variables.

Example:

let country = "India"
print(country)

Output:

India

String Interpolation: String interpolation allows embedding constants or variables directly within a string, replacing placeholders with actual values.

Example:

var city = "Delhi"
print("I live in \(city)")

Output:

I live in Delhi