Tutorial Swift 33 : Cara Menggunakan Swift Optional Chaining

Last Updated on May 21, 2022 by

Pada bahasa pemrograman swift terdapat opsi untuk mengkueri, memanggil properti, metode, dan subskrip pada opsional yang mungkin bernilai nil atau nihil. Opsi ini dikenal dengan Swift Optional Chaining.

Optional chaining adalah salah satu hal yang sangat dibutuhkan ketika bekerja dengan bahasa Swift.   Pada artikel ini, kami akan mengajak Anda untuk belajar Swift tentang cara menggunakan optional changing di Swift.  Ini dia penjelasannya.

Apa Itu Swift Optional Chaining?

Swift Optional Chaining ada dalam proses query, memanggil properti, subscript dan metode secara opsional yang mungkin bernilai ‘nil’ atau nihil didefinisikan sebagai opsional chaining. Optional chaining mengembalikan dua nilai yaitu:

• Jika optional berisi ‘nilai’ maka memanggil properti, metode, dan subskrip terkaitnya mengembalikan nilai
• Jika optional berisi nilai ‘nil’, semua properti, metode, dan subskrip terkaitnya mengembalikan nil

Karena beberapa kueri ke metode, properti, dan subskrip dikelompokkan bersama, kegagalan pada satu chaining akan memengaruhi seluruh chaining dan menghasilkan nilai ‘nil’ atau ‘nihil’.

Jika string opsional yang berisi nilai, properti, metode, atau panggilan indeks berhasil jika opsinya nihil, properti, metode, atau panggilan indeks mengembalikan nihil. Beberapa kueri dapat dichaining bersama-sama, dan seluruh chaining gagal dengan baik jika ada tautan dalam chaining yang nihil.

Optional Chaining sebagai Alternatif untuk Forced Unwrapping

Rantai opsional ditentukan setelah nilai opsional dengan ‘?’ yang digunakan untuk memanggil subskrip, metode, dan properti ketika nilai opsional mengembalikan beberapa nilai.

Program untuk Swift Optional Chaining dengan ‘!’

class Buku {
   var kategori: Kategori?
}

class Kategori {
   var nama = "Action"
}

let hasil = Buku()
let bukukat = hasil.kategori!.nama

Ketika menjalankan programnya Anda akan memperoleh hasil sebagai berikut.

fatal error: unexpectedly found nil while unwrapping an Optional value
0 Swift 4 0x0000000103410b68
llvm::sys::PrintStackTrace(__sFILE*) + 40
1 Swift 4 0x0000000103411054 SignalHandler(int) + 452
2 libsystem_platform.dylib 0x00007fff9176af1a _sigtramp + 26
3 libsystem_platform.dylib 0x000000000000000b _sigtramp + 1854492939
4 libsystem_platform.dylib 0x00000001074a0214 _sigtramp + 1976783636
5 Swift 4 0x0000000102a85c39
llvm::JIT::runFunction(llvm::Function*, std::__1::vector > const&) + 329
6 Swift 4 0x0000000102d320b3
llvm::ExecutionEngine::runFunctionAsMain(llvm::Function*,
std::__1::vector<std::__1::basic_string, std::__1::allocator >,
std::__1::allocator<std::__1::basic_string, std::__1::allocator > > > const&,
char const* const*) + 1523
7 Swift 4 0x000000010296e6ba Swift 4::RunImmediately(Swift
4::CompilerInstance&, std::__1::vector<std::__1::basic_string,
std::__1::allocator >, std::__1::allocator<std::__1::basic_string,
std::__1::allocator > > > const&, Swift 4::IRGenOptions&, Swift 4::SILOptions
const&) + 1066
8 Swift 4 0x000000010275764b frontend_main(llvm::ArrayRef,
char const*, void*) + 5275
9 Swift 4 0x0000000102754a6d main + 1677
10 libdyld.dylib 0x00007fff8bb9e5c9 start + 1
11 libdyld.dylib 0x000000000000000c start + 1950751300
Stack dump:
0. Program arguments:
/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/
usr/bin/Swift 4 -frontend -interpret – -target x86_64-apple-darwin14.0.0 –
target-cpu core2 -sdk
/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/
SDKs/MacOSX10.10.sdk -module-name main
/bin/sh: line 47: 15672 Done cat <<‘SWIFT 4’
import Foundation
</std::__1::basic_string</std::__1::basic_string</std::__1::basic_string</std::
__1::basic_string

Program di atas mendeklarasikan ‘Buku’ sebagai nama kelas dan berisi ‘kategori’ sebagai fungsi kategori. Subclass dideklarasikan sebagai ‘Kategori’ dan ‘nama’ sebagai fungsi nama yang diinisialisasi sebagai ‘Action’.

Panggilan ke superclass diinisialisasi dengan membuat instance ‘hasil’ dengan opsional ‘!’. Karena nilai tidak dideklarasikan di kelas dasarnya, nilai ‘nil’ disimpan sehingga mengembalikan kesalahan fatal dengan prosedur force unwrapping.

Program untuk Optional Chaining dengan ‘?’

class Buku {
   var kategori: Kategori?
}

class Kategori {
   var nama = "Action"
}
let hasil = Buku()

if let bukukat = hasil.kategori?.nama {
   print("Kategori: \(bukukat)")
} else {
   print("Kategori tidak dapat diambil")
}

Hasilnya adalah sebagai berikut:

Kategori tidak dapat diambil

Program di atas mendeklarasikan ‘Buku’ sebagai nama kelas dan berisi ‘kategori’ sebagai fungsi kategori. Subclass dideklarasikan sebagai ‘Kategori’ dan ‘nama’ sebagai fungsi nama yang diinisialisasi sebagai ‘Action’.

Panggilan ke superclass diinisialisasi dengan membuat instance ‘hasil’ dengan opsional ‘?’. Karena nilai tidak dideklarasikan di kelas dasarnya, nilai ‘nil’ disimpan dan dicetak di konsol oleh handler block lain.

Mendefinisikan Kelas Model untuk Optional Chaining & Mengakses Properties

Bahasa Swift 4 juga menyediakan konsep optional chaining, untuk mendeklarasikan lebih dari satu subclass sebagai model class. Konsep ini akan sangat berguna untuk mendefinisikan model yang kompleks dan untuk mengakses properti, metode, dan sub-properti subskrip.

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran:  \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var random: String?

   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()
if let nilai = final.hasil?.output {
   print("Luas:  \(nilai)")
} else {
   print("Tidak diketahui")
}

Ketika menjalankan kode untuk mendefinisikan Swift optional chaining dan mengakses properties adalah sebagai berikut.

Tidak diketahui

Memanggil Metode Melalui Optional Chaining

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }

   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?
   
   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()

if final.hasil?.lingkaranoutput() != nil {
   print("Lingkaran diketahui)")
} else {
   print("Lingkaran tidak diketahui")
}

Ketika dijalankan, maka hasil yang Anda dapat dari kode tersebut adalah sebagai berikut:

Lingkaran tidak diketahui

Fungsi lingkaranoutput() yang dideklarasikan di dalam subkelas lingkaran() dipanggil dengan membuat instance bernama ‘final’. Fungsi akan mengembalikan nilai jika berisi beberapa nilai jika tidak, fungsi akan mengembalikan beberapa pesan cetak yang ditentukan pengguna dengan mencentang pernyataan ‘if final.hasil?.lingkaranoutput() != nil’.

Mengakses Subskrip melalui Optional Chaining

Swift Optional Chaining digunakan untuk menyetel dan mengambil nilai subskrip untuk memvalidasi apakah panggilan ke subskrip tersebut mengembalikan nilai. ‘?’ ditempatkan sebelum kurung kurawal subskrip untuk mengakses nilai opsional pada subskrip tertentu.

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama =  radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?
   
   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()

if let radNama = final.hasil?[0].radnama {
   print("Radius: \(radNama)")
} else {
   print("Radius tidak diketahui")
}

Hasil yang diperoleh

Radius tidak diketahui

Dalam program di atas, nilai instans untuk fungsi keanggotaan ‘radiusName’ tidak ditentukan Oleh karena itu, program call ke suatu fungsi hanya akan mengembalikan bagian lain sementara untuk mengembalikan nilai kita perlu mengatur nilai ke fungsi anggota tertentu.

Mengakses Subskrip Optional Type

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }

   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?
   
   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()
final.hasil?[0] = rad(radnama: "Diameter")

let check = lingkaran()
check.luas.append(rad(radnama: "Units"))
check.luas.append(rad(radnama: "Meter"))
final.hasil = check

var luas = ["Rad": [13, 51, 9, 87], "Lingkaran": [55, 25, 66]]
luas["Rad"]?[1] = 56
luas["Lingkaran"]?[1] -= 1

print(luas["Rad"]?[0])
print(luas["Rad"]?[1])
print(luas["Rad"]?[2])
print(luas["Rad"]?[3])

print(luas["Lingkaran"]?[0])
print(luas["Lingkaran"]?[1])
print(luas["Lingkaran"]?[2])

Hasilnya adalah sebagai berikut

Optional(13)
Optional(56)
Optional(9)
Optional(87)
Optional(55)
Optional(24)
Optional(66)

Nilai opsional untuk subskrip dapat diakses dengan merujuk nilai subskripnya. Itu dapat diakses sebagai subskrip[0], subskrip[1] dll. Nilai subskrip default untuk ‘Rad’ pertama kali ditetapkan sebagai [13, 51, 9, 87] dan untuk ‘Lingkaran’ [55, 25, 66]] . Kemudian nilai subskrip diubah menjadi Rad[0] menjadi 56 dan Lingkaran[1] menjadi 24.

Menghubungkan Beberapa Tingkat Chaining

Beberapa sub kelas juga dapat dihubungkan dengan metode, properti, dan subskrip kelas supernya dengan rantai opsional. Beberapa rantai opsional dapat dihubungkan.

Jika jenis pengambilan bukan opsional, rangkaian opsional akan mengembalikan nilai opsional. Misalnya jika String melalui rantai opsional itu akan mengembalikan nilai ‘String?’

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?

   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()

if let radNama = final.hasil?[0].radnama {
   print("Radius: \(radNama)")
} else {
   print("Radius tidak diketahui")
}

Ketika dijalankan, hasilnya akan seperti di bawah ini.

Radius tidak diketahui

Dalam program di atas, nilai instansi untuk fungsi ‘radNama’ tidak ditentukan. Oleh karena itu, program call ke suatu fungsi hanya akan mengembalikan bagian lain sementara untuk mengembalikan nilai kita perlu mengatur nilai ke fungsi tertentu.

Jika jenis pengambilan sudah opsional, maka rantai opsional juga akan mengembalikan nilai opsional. Misalnya jika String? Apakah diakses melalui rantai opsional itu akan mengembalikan nilai ‘String?’

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?
   
   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()
final.hasil?[0] = rad(radnama: "Diameter")
let check = lingkaran()

check.luas.append(rad(radnama: "Units"))
check.luas.append(rad(radnama: "Meter"))
final.hasil = check

if let radNama = final.hasil?[0].radnama {
   print("Radius: \(radNama)")
} else {
   print("Radius tidak diketahui")
}

Apabila dijalankan, hasilnya akan menjadi sebagai berikut.

Radius: Units

Dalam program di atas, nilai instance untuk fungsi keanggotaan ‘radiusName’ ditentukan. Oleh karena itu, panggilan program ke fungsi sekarang akan mengembalikan nilai.

Chaining pada Metode dengan Nilai Pengembalian Opsional

Optional chaining digunakan untuk mengakses metode yang ditentukan subkelas juga.

class hitung {
   var hasil: lingkaran?
}

class lingkaran {
   var luas = [rad]()
   var output: Int {
      return luas.count
   }
   subscript(i: Int) -> rad {
      get {
         return luas[i]
      }
      set {
         luas[i] = newValue
      }
   }
   func lingkaranoutput() {
      print("Lingkaran: \(output)")
   }
   var x: referensi?
}

class rad {
   let radnama: String
   init(radnama: String) { self.radnama = radnama }
}

class referensi {
   var refNama: String?
   var refNum: String?
   var refluas: String?
   
   func Identifier() -> String? {
      if refNama != nil {
         return refNama
      } else if refNum != nil {
         return refNum
      } else {
         return nil
      }
   }
}

let final = hitung()

if final.hasil?.lingkaranoutput() != nil {
   print("Luas lingkaran diketahui)")
} else {
   print("Luas lingkaran tidak diketahui")

Ketika dijalankan, hasilnya akan menjadi sebagai berikut

Luas lingkaran tidak diketahui

Itulah penjelasan tentang Swift Optional Chaining dan berbagai contoh program untuk menggunakan optional chaining di Swift. Jika Anda tertarik untuk belajar Swift secara lebih mendalam, jangan lupa pelajari berbagai tutorial Swift hanya di Codekey.