Materi · Swift Fundamentals
Materi Swift Fundamentals
Syntax dasar Swift asli, disusun 9 tahap berurutan — dari variabel sampai membaca (tracing) kode Swift dan menentukan outputnya. Semua contoh beda dari soal latihan.
1
Variable & Constant
var membuat variabel yang nilainya BISA diubah lagi setelah diisi. let membuat konstanta yang nilainya TIDAK BISA diubah lagi setelah diisi pertama kali — mencoba mengubahnya akan jadi error saat kompilasi.
var umur = 20
umur = 21 // boleh, var bisa diubah
let nama = "Rina"
nama = "Budi" // ERROR: tidak boleh, let tidak bisa diubah
Swift punya type inference — kamu tidak wajib menulis tipe datanya, Swift akan menebak sendiri dari nilai awal. Tapi kamu juga boleh menuliskannya eksplisit.
var skor = 100 // Swift tahu ini Int
var tinggi = 165.5 // Swift tahu ini Double
var aktif = true // Swift tahu ini Bool
var kota: String = "Jakarta" // tipe ditulis eksplisit
Empat tipe data dasar yang paling sering dipakai: Int (bilangan bulat), Double (bilangan desimal), String (teks), Bool (benar/salah — true/false).
Kebiasaan yang baik: pakai let sebagai default, dan cuma pakai var kalau kamu memang tahu nilainya akan berubah nanti.
2
Operator
Operator aritmatika: + - * / seperti biasa, plus % untuk sisa bagi (modulo).
let a = 17
let b = 5
print(a + b) // 22
print(a - b) // 12
print(a * b) // 85
print(a / b) // 3 (pembagian Int dibulatkan ke bawah, bukan 3.4)
print(a % b) // 2 (sisa dari 17 dibagi 5)
Kalau a dan b bertipe Int, hasil a / b juga Int — bagian desimalnya DIBUANG, bukan dibulatkan matematis. 17/5 hasilnya 3, bukan 3.4 atau 3.5.
Operator perbandingan (hasilnya selalu Bool): == (sama dengan), != (tidak sama dengan), >, <, >=, <=.
print(5 == 5) // true
print(5 != 3) // true
print(5 >= 5) // true
Operator logika: && (AND, keduanya harus true), || (OR, salah satu true saja cukup), ! (NOT, membalik nilai).
let umur = 20
let punyaKTP = true
print(umur >= 17 && punyaKTP) // true
print(!punyaKTP) // false
3
Conditional
if / else if / else — kondisi ditulis TANPA tanda kurung wajib, tapi kurung kurawal { } WAJIB ada meskipun isinya cuma satu baris.
let nilai = 75
if nilai >= 90 {
print("A")
} else if nilai >= 75 {
print("B")
} else {
print("C")
}
// output: B
Sama seperti pseudocode: dicek dari atas, begitu ketemu yang TRUE langsung jalan dan berhenti — kondisi di bawahnya tidak dicek lagi.
switch memilih satu blok berdasarkan kecocokan nilai. Beda dari beberapa bahasa lain: switch di Swift TIDAK butuh break — begitu satu case cocok, otomatis berhenti, tidak "tembus" ke case di bawahnya.
let hari = 3
switch hari {
case 1:
print("Senin")
case 2:
print("Selasa")
case 3:
print("Rabu")
default:
print("Hari lain")
}
// output: Rabu
Swift mewajibkan switch menangani SEMUA kemungkinan nilai — makanya hampir selalu butuh default di akhir untuk menangkap nilai yang tidak disebutkan case manapun.
4
Loop
for-in dipakai kalau jumlah putaran sudah pasti, biasanya lewat range. 1...5 (tiga titik) mencakup 1 SAMPAI 5 (5 ikut dihitung). 1..<5 (titik-lebih kecil) mencakup 1 sampai SEBELUM 5 (5 tidak ikut).
for i in 1...4 {
print(i)
}
// output: 1 2 3 4
for i in 1..<4 {
print(i)
}
// output: 1 2 3 (4 tidak ikut karena pakai ..<)
while mengecek kondisi DULU sebelum tiap putaran — kalau kondisinya FALSE sejak awal, badan loop tidak pernah jalan sama sekali.
var n = 10
while n > 0 {
n -= 2
}
print(n)
// output: 0
repeat-while mengecek kondisi SETELAH tiap putaran — artinya badan loop PASTI jalan minimal satu kali, walaupun kondisinya sudah FALSE sejak awal.
var x = 100
repeat {
x += 1
} while x < 0
print(x)
// output: 101 (badan loop tetap jalan sekali walau x<0 sudah FALSE sejak awal)
Beda paling penting while vs repeat-while: while BISA tidak jalan sama sekali (0 kali), repeat-while SELALU jalan minimal 1 kali.
5
Collection
Array — kumpulan nilai berurutan dengan tipe sama, diakses lewat index. Index Swift dimulai dari 0 (beda dengan pseudocode kita yang mulai dari 1).
var buah = ["Apel", "Jeruk", "Mangga"]
print(buah[0]) // "Apel" (elemen pertama, index 0)
buah.append("Pisang")
print(buah.count) // 4
Dictionary — kumpulan pasangan key-value, diakses lewat key (bukan nomor urut).
var umur = ["Rina": 25, "Budi": 30]
print(umur["Rina"]!) // 25
umur["Citra"] = 28
print(umur.count) // 3
Set — kumpulan nilai UNIK (tidak boleh ada duplikat) dan TIDAK berurutan (tidak punya index seperti array).
var warna: Set = ["Merah", "Biru", "Hijau"]
warna.insert("Merah") // tidak nambah apa-apa, "Merah" sudah ada
print(warna.count) // tetap 3
Array = berurutan, boleh duplikat, akses pakai index angka. Dictionary = tidak berurutan, akses pakai key. Set = tidak berurutan, tidak boleh duplikat, tidak punya index.
6
Function
Function dideklarasikan dengan func, parameter ditulis dengan nama dan tipe, dan tipe nilai balik (return value) ditulis setelah tanda panah ->.
func sapa(nama: String) -> String {
return "Halo, \(nama)!"
}
let hasil = sapa(nama: "Rina")
print(hasil)
// output: Halo, Rina!
Secara default, nama parameter dipakai juga sebagai label saat memanggil function (nama: di atas). Kalau function tidak mengembalikan apa-apa, tanda -> Tipe boleh dihilangkan.
func tambah(a: Int, b: Int) -> Int {
return a + b
}
print(tambah(a: 3, b: 5))
// output: 8
Function dengan beberapa parameter dipanggil dengan menyebut SEMUA label parameternya, sesuai urutan yang dideklarasikan.
7
Optional
Menambahkan ? di belakang tipe data membuatnya Optional — artinya variabel itu BOLEH berisi nilai ATAU nil (kosong/tidak ada nilai).
var namaTengah: String? = nil
namaTengah = "Putri"
Cara paling aman membuka nilai Optional adalah if let — kalau isinya bukan nil, nilainya "dibuka" ke variabel baru dan blok if dijalankan; kalau nil, blok if dilewati.
var umur: Int? = 25
if let umurPasti = umur {
print("Umur: \(umurPasti)")
} else {
print("Umur tidak diketahui")
}
// output: Umur: 25
Nil-coalescing (??) memberi nilai cadangan kalau Optional-nya ternyata nil, dalam satu baris singkat.
var kota: String? = nil
let kotaAman = kota ?? "Tidak diketahui"
print(kotaAman)
// output: Tidak diketahui
Ada juga force-unwrap pakai tanda seru (umur!) yang langsung membuka nilai tanpa pengecekan — kalau ternyata isinya nil, aplikasi akan CRASH. Karena berisiko, if let atau ?? jauh lebih aman dipakai sehari-hari.
8
OOP Dasar Swift
Konsepnya sama persis dengan yang sudah kamu kuasai di kategori OOP — di sini fokusnya cuma sintaks Swift-nya saja.
class Mobil {
var merk: String // property
init(merk: String) { // initializer
self.merk = merk
}
func klakson() { // method
print("\(merk) bunyi: Tin tin!")
}
}
let mobilA = Mobil(merk: "Toyota")
mobilA.klakson()
// output: Toyota bunyi: Tin tin!
class dan struct sama-sama bisa punya property, method, dan initializer — tapi beda mendasar: class adalah reference type (menyalin variabelnya berarti menyalin REFERENSI ke objek yang SAMA), sementara struct adalah value type (menyalin variabelnya membuat SALINAN independen).
class Akun { var saldo = 100 }
struct Poin { var nilai = 100 }
let akunA = Akun()
let akunB = akunA // akunB nunjuk ke OBJEK YANG SAMA dengan akunA
akunB.saldo = 500
print(akunA.saldo) // 500 (ikut berubah, karena class = reference)
var poinA = Poin()
var poinB = poinA // poinB adalah SALINAN independen
poinB.nilai = 500
print(poinA.nilai) // 100 (tidak ikut berubah, karena struct = value)
Inheritance (hanya untuk class, struct TIDAK bisa mewarisi) — subclass bisa memakai ulang atau menimpa (override) method dari superclass-nya.
class Kendaraan {
func jalan() {
print("Kendaraan bergerak")
}
}
class Motor: Kendaraan {
override func jalan() {
print("Motor melaju dengan 2 roda")
}
}
let m = Motor()
m.jalan()
// output: Motor melaju dengan 2 roda
9
Tracing Code
Ini tahap integrasi — kemampuan MEMBACA kode Swift baris demi baris dan menentukan PERSIS apa yang di-print-kan di akhir, menggabungkan semua yang sudah dipelajari (variabel, operator, kondisi, loop, collection, function, optional, class/struct).
Caranya sama seperti melacak pseudocode: jalankan baris satu-satu dari atas, catat nilai tiap variabel setiap kali berubah, jangan menebak dari sekilas baca.
var total = 0
let angka = [3, 7, 2, 9]
for n in angka {
if n % 2 == 0 {
total += n
}
}
print(total)
// Trace: angka genap di array cuma 2, jadi total = 0 + 2 = 2
// output: 2
func gandakan(_ x: Int) -> Int {
return x * 2
}
var hasil = 5
hasil = gandakan(hasil)
hasil = gandakan(hasil)
print(hasil)
// Trace: hasil 5 -> gandakan(5)=10 -> gandakan(10)=20
// output: 20
Soal aptitude/programming test paling sering muncul dalam bentuk seperti ini — potongan kode pendek, lalu kamu diminta menebak print-nya. Kuncinya tetap sama: sabar trace baris per baris, jangan buru-buru.
Ini rangkuman buatan sendiri untuk latihan, bukan dokumentasi resmi Swift/Apple — cocok buat pegangan cepat sebelum mengerjakan soal.