Media Belajar Bahasa Pemrograman | by APPKEY

SwiftTutorial Swift 33 : Cara Menggunakan Swift Optional Chaining

Tutorial Swift 33 : Cara Menggunakan Swift Optional Chaining

-

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.

Optional Chaining ‘?’ Akses ke metode, properti, dan subscriptsOptional Chaining ‘!’untuk memaksa Unwrapping
? ditempatkan setelah nilai opsional untuk memanggil properti, metode, atau subskrip ! ditempatkan setelah nilai opsional untuk memanggil properti, metode, atau subskrip untuk memaksa membuka bungkus nilai
Gagal dengan anggun ketika opsionalnya adalah ‘nihil’ Pembukaan paksa memicu kesalahan waktu proses ketika opsionalnya adalah ‘nihil’

 

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.

Artikel Terkait  Tutorial Swift 16 : Mari Mengenal Sets dalam Swift

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.

Artikel Terkait  Tutorial Swift 2 : Install Swift, Tahap Awal Mengatur Lingkungan Kerja pada Swift

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.


Jasa Pembuatan Aplikasi, Website dan Internet Marketing | PT APPKEY
PT APPKEY adalah perusahaan IT yang khusus membuat aplikasi Android, iOS dan mengembangkan sistem website. Kami juga memiliki pengetahuan dan wawasan dalam menjalankan pemasaran online sehingga diharapkan dapat membantu menyelesaikan permasalahan Anda.

Jasa Pembuatan Aplikasi

Jasa Pembuatan Website

Jasa Pembuatan Paket Aplikasi

Jasa Pembuatan Internet Marketing

Tutorial

Subscribe Sekarang

Dapatkan beragam informasi menarik tentang bahasa pemrograman langsung melalui email Anda. Subscribe sekarang dan terus belajar bersama kami!

Blog Post Ranking 10

Tutorial Python 9 : Cara Membuat Looping Python

Pada artikel sebelumnya, Codekey telah menjelaskan tentang Operasi Kondisional Python yang di dalamnya menyinggung tentang percabangan dan perulangan. Belajar...

Tutorial PHP 22 : Cara Membuat Redirect PHP dengan Cepat dan Mudah

Jika Anda melakukan browsing di browser kesayangan Anda, mungkin Anda pernah melihat link yang berisikan “php redirect” atau yang...

Tutorial Python 8 : Langkah Mudah Membuat Operasi Kondisional pada Python

Pada pembahasan sebelumnya, Codekey telah menjelaskan kepada Anda tentang pengoperasian string pada Python mulai dari menggabungkan hingga memanipulasi string...

Tutorial Python 7 : Python String Format dan Cara Mudahnya

Anda ingin belajar Python dan ingin menjadi ahli dalam bahasa pemrograman Python? Mari belajar bersama Codekey! Pada pembahasan kali...

Tutorial PHP 23 : Cara Membuat Messages Alert PHP

Alert box atau alert messages digunakan di situs web untuk menampilkan pesan peringatan kepada pengguna bahwa mereka telah memasukkan...

Tutorial Dart 18 : Ayo Mulai, Pelajari Cara Install Flutter

Pada seri tutorial Dart kali ini, Codekey akan menampilkan hal yang sedikit berbeda, yaitu tentang aplikasi-aplikasi yang mendukung pemrograman...

Tutorial SQL 8 : Constraint SQL, Bagaimana Fungsi dan Penggunaannya?

Pada artikel sebelumnya Anda telah mempelajari tentang wildcard SQL, pada artikel kali ini kami akan menjelaskan tentang constraint SQL. Jika...

Tutorial SQL 20 : Mari Pelajari Cara Menggunakan Fungsi GROUP by SQL

Pada pembahasan seri Tutorial SQL ke- 20 ini, Codekey akan membahas tentang GROUP BY yang merupakan statement di dalam...

Tutorial Javascript 8 : Array Javascript, Panduan Lengkap Cara Membuatnya

Seperti bahasa pemrograman yang berorientasi objek lainnya, dalam JavaScript juga terdapat array. Jika Anda memiliki banyak objek yang ingin...

Tutorial Javascript 21 : Panduan Membuat Number Format Javascript

Ada banyak cara berbeda untuk mencetak integer dengan koma sebagai pemisah ribuan dalam JavaScript. Untuk mencetak integer dalam JavaScript,...

Bisnis

Online Service

Peluang Bisnis

Model Bisnis

Entrepreneurship

Uang

Ketrampilan

Outsourcing

Monetize

Pemasaran

SEO

Internet Marketing

Dasar Pemasaran

Strategi Pemasaran

Situs Web Analitik

Iklan

Teknologi

Teknologi Terbaru

AI

Komputer

Jaringan

Paling Sering dibaca
Mungkin Anda Menyukainya