Learn Swift - Basic Syntax & Swift Code Structure

#Introduction

In episode 2 you understood Swift's architecture. Now it's time to write real code. Episode 3 covers Swift basic syntax and code structure — the building blocks you'll use in every line of code you write as a Swift developer.

Swift's syntax is designed to be concise yet expressive. You'll see that much of the boilerplate required in other languages can be eliminated without sacrificing clarity. Master this episode well, because every advanced episode stands on top of it.

#Variables and Constants

#var and let

Swift makes a strict distinction between values that can change and those that can't. Declare with var if the value can change, and let if it must not be reassigned after being set once:

var skor = 10
skor += 5
 
let namaAplikasi = "Swift Notes"
print(namaAplikasi)
print(skor)

let namaAplikasi = "Swift Notes" creates a constant — trying to reassign it will fail at compile time. Get in the habit of using let by default and var only when the value truly needs to change.

#Type Inference and Basic Types

You don't always have to write types explicitly — the compiler infers them from the initial value:

let jumlahKursi: Int = 12
let tinggi: Double = 1.75
let kategori: String = "premium"
let aktif: Bool = true

Swift's basic types include Int, Double, Float, String, and Bool. Important note: Double and Float can't be mixed implicitly — conversion must be explicit with Double(nilai) or Float(nilai).

#Control Structures

#if and switch

if branching is written with optional parentheses and must have a block:

let nilai = 85
 
if nilai >= 90 {
    print("Luar biasa")
} else if nilai >= 75 {
    print("Bagus")
} else {
    print("Perlu latihan lagi")
}

For matching many possibilities, switch in Swift is far more powerful than in C: every case doesn't need a break, and all possibilities must be covered or provided with a default:

let kategoriUmur = "remaja"
 
switch kategoriUmur {
case "anak":
    print("Di bawah 12 tahun")
case "remaja":
    print("13 sampai 19 tahun")
case "dewasa":
    print("20 tahun ke atas")
default:
    print("Kategori tidak dikenal")
}

switch kategoriUmur evaluates the value once and selects the matching case. Swift also supports ranges such as case 0..<13 for numeric patterns.

#for-in, while, and repeat-while

The for-in loop iterates over collections or ranges:

for angka in 1...5 {
    print("Iterasi ke-\(angka)")
}

The range 1...5 includes 1 through 5 inclusively. Use 1..<5 if you want the upper bound exclusive. For condition-based loops, while checks the condition at the start, and repeat-while checks it at the end so the body always executes at least once:

var counter = 3
while counter > 0 {
    print("Mundur \(counter)")
    counter -= 1
}
 
repeat {
    print("Selalu jalan sekali")
} while false

#Functions

#Declaration and Parameters

Functions are declared with the func keyword, with explicit parameter types and return types:

func hitungDiskon(harga: Double, persen: Double) -> Double {
    let potongan = harga * (persen / 100)
    return harga - potongan
}
 
let total = hitungDiskon(harga: 500_000, persen: 15)
print(total)

hitungDiskon(harga:persen:) uses argument labels that must be written when calling. This makes the code read like natural language. Default values allow parameters to be omitted when calling.

#Closures

#Functions as Values

A closure is a self-contained block of code that can be stored and passed around — a first-class citizen. Its syntax resembles an unnamed function:

let daftar = [3, 1, 4, 1, 5, 9, 2]
 
let naik = daftar.sorted { (a: Int, b: Int) -> Bool in
    return a < b
}
 
print(naik)

The concise version uses the implicit parameters $0 and $1:

let turun = daftar.sorted { $0 > $1 }
print(turun)

daftar.sorted { $0 > $1 } sorts in descending order without writing any types at all — a pattern extremely common across Swift codebases, especially together with map, filter, and reduce, which you'll use in episode 5.

#Closing

Key takeaways:

• Use let by default and var only when the value must change.
• Swift's basic types include Int, Double, Float, String, and Bool, with type inference.
• if and switch handle branching; Swift's switch is free of break.
• for-in iterates ranges and collections; while and repeat-while repeat based on a condition.
• Functions are declared with func and support labels and default values.
• A closure is an unnamed function that can be stored and passed around.

In the next episode, episode 4, we'll cover advanced data types and collections — Array, Dictionary, Set, and tuples, optionals with optional chaining and nil coalescing, enums with associated values and raw values, and the difference between struct and class in terms of value and reference semantics. Get your keyboard ready!