Swift Programming: Variables, Control Flow, Functions, and Object-Oriented Concepts
Tags: swift, ios, development, mobile
Published: 2024-01-08 08:46:36

Introduction to Swift Programming: From Basics

Before starting, **Open Xcode, Click on File => New => Playground => iOS => Blank**, and create a new playground to run Swift Code.

## Swift Fundamentals

### Variables and Constants

Swift uses `var` to declare variables and `let` to declare constants.
```swift
    var variableName: DataType = initialValue
    let constantName: DataType = initialValue
```
Example:
```swift
    var greeting: String = "Hello"
    let pi: Double = 3.14159
```
Constants (`let`) cannot change their value after they are set, while variables (`var`)may.

### Data Types

Some common data types in Swift include:

* `String` for text

* `Int` for whole numbers

* `Bool` for Boolean values

* `Double` and `Float` for floating-point numbers

Swift is a type-safe language, meaning it encourages you to be clear about the types of values your code can work with.

### Control Flow

Swift provides several ways to control the flow of code execution, including if statements, switch cases, and loops.

**If Statement:**
```swift
    if someCondition {
        // Code to execute if someCondition is true
    } else if anotherCondition {
        // Code to execute if anotherCondition is true
    } else {
        // Code to execute if the above conditions are false
    }
```
**Switch-cases**
```swift
    switch <#some value to consider#> {
    case <#value 1#>:
        <#respond to value 1#>
    case <#value 2#>,
        <#value 3#>:
        <#respond to value 2 or 3#>
    default:
        <#otherwise, do something else#>
    }
```
**For-In Loop:**
```swift
    for item in items {
        // Code to execute for each item in 'items'
    }
```
**While Loop:**
```swift
    while someCondition {
        // Code to execute while someCondition remains true
    }
```
### Functions

Functions are self-contained chunks of code designed to carry out particular tasks.

Syntax:
```swift
    func functionName(parameterName: ParameterType) -> ReturnType {
        // Code
        return someValue
    }
```
Example:
```swift
    func greet(person: String) -> String {
        let greeting = "Hello, \(person)!"
        return greeting
    }
```
Here you have a function named greet that takes one parameter of type String and also returns a String.

## Exercise: Try a simple function

Let’s write a function that takes a person’s name as a parameter and prints a customised greeting.
```swift
    func greet(person: String) {
        let greeting = "Starting iOS Development with, \(person)!"
        print(greeting)
    }
    
    greet(person: "Rohan") 
    // Outputs: Starting iOS Development with, Rohan!
```
This function takes a String parameter and uses string interpolation to include it in a greeting, which is then printed to the console.

### Classes and Structures

Swift uses classes and structures to define custom data types.

Structure Example:
```swift
    struct Person {
        var name: String
        var age: Int
    }
    
    var person1 = Person(name: "John", age: 25)
```
Class Example:
```swift
    class Vehicle {
        var numberOfWheels: Int
        
    init(numberOfWheels: Int) {
            self.numberOfWheels = numberOfWheels
        }
    
    func information() {
            print("I have \(numberOfWheels) wheels")
        }
    }
    
    let myVehicle = Vehicle(numberOfWheels: 4)
    myVehicle.information() // Outputs: I have 4 wheels
```
Classes are reference types, meaning that when you assign a class instance to a variable or constant, you are actually pointing to the same existing instance, whereas structures are value types, meaning that they replicate the instance. This is the primary distinction between classes and structures.

You now have a basic understanding of basic programming concepts and Swift syntax. Now write your function, experiment with conditionals and loops, and perhaps try defining a class or a structure. The logic in your programmes will be built using these technologies as the building blocks.

**Practice. Experiment. Learn**