Dalam artikel ini, Anda akan mempelajari tentang opsional, kasus penggunaannya, dan penanganan opsional di Swift.
Di artikel sebelumnya, kita belajar tentang tipe data berbeda yang tersedia di Swift dan juga memperhatikan variabel atau konstanta yang dideklarasikan dari tipe tersebut berisi nilai default.
Contoh:
let someValue = Int () print (someValue)
Saat Anda menjalankan program, hasilnya adalah:
0
Namun ada tipe data lain di Swift yang disebut Opsional, yang nilai defaultnya adalah nilai null ( nil). Anda dapat menggunakan opsional bila Anda ingin variabel atau konstanta tidak mengandung nilai di dalamnya. Jenis opsional mungkin berisi nilai atau tidak ada nilai (nilai null).
Secara non teknis, Anda bisa berpikir opsional sebagai kotak sepatu. Kotak sepatu mungkin berisi atau tidak ada sepatu di dalamnya. Jadi, Anda harus tahu terlebih dahulu saat mengakses sepatu dari dalam kotak.
Bagaimana cara mendeklarasikan Opsional?
Anda cukup merepresentasikan tipe Data sebagai Opsional dengan menambahkan !atau ?ke file Type. Jika sebuah opsional berisi nilai di dalamnya, ia mengembalikan nilai sebagai Optional, jika tidak ia mengembalikan nil.
Contoh 1: Bagaimana cara mendeklarasikan opsional di Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Saat Anda menjalankan program, hasilnya adalah:
nihil
Dalam program di atas, kami telah menginisialisasi tipe opsional menggunakan ?dan !. Kedua cara tersebut valid untuk membuat opsional tetapi ada satu perbedaan utama yang akan kita bahas di bawah.
Mendeklarasikan Int opsional berarti variabel akan memiliki nilai integer atau tanpa nilai. Karena tidak ada nilai yang ditetapkan ke variabel, Anda dapat melihat kedua printoutput pernyataan nildi layar.
Contoh 2: Menetapkan dan mengakses nilai dari opsional
let someValue:Int? = 5 print(someValue) print(someValue!)
Saat Anda menjalankan program, hasilnya adalah:
Opsional (5) 5
Dalam program di atas, kami telah mendeklarasikan jenis opsional Intdan menetapkan nilai 5 di dalamnya.
Seperti yang Anda lihat, mencetak opsional sebagai print(someValue)tidak memberi Anda 5tetapi Optional(5). Ini adalah dalam bentuk seperti dijelaskan di atas: Optional. Untuk mengaksesnya , kita membutuhkan mekanisme yang disebut unwrapping .
Anda dapat membuka bungkus opsional dengan menambahkan !karakter di akhir variabel / konstanta seperti di baris berikutnya print(someValue!). print(someValue!)membuka bungkus opsional dan keluaran 5di layar.
Namun, ingatlah, jenis mekanisme pembukaan bungkus ini hanya boleh digunakan ketika Anda yakin bahwa opsional akan memiliki nilai saat Anda mengaksesnya.
Contoh 3: Secara eksplisit mendeklarasikan opsional yang tidak terbungkus
Anda juga dapat membuat opsional yang tidak dibungkus sebagai:
let someValue:Int! = 5 print(someValue)
Saat Anda menjalankan program, hasilnya adalah:
5
Dalam program di atas, Int!membuat opsional yang tidak terbungkus, yang secara otomatis membuka nilai saat Anda mengaksesnya sehingga Anda tidak perlu setiap kali menambahkan !karakter.
Pastikan saat Anda menggunakan jenis opsional ini, variabel akan selalu memiliki nilai saat Anda mengaksesnya. Jika tidak, Anda akan mendapatkan error crash yang fatal.
Contoh 4: Kesalahan fatal saat mengakses opsional yang tidak dibuka bungkusnya
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Ketika Anda menjalankan program, Anda akan mendapatkan crash sebagai kesalahan fatal: tiba-tiba ditemukan nol saat membuka bungkus nilai Opsional karena kode unwrappedValue:Int = someValuemencoba untuk menetapkan nilai dari Opsional someValue ke variabel unwrappedValue.
Namun, somevalue adalah Optionaltipe yang mengandung nilnilai. Mencoba untuk menetapkan nilai nil ke variabel unwrappedValue yang bukan opsional akan menyebabkan error.
Ada beberapa teknik berbeda untuk menangani kasus ini yang dijelaskan di bawah ini.
Penanganan Opsional
Untuk menggunakan nilai opsional, itu perlu dibuka bungkusnya. Cara yang lebih baik untuk menggunakan nilai opsional adalah dengan membuka bungkus bersyarat daripada membuka paksa menggunakan !operator.
Ini karena membuka bungkusan bersyarat bertanya Periksa apakah variabel ini memiliki nilai? . Jika ya, berikan nilainya, jika tidak maka akan menangani kasus nil.
Sebaliknya, force unwrapping mengatakan Variabel ini memiliki nilai saat Anda menggunakannya . Oleh karena itu, ketika Anda memaksa membuka sebuah variabel yang nil, program Anda akan memunculkan nil yang tidak terduga ditemukan saat membuka bungkus pengecualian opsional dan macet . Beberapa teknik untuk membuka bungkus bersyarat dijelaskan di bawah ini:
1. Jika-pernyataan
You can use if statement and compare optional with nil to find out whether a optional contains a value or not. You can use the comparison operator "equal to" operator (==) or the "not equal to" operator (!=) in the if statement.
Example 5: Optional handling with if else statement
var someValue:Int? var someAnotherValue:Int! = 0 if someValue != nil ( print("It has some value (someValue!)") ) else ( print("doesn't contain value") ) if someAnotherValue != nil ( print("It has some value (someAnotherValue!)") ) else ( print("doesn't contain value") )
When you run the program, the output will be:
doesn't contain value It has some value 0
In the above program, the code inside if statement executes if an optional contain a value, otherwise the statement inside the else block executes. The major drawback of optional handling using this technique is, you still need to unwrap the value from optional using ! operator.
2. Optional Binding (if-let)
Optional binding helps you to find out whether an optional contains a value or not. If an optional contains a value, that value is available as a temporary constant or variable. Therefore, optional binding can be used with if statement to check for a value inside an optional, and to extract that value into a constant or variable in a single action.
Example 5: Optional handling using if let statement
var someValue:Int? var someAnotherValue:Int! = 0 if let temp = someValue ( print("It has some value (temp)") ) else ( print("doesn't contain value") ) if let temp = someAnotherValue ( print("It has some value (temp)") ) else ( print("doesn't contain value") )
When you run the program, the output will be:
doesn't contain value It has some value 0
In the above program, the code inside if statement executes if the optional contains a value. Otherwise the else block gets executed. The if-let statement also automatically unwraps the value and places the unwrapped value in temp constant. This technique has major advantage because you don't need to forcely unwrap the value although being certain an optional contains a value.
3. Guard statement
You can use guard to handle optionals in Swift. Don't worry if you don't know what guard is. For now, just think of guard as an if-else condition with no if block. If the condition fails, else statement is executed. If not, next statement is executed. See Swift guard for more details.
Example 6: Optional handling using guard-let
func testFunction() ( let someValue:Int? = 5 guard let temp = someValue else ( return ) print("It has some value (temp)") ) testFunction()
When you run the program, the output will be:
It has some value 5
In the above program, the guard contains a condition whether an optional someValue contains a value or not. If it contains a value then guard-let statement automatically unwraps the value and places the unwrapped value in temp constant. Otherwise, else block gets executed and and it would return to the calling function. Since, the optional contains a value, print function is called.
4. Nil-coalescing operator
In Swift, you can also use nil-coalescing operator to check whether a optional contains a value or not. It is defined as (a ?? b). It unwraps an optional a and returns it if it contains a value, or returns a default value b if a is nil.
Example 7: Optional handling using nil-coalescing operator
var someValue:Int! let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
When you run the program, the output will be:
5
Dalam program di atas, variabel someValue didefinisikan opsional dan berisi nilai nihil. Operator penggabungan nihil gagal membuka bungkusan opsional karena itu mengembalikan defaultValue. Oleh karena itu, pernyataan tersebut print(unwrappedValue)mengeluarkan 5 di konsol.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Saat Anda menjalankan program, hasilnya adalah:
10
Namun, dalam program di atas, variabel opsional someValue diinisialisasi dengan nilai 10. Jadi, operator penggabungan nihil berhasil membuka bungkus nilai dari someValue. Oleh karena itu, pernyataan tersebut someValue ?? defaultValuemengembalikan 10 dan pernyataan print(unwrappedValue)menghasilkan 10 di konsol.
