🐦 Swift untuk Pemula: Panduan Lengkap

# Cara 1: Swift Playgrounds di iPad / Mac
# - Download "Swift Playgrounds" dari App Store
# - Gratis, langsung bisa coding di perangkat
# - Sangat cocok untuk pemula

# Cara 2: Xcode Playground di Mac
# - Download Xcode dari Mac App Store (gratis)
# - Buka Xcode → File → New → Playground
# - Pilih Blank Playground
# - Ketik kode dan langsung lihat hasilnya

# Cara 3: Swift Online di Linux / Windows
# - Kunjungi https://swiftfiddle.com
# - Atau gunakan https://online.swiftplayground.run
# - Tidak perlu instalasi apapun

// File: HelloWorld.swift
print("Halo, dunia!")
print("Selamat datang di Swift!")
print("Nama saya: BeebaneLabs")

// Menjalankan dari terminal:
// swift HelloWorld.swift
//
// Output:
// Halo, dunia!
// Selamat datang di Swift!
// Nama saya: BeebaneLabs

# Unduh Swift dari https://swift.org/download/
# Contoh untuk Ubuntu 22.04:

wget https://download.swift.org/swift-5.10-release/ubuntu2204/swift-5.10-RELEASE/swift-5.10-RELEASE-ubuntu22.04.tar.gz
tar xzf swift-5.10-RELEASE-ubuntu22.04.tar.gz

# Tambahkan ke PATH
export PATH=$PATH:/path/to/swift/usr/bin

# Verifikasi
swift --version
# Output: swift version 5.10

# Jalankan program
swift HelloWorld.swift

// let = konstanta (tidak bisa diubah nilainya)
let nama = "Budi Santoso"
let umur = 25
let tinggi = 175.5
let is_active = true

// var = variabel (bisa diubah nilainya)
var kota = "Jakarta"
kota = "Surabaya"  // ✅ Bisa diubah

// var cobaUbah = "hello"
// cobaUbah = "world"  // ❌ Error: let sudah di-assign
// Di Swift, "let" harus di-assign saat deklarasi

// Type inference — Swift otomatis mendeteksi tipe
let age = 25            // Swift tahu ini Int
let name = "Andi"       // Swift tahu ini String
let height = 170.5      // Swift tahu ini Double

// Type annotation — deklarasi tipe secara eksplisit
let score: Int = 100
let price: Double = 99.99
let letter: Character = "A"
let greeting: String = "Halo"

// Multiple assignment
let (x, y, z) = (1, 2, 3)
print("\(x), \(y), \(z)")  // 1, 2, 3

// Nama variabel harus unik dalam scope yang sama
let count = 10
// let count = 20  // ❌ Error: 'count' already declared

// Swift TIDAK melakukan konversi otomatis antar tipe numerik
let score: Int = 100
// let result = score + 3.14  // ❌ Error: cannot add Int + Double

// Solusi: konversi secara eksplisit
let result = Double(score) + 3.14  // ✅ 103.14

// String → Int (menggunakan initializer yang bisa gagal)
let ageString = "25"
if let age = Int(ageString) {
    print("Umur: \(age)")  // ✅ Umur: 25
} else {
    print("Bukan angka valid")
}

// Int → String
let number = 42
let numberStr = String(number)  // "42"

// Double → Int (membulatkan ke bawah)
let pi = 3.14
let piInt = Int(pi)  // 3

// Cek tipe data
print(type(of: 42))         // Int
print(type(of: "hello"))    // String
print(type(of: 3.14))       // Double
print(type(of: true))       // Bool

// String interpolation — menyisipkan nilai ke dalam string
let nama = "Andi"
let umur = 25
print("Nama saya \(nama), umur \(umur) tahun")
// Output: Nama saya Andi, umur 25 tahun

// Ekspresi dalam interpolasi
print("2 + 3 = \(2 + 3)")
// Output: 2 + 3 = 5

// Multiline string
let paragraf = """
    Ini adalah paragraf
    yang terdiri dari
    beberapa baris.
    """
print(paragraf)

// Properti string
let teks = "Hello, Swift!"
print(teks.count)      // 13
print(teks.uppercased()) // HELLO, SWIFT!
print(teks.lowercased()) // hello, swift!
print(teks.isEmpty)    // false

// Cek apakah string mengandung teks tertentu
print(teks.contains("Swift")) // true
print(teks.hasPrefix("Hello")) // true
print(teks.hasSuffix("!"))     // true

// String bisa di-index
let char = teks[teks.startIndex]
print(char)  // H

// Operator + untuk menggabungkan string
let kata1 = "Halo"
let kata2 = " Dunia!"
let gabungan = kata1 + kata2  // "Halo Dunia!"
print(gabungan)

// String repetisi
let ulang = String(repeating: "Ha", count: 3)
print(ulang)  // HaHaHa

// If / Else sederhana
let umur = 20

if umur >= 18 {
    print("Anda sudah dewasa")
} else {
    print("Anda masih remaja")
}

// If / Else If
let skor = 85
if skor >= 90 {
    print("Grade: A")
} else if skor >= 80 {
    print("Grade: B")
} else if skor >= 70 {
    print("Grade: C")
} else {
    print("Grade: D")
}

// Guard — memastikan kondisi, keluar dari scope jika gagal
func sapa(nama: String?) {
    guard let nama = nama else {
        print("Nama tidak valid!")
        return
    }
    print("Halo, \(nama)!")
}
sapa(nama: "Budi")  // Halo, Budi!
sapa(nama: nil)     // Nama tidak valid!

// Ternary operator
let usia = 20
let status = usia >= 18 ? "Dewasa" : "Remaja"
print(status)  // Dewasa

// Switch — di Swift, semua case harus tertangani (exhaustive)
let hari = "Senin"

switch hari {
case "Senin":
    print("Hari Senin — awal minggu!")
case "Selasa":
    print("Hari Selasa")
case "Rabu":
    print("Hari Rabu — tengah minggu")
case "Kamis":
    print("Hari Kamis")
case "Jumat":
    print("Hari Jumat — menjelang weekend!")
case "Sabtu", "Minggu":
    print("Akhir pekan! 🎉")
default:
    print("Hari tidak valid")
}

// Switch dengan range
let nilai = 75

switch nilai {
case 90...100:
    print("Sangat Baik")
case 80...89:
    print("Baik")
case 70...79:
    print("Cukup")
case 0...69:
    print("Perlu Perbaikan")
default:
    print("Nilai tidak valid")
}

// Switch dengan pattern matching
let koordinat = (x: 10, y: 0)

switch koordinat {
case (0, 0):
    print("Di origin")
case (_, 0):
    print("Di sumbu X")
case (0, _):
    print("Di sumbu Y")
case (-2...2, -2...2):
    print("Dekat origin")
default:
    print("Di tempat lain")
}

// For-in loop — range
for i in 1...5 {
    print(i)  // 1, 2, 3, 4, 5
}

// Half-open range (tidak termasuk angka terakhir)
for i in 0..<5 {
    print(i)  // 0, 1, 2, 3, 4
}

// For-in dengan underscore (jika index tidak diperlukan)
for _ in 1...3 {
    print("Ulangan!")
}

// Iterasi array
let buah = ["Apel", "Mangga", "Jeruk"]
for item in buah {
    print(item)
}

// For-in dengan index
for (index, item) in buah.enumerated() {
    print("\(index + 1). \(item)")
}
// 1. Apel
// 2. Mangga
// 3. Jeruk

// Stride — melangkah dengan interval tertentu
for i in stride(from: 0, to: 20, by: 5) {
    print(i)  // 0, 5, 10, 15
}

// While loop
var counter = 5
while counter > 0 {
    print(counter)
    counter -= 1
}
// 5, 4, 3, 2, 1

// Repeat-while (seperti do-while)
var num = 1
repeat {
    print(num)
    num *= 2
} while num <= 100
// 1, 2, 4, 8, 16, 32, 64

// Break dan Continue
for i in 1...10 {
    if i == 3 { continue }  // Skip angka 3
    if i == 7 { break }     // Berhenti di angka 7
    print(i)
}
// 1, 2, 4, 5, 6

// Optional — tipe yang bisa bernilai nil
var nama: String? = "Andi"
var umur: Int? = nil  // nil = tidak ada nilai

// Unwrapping Optional

// 1. if let — cara paling aman
if let namaUnwrapped = nama {
    print("Nama: \(namaUnwrapped)")
} else {
    print("Nama kosong")
}

// 2. Guard let — untuk keluar dari fungsi jika nil
func prosesNama(_ nama: String?) {
    guard let nama = nama else {
        print("Error: nama tidak boleh kosong!")
        return
    }
    print("Memproses: \(nama)")
}

// 3. Optional binding dengan shorthand
if let nama = nama {
    print(nama)  // Tidak perlu nama baru
}

// 4. Nil coalescing (??) — default value jika nil
var input: String? = nil
let result = input ?? "Default Value"
print(result)  // Default Value

// 5. Force unwrapping (!) — BERHATI-HATI! Bisa crash
let namaForce = nama!  // Aman karena nama != nil
print(namaForce)

// 6. Optional chaining (?.)
struct Alamat {
    var kota: String?
}
var alamat: Alamat? = Alamat(kota: "Jakarta")
let kota = alamat?.kota  // Optional("Jakarta")
print(kota ?? "Tidak diketahui")  // Jakarta

// Optional vs non-optional
let namaBiasa: String = "Budi"    // Tidak bisa nil
let namaOptional: String? = nil   // Bisa nil

// Membandingkan optional
if namaOptional == nil {
    print("Nama kosong")
}

// Enum sederhana
enum Direction {
    case north, south, east, west
}

let arah = Direction.north
print(arah)  // north

// Switch dengan enum
switch arah {
case .north:
    print("Ke utara")
case .south:
    print("Ke selatan")
case .east:
    print("Ke timur")
case .west:
    print("Ke barat")
}

// Enum dengan Raw Value
enum Planet: Int {
    case mercury = 1, venus = 2, earth = 3, mars = 4
}

let bumi = Planet.earth
print(bumi.rawValue)  // 3

// Inisialisasi dari raw value
if let planet = Planet(rawValue: 2) {
    print(planet)  // venus
}

enum Currency: String {
    case idr = "IDR"
    case usd = "USD"
    case eur = "EUR"
}
let mataUang = Currency.idr
print(mataUang.rawValue)  // IDR

// Enum dengan Associated Values
enum Barcode {
    case upc(Int, Int, Int, Int)
    case qrCode(String)
}

let kode = Barcode.upc(8, 85909, 51226, 3)
let qr = Barcode.qrCode("ABCDEFGH")

switch kode {
case .upc(let sistem, let produsen, let produk, let check):
    print("UPC: \(sistem)-\(produsen)-\(produk)-\(check)")
case .qrCode(let kode):
    print("QR: \(kode)")
}

// Enum dengan Method
enum Kompas {
    case utara, selatan, timur, barat

    func deskripsi() -> String {
        switch self {
        case .utara: return "Menghadap utara 🧭"
        case .selatan: return "Menghadap selatan"
        case .timur: return "Menghadap timur 🌅"
        case .barat: return "Menghadap barat 🌇"
        }
    }

    func berlawananArah() -> Kompas {
        switch self {
        case .utara: return .selatan
        case .selatan: return .utara
        case .timur: return .barat
        case .barat: return .timur
        }
    }
}

let mataAngin = Kompas.utara
print(mataAngin.deskripsi())        // Menghadap utara 🧭
print(mataAngin.berlawananArah())   // selatan

// CaseIterable — bisa di-loop semua case
enum Hewan: CaseIterable {
    case kucing, anjing, burung, ikan
}

for hewan in Hewan.allCases {
    print(hewan)
}

// Struct sederhana
struct Mahasiswa {
    var nama: String
    var nim: String
    var ipk: Double

    // Computed property
    var predikat: String {
        if ipk >= 3.5 {
            return "Cum Laude"
        } else if ipk >= 3.0 {
            return "Sangat Memuaskan"
        } else {
            return "Memuaskan"
        }
    }
}

// Membuat instance
var mhs1 = Mahasiswa(nama: "Andi", nim: "12345", ipk: 3.7)
print(mhs1.nama)       // Andi
print(mhs1.predikat)   // Cum Laude

// Mengubah properti
mhs1.ipk = 3.2
print(mhs1.predikat)   // Sangat Memuaskan

// Struct dengan method
struct Kalkulator {
    var angka1: Double
    var angka2: Double

    func tambah() -> Double {
        return angka1 + angka2
    }

    func kurang() -> Double {
        return angka1 - angka2
    }

    func kali() -> Double {
        return angka1 * angka2
    }
}

let calc = Kalkulator(angka1: 10, angka2: 5)
print(calc.tambah())   // 15
print(calc.kurang())   // 5
print(calc.kali())     // 50

// Struct dengan default values
struct Setting {
    var namaAplikasi: String
    var versi: String = "1.0"
    var darkMode: Bool = true
    var font: String = "Arial"
}

let setting = Setting(namaAplikasi: "MyApp")
print(setting.versi)    // 1.0
print(setting.darkMode) // true

// Value type behavior
struct Point {
    var x: Int
    var y: Int
}

var p1 = Point(x: 1, y: 1)
var p2 = p1  // p2 adalah salinan p1
p2.x = 10
print(p1.x)  // 1 (p1 TIDAK berubah!)
print(p2.x)  // 10

// Extension — menambah method/properti ke struct yang sudah ada
extension Point {
    func deskripsi() -> String {
        return "Point(\(x), \(y))"
    }
}
print(p1.deskripsi())  // Point(1, 1)

// CustomStringConvertible — tampilan saat di-print
struct Warna: CustomStringConvertible {
    var merah: Int
    var hijau: Int
    var biru: Int

    var description: String {
        return "RGB(\(merah), \(hijau), \(biru))"
    }
}

let merah = Warna(merah: 255, hijau: 0, biru: 0)
print(merah)  // RGB(255, 0, 0)

// Class sederhana
class Mobil {
    var merk: String
    var tahun: Int
    var kecepatan: Int = 0

    // Initializer (wajib ada jika ada properti tanpa default)
    init(merk: String, tahun: Int) {
        self.merk = merk
        self.tahun = tahun
    }

    func jalankan() {
        print("\(merk) mulai berjalan")
        kecepatan = 60
    }

    func berhenti() {
        print("\(merk) berhenti")
        kecepatan = 0
    }

    func deskripsi() -> String {
        return "\(merk) tahun \( tahun) - kecepatan: \(kecepatan) km/h"
    }
}

// Membuat instance
let mobil1 = Mobil(merk: "Toyota", tahun: 2024)
mobil1.jalankan()
print(mobil1.deskripsi())  // Toyota tahun 2024 - kecepatan: 60 km/h

// Reference type — semua referensi ke objek yang SAMA
var mobil2 = mobil1  // mobil2 merujuk ke objek yang sama
mobil2.merk = "Honda"
print(mobil1.merk)  // Honda! (berubah juga karena same object)

// Inheritance (Pewarisan)
class MobilSport: Mobil {
    var turbo: Bool

    init(merk: String, tahun: Int, turbo: Bool) {
        self.turbo = turbo
        super.init(merk: merk, tahun: tahun)
    }

    func aktifkanTurbo() {
        if turbo {
            kecepatan = 200
            print("Turbo aktif! 🏎️")
        }
    }
}

let ferrari = MobilSport(merk: "Ferrari", tahun: 2024, turbo: true)
ferrari.jalankan()
ferrari.aktifkanTurbo()  // Turbo aktif! 🏎️
print(ferrari.deskripsi())

// Override method
class Animal {
    var nama: String

    init(nama: String) {
        self.nama = nama
    }

    func suara() -> String {
        return "..."
    }
}

class Kucing: Animal {
    override func suara() -> String {
        return "Meong! 🐱"
    }
}

class Anjing: Animal {
    override func suara() -> String {
        return "Guk guk! 🐶"
    }
}

let kucing = Kucing(nama: "Kitty")
let anjing = Anjing(nama: "Buddy")
print("\(kucing.nama) bilang: \(kucing.suara())")  // Kitty bilang: Meong! 🐱
print("\(anjing.nama) bilang: \(anjing.suara())")  // Buddy bilang: Guk guk! 🐶

// Deinitializer — dipanggil saat objek di-dealloc
class Database {
    var nama: String

    init(nama: String) {
        self.nama = nama
        print("Database \(nama) dibuka")
    }

    deinit {
        print("Database \(nama) ditutup")
    }
}

var db: Database? = Database(nama: "mydb")  // Database mydb dibuka
db = nil  // Database mydb ditutup

// Protocol sederhana
protocol DapatDikendarai {
    var kecepatanMaks: Int { get }
    func jalankan()
    func berhenti()
}

// Struct mengadopsi protocol
struct SepedaMotor: DapatDikendarai {
    var nama: String
    var kecepatanMaks: Int = 120

    func jalankan() {
        print("\(nama) mulai melaju")
    }

    func berhenti() {
        print("\(nama) berhenti")
    }
}

let motor = SepedaMotor(nama: "Honda Vario")
motor.jalankan()  // Honda Vario mulai melaju
print("Kecepatan maks: \(motor.kecepatanMaks)")  // 120

// Protocol dengan default implementation (extension)
protocol BisaDihitung {
    func hitung() -> Int
}

extension BisaDihitung {
    func hitung() -> Int {
        return 0  // Default implementation
    }
}

struct Kounter: BisaDihitung {
    var jumlah: Int
    // Bisa override atau gunakan default
    func hitung() -> Int {
        return jumlah
    }
}

// Protocol dengan properti requirement
protocol Describable {
    var deskripsi: String { get }
}

protocol Mutable {
    var nama: String { get set }
}

// Class conforming ke multiple protocol
class Manusia: Describable, Mutable {
    var nama: String
    var umur: Int

    init(nama: String, umur: Int) {
        self.nama = nama
        self.umur = umur
    }

    var deskripsi: String {
        return "\(nama), umur \(umur) tahun"
    }
}

let orang = Manusia(nama: "Budi", umur: 30)
print(orang.deskripsi)  // Budi, umur 30 tahun

// Protocol — digunakan sebagai tipe
func tampilkanInfo(item: Describable) {
    print("Info: \(item.deskripsi)")
}

tampilkanInfo(item: orang)  // Info: Budi, umur 30 tahun

// Protocol dengan associated type
protocol Kotak {
    associatedtype Item
    mutating func masukan(_ item: Item)
    func keluarkan() -> Item?
}

struct KotakBuku: Kotak {
    typealias Item = String
    private var buku: [String] = []

    mutating func masukan(_ item: String) {
        buku.append(item)
    }

    func keluarkan() -> String? {
        return buku.last
    }
}

var kotak = KotakBuku()
kotak.masukan("Swift Programming")
kotak.masukan("Design Patterns")
print(kotak.keluarkan()!)  // Design Patterns

// Mendefinisikan error dengan enum
enum LoginError: Error {
    case usernameKosong
    case passwordSalah
    case akunTerblokir
}

// Fungsi yang bisa melempar error
func login(username: String, password: String) throws -> String {
    if username.isEmpty {
        throw LoginError.usernameKosong
    }
    if password != "rahasia" {
        throw LoginError.passwordSalah
    }
    return "Login berhasil! 🎉"
}

// do-catch
do {
    let hasil = try login(username: "andi", password: "rahasia")
    print(hasil)
} catch LoginError.usernameKosong {
    print("Username tidak boleh kosong!")
} catch LoginError.passwordSalah {
    print("Password salah!")
} catch LoginError.akunTerblokir {
    print("Akun telah terblokir!")
} catch {
    print("Error tidak diketahui: \(error)")
}

// try? — mengembalikan nil jika error
let hasil2 = try? login(username: "andi", password: "salah")
print(hasil2 ?? "Gagal")  // Gagal

// try! — force try (BERHATI-HATI)
// let hasil3 = try! login(...)  // CRASH jika error!

// Fungsi dasar
func sapa(nama: String) -> String {
    return "Halo, \(nama)!"
}
print(sapa(nama: "Andi"))

// Default parameter
func power(base: Int, exponent: Int = 2) -> Int {
    var result = 1
    for _ in 0..<exponent {
        result *= base
    }
    return result
}
print(power(base: 3))          // 9
print(power(base: 2, exponent: 10))  // 1024

// Variadic parameter
func jumlahkan(_ angka: Int...) -> Int {
    return angka.reduce(0, +)
}
print(jumlahkan(1, 2, 3, 4))  // 10

// Closure
let tambah = { (a: Int, b: Int) -> Int in
    return a + b
}
print(tambah(3, 5))  // 8

// Closure dalam array
let angka = [5, 3, 1, 4, 2]
let terurut = angka.sorted { $0 < $1 }
print(terurut)  // [1, 2, 3, 4, 5]

// Map, Filter, Reduce
let nums = [1, 2, 3, 4, 5]
let doubled = nums.map { $0 * 2 }
print(doubled)  // [2, 4, 6, 8, 10]

let even = nums.filter { $0 % 2 == 0 }
print(even)  // [2, 4]

let sum = nums.reduce(0, +)
print(sum)  // 15