My Swift Programming Journey

Variables in Swift are used to store information that can be used and changed throughout your code. You define a variable using the var keyword followed by a name and a type. For example:

var greeting: String = "Hello, World!"

In this example, greeting is a variable of type String, and it's initially set to "Hello, World!". You can change its value later in the code.

Constants are similar to variables but their values cannot be changed once they are set. Use the let keyword to define a constant. For example:

let pi = 3.14159

Here, pi is a constant representing the value of π. Once defined, the value of pi cannot be changed, ensuring that it remains constant throughout your code.

This code snippet demonstrates basic arithmetic operations in Swift:

let a = 10
let b = 5
let sum = a + b
let difference = a - b
let product = a * b
let quotient = a / b

This code initializes two integer constants a and b, then calculates their sum, difference, product, and quotient.

This snippet shows how to concatenate strings in Swift:

let firstName = "John"
let lastName = "Doe"
let fullName = firstName + " " + lastName

Here, two string constants, firstName and lastName, are concatenated to form fullName.

This example illustrates a simple conditional statement using an if-else structure:

let score = 85

if score >= 90 {
    print("A")
} else if score >= 80 {
    print("B")
} else {
    print("C or lower")
}

The code checks the value of score and prints the corresponding grade based on the conditions.

This snippet demonstrates a basic loop using the for-in structure:

let numbers = [1, 2, 3, 4, 5]

for number in numbers {
    print(number)
}

This code loops through each element in the numbers array and prints it.

Optional binding is a safe way to unwrap an optional value. Here's an example:

var optionalName: String? = "John Doe"

if let name = optionalName {
    print("Hello, \(name)")
} else {
    print("No name provided")
}

If optionalName contains a value, it is assigned to name and the code inside the if block runs. Otherwise, the else block is executed.

Functions are reusable blocks of code that perform specific tasks. Here's a simple function that adds two numbers:

func add(a: Int, b: Int) -> Int {
    return a + b
}

let sum = add(a: 5, b: 3)
print(sum) // Output: 8

This function takes two integers as parameters and returns their sum.

Classes and structures are used to define custom data types. Here's an example of a simple structure:

struct Person {
    var firstName: String
    var lastName: String
}

let person = Person(firstName: "John", lastName: "Doe")
print(person.firstName) // Output: John

Structures in Swift can have properties and methods, just like classes. The main difference is that structures are value types, while classes are reference types.

Enumerations define a common type for a group of related values and enable you to work with those values in a type-safe way. Here's an example:

enum CompassPoint {
    case north
    case south
    case east
    case west
}

var direction = CompassPoint.north
direction = .east // Changing the value of direction

Enumerations can also have associated values and methods.

Protocols define a blueprint of methods, properties, and other requirements for a particular task or functionality. Here's an example:

protocol Greetable {
    var name: String { get }
    func greet()
}

struct Person: Greetable {
    var name: String
    func greet() {
        print("Hello, \(name)")
    }
}

let person = Person(name: "John")
person.greet() // Output: Hello, John

In this example, the Greetable protocol requires a name property and a greet method. The Person structure conforms to this protocol by implementing the required elements.