Dalam artikel ini, anda akan belajar mengenai pilihan, kes penggunaannya dan pengendalian pilihan di Swift.
Dalam artikel sebelumnya, kami mengetahui tentang berbagai jenis data yang tersedia di Swift dan juga melihat pemboleh ubah atau pemalar yang dinyatakan dari jenis tersebut mengandungi nilai lalai.
Contoh:
biarkan someValue = Int () mencetak (someValue)
Semasa anda menjalankan program, outputnya adalah:
0
Namun ada jenis data lain di Swift yang disebut Opsional, yang nilai lalai adalah nilai nol ( nil). Anda boleh menggunakan pilihan apabila anda mahukan pemboleh ubah atau pemalar tidak mengandungi nilai di dalamnya. Jenis pilihan mungkin mengandungi nilai atau tidak ada nilai (nilai nol).
Bukan secara teknikal, anda boleh menganggap pilihan sebagai kotak kasut. Kotak kasut mungkin atau tidak mengandungi kasut di dalamnya. Jadi, anda harus tahu terlebih dahulu semasa mengakses kasut dari kotak.
Bagaimana untuk menyatakan Pilihan?
Anda hanya boleh mewakili jenis Data sebagai Pilihan dengan menambahkan !atau ?ke Type. Sekiranya pilihan mengandungi nilai di dalamnya, ia mengembalikan nilai sebagai Optional, jika tidak, ia mengembalikan nil.
Contoh 1: Bagaimana cara menyatakan pilihan dalam Swift?
var someValue:Int? var someAnotherValue:Int! print(someValue) print(someAnotherValue)
Semasa anda menjalankan program, outputnya adalah:
nih nih
Dalam program di atas, kami telah menginisialisasi jenis pilihan menggunakan ?dan !. Kedua-dua cara itu sah untuk membuat pilihan tetapi ada satu perbezaan utama yang akan kita terokai di bawah.
Menyatakan Int pilihan bermaksud pemboleh ubah sama ada mempunyai nilai integer atau tidak ada nilai. Oleh kerana tidak ada nilai yang ditetapkan untuk pemboleh ubah, anda dapat melihat kedua-dua printoutput pernyataan nildi layar.
Contoh 2: Menetapkan dan mengakses nilai dari pilihan
let someValue:Int? = 5 print(someValue) print(someValue!)
Semasa anda menjalankan program, outputnya adalah:
Pilihan (5) 5
Dalam program di atas, kami telah menyatakan pilihan Intjenis dan memberikan nilai 5 di dalamnya.
Seperti yang anda lihat, mencetak pilihan sebagai print(someValue)tidak memberi anda 5tetapi Optional(5). Ia adalah dalam bentuk seperti yang dinyatakan di atas: Optional. Untuk mengaksesnya , kita memerlukan mekanisme yang disebut membuka bungkus .
Anda boleh membuka pilihan dengan menambahkan !watak pada akhir pemboleh ubah / pemalar seperti pada baris seterusnya print(someValue!). print(someValue!)membuka pilihan dan output 5pada skrin.
Walau bagaimanapun, ingat, mekanisme pembungkusan seperti ini hanya boleh digunakan apabila anda yakin bahawa pilihan tersebut pasti mempunyai nilai ketika anda mengaksesnya.
Contoh 3: Menyatakan secara jelas pilihan yang belum dibungkus
Anda juga boleh membuat pilihan yang belum dibungkus seperti:
let someValue:Int! = 5 print(someValue)
Semasa anda menjalankan program, outputnya adalah:
5
Dalam program di atas, Int!buat opsional yang belum dibungkus, yang secara automatik membuka nilai ketika anda mengaksesnya sehingga anda tidak perlu menambahkan !karakter setiap saat .
Pastikan anda menggunakan opsyen seperti ini, pemboleh ubah akan selalu memerlukan nilai ketika anda mengaksesnya. Sekiranya tidak, anda akan mengalami kerosakan ralat yang boleh membawa maut.
Contoh 4: Kesalahan maut semasa mengakses pilihan kosong yang belum dibungkus
var someValue:Int! var unwrappedValue:Int = someValue //crashes due to this line
Semasa anda menjalankan program, anda akan mengalami kerosakan sebagai ralat maut: tidak dijumpai dijumpai tanpa membuka nilai Pilihan kerana kod tersebut unwrappedValue:Int = someValuecuba memberikan nilai dari Opsyen someValue kepada variabel unsrappedValue.
Walau bagaimanapun, somevalue adalah Optionaljenis yang mengandungi nilnilai. Mencuba untuk menetapkan nilai nil pada variabel unsrappedValue yang bukan pilihan akan menyebabkan crash.
Terdapat teknik yang berbeza untuk menangani kes ini yang dijelaskan di bawah.
Pengendalian Pilihan
Untuk menggunakan nilai pilihan, ia harus dibungkus. Cara yang lebih baik untuk menggunakan nilai pilihan adalah dengan membuka pembungkus bersyarat daripada memaksa pembungkusan menggunakan !operator.
Ini kerana unrapping bersyarat meminta Periksa adakah pemboleh ubah ini mempunyai nilai? . Sekiranya ya, berikan nilainya, jika tidak, ia akan mengatasi kes nihil.
Sebaliknya, unrapping force mengatakan pemboleh ubah ini mempunyai nilai semasa anda menggunakannya . Oleh itu, apabila anda memaksa pembongkaran pemboleh ubah yang nihil, program anda akan membuang nil yang tidak dijumpai semasa membuka kad pengecualian dan kemalangan pilihan . Beberapa teknik untuk pembungkusan bersyarat dijelaskan di bawah:
1. Penyataan jika
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, pemboleh ubah someValue didefinisikan sebagai pilihan dan mengandungi nilai nihil. Pengendali penggabungan nil gagal membuka bungkusan pilihan sehingga mengembalikan nilai default. Oleh itu pernyataan itu print(unwrappedValue)mengeluarkan 5 di konsol.
var someValue:Int? = 10 let defaultValue = 5 let unwrappedValue:Int = someValue ?? defaultValue print(unwrappedValue)
Semasa anda menjalankan program, outputnya adalah:
10
Walau bagaimanapun, dalam program di atas, pemboleh ubah opsyen someValue diinisialisasi dengan nilai 10. Oleh itu, pengendali penggabungan nil berjaya melepaskan nilai dari someValue. Oleh itu, pernyataan someValue ?? defaultValuemengembalikan 10 dan penyataan tersebut print(unwrappedValue)mengeluarkan 10 di konsol.
