ออปชันนัล
ออปชันนัล
ออปชันนัล เป็นบทเรียน Swift Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 1 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Swift Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Swift Academy มีบทเรียนทั้งหมด 1 บทเรียน
บทนำ
สวัสดีครับ/ค่ะ
ใช้เพื่อระบุว่าตัวแปรแบบออปชันนัลอาจไม่มีค่า
หากตัวแปรชนิดออปชันนัลมีค่า ตัวแปรนี้จะถูกแกะห่อเพื่อนำไปใช้งาน หรือมิฉะนั้นก็จะไม่มีค่า
การใช้ออปชันนัลกับชนิดข้อมูลหลายแบบใน Swift
แนวคิดนี้อาจเปรียบเทียบได้กับ nil pointer ใน Obj-C อย่างไรก็ตาม nil pointer ใช้ได้กับชนิดออบเจ็กต์เท่านั้น
ออปชันนัลใน Swift ไม่ได้ใช้เฉพาะกับชนิดออบเจ็กต์เท่านั้น แต่ยังใช้กับ Struct, enum หรือชนิดข้อมูลพื้นฐานได้ด้วย
var optionalVar: String?
// optionalVar is automatically set to nil]
/*
Since we define it as optional without
assigning a value, the variable
automatically takes the value of nil.
*/nil ใน Swift และ nil ใน Obj-C ไม่เหมือนกัน
nil ใน Swift และ nil ใน Obj-C ไม่ได้ เหมือนกัน
nil pointer ใน Obj-C แสดงว่าไม่มีออบเจ็กต์อยู่ ส่วนใน Swift nil ไม่ใช่ nil pointer แต่แสดงว่าไม่มีข้อมูล และรองรับชนิดข้อมูลอื่น ๆ นอกเหนือจากชนิดออบเจ็กต์ด้วย
การบังคับแกะห่อค่า
เราสามารถเข้าถึงตัวแปรที่กำหนดเป็นออปชันนัลได้โดยใช้วิธีบังคับแกะห่อค่า
การใช้ตัวดำเนินการเครื่องหมายอัศเจรีย์จะบังคับให้แกะค่าออกมาได้ แต่โดยทั่วไปไม่ควรใช้วิธีนี้มากนัก
หากไม่มีข้อมูลอ้างอิงขณะบังคับแกะห่อค่า เราจะได้รับข้อผิดพลาดขณะทำงาน
let convertedNumber : Int? = 123
if convertedNumber != nil {
print("convertedNumber has an integer value of \(convertedNumber!).")
}
// Prints "convertedNumber has an integer value of 123."การเข้าถึงออปชันนัลด้วยการผูกค่าออปชันนัล
การเข้าถึงออปชันนัลด้วยการผูกค่าออปชันนัล
ด้วยบล็อก if let เราสามารถเข้าถึงค่าของตัวแปรออปชันนัลได้ โดยกำหนดค่าให้กับค่าคงที่หรือตัวแปร
การใช้วิธีนี้แทนการบังคับแกะห่อค่าเป็นวิธีที่เรียบร้อยและเหมาะสมกว่า
var possibleNumber : String? = "10"
if let actualNumber = possibleNumber {
print(actualNumber)
}ตัวอย่าง
if let firstNumber = Int("4"), let secondNumber = Int("42"),
firstNumber < secondNumber && secondNumber < 100 {
print("\(firstNumber) < \(secondNumber) < 100")
}
// Prints "4 < 42 < 100"
/*
If at least one of them is false,
it will not be entered in the if blog.
*/
ออปชันนัลที่แกะห่อโดยปริยาย
ออปชันนัลที่แกะห่อโดยปริยาย
ในบางกรณี ค่าออปชันนัลจะถูกกำหนดไว้ในขั้นแรก และในขั้นต่อมาเราทราบแน่ชัดว่าค่านั้นจะไม่เป็น nil
ในกรณีเช่นนี้ แทนที่จะใช้ออปชันนัล (?) เราสามารถใช้ตัวดำเนินการ (!) เพื่อระบุว่าออปชันนัลนี้จะไม่เป็น nil อย่างแน่นอน
รูปแบบการกำหนดเช่นนี้เรียกว่า 'ออปชันนัลที่แกะห่อโดยปริยาย'
การแกะห่อโดยปริยาย
การแกะห่อโดยปริยาย
มักใช้ในระยะเริ่มต้นคลาสมากที่สุด
ต่างจากออปชันนัลแบบทั่วไป เราไม่จำเป็นต้องแกะห่อตัวแปรที่กำหนดให้แกะห่อโดยปริยาย
let possibleString: String? = "An optional string."
// requires an exclamation mark
let forcedString: String = possibleString!
let assumedString: String! = "An implicitly unwrapped optional string."
// no need for an exclamation mark
let implicitString: String = assumedString ตัวอย่าง
หากเรากำหนด nil ให้กับตัวแปรชนิดนี้ เราจะได้รับข้อผิดพลาดขณะทำงาน
ลองดูตัวอย่างกัน
/*
We can use it during optional binding or we can check for nil.
So we use implicitly unwrapped optional
in the same way we use classic optional.
*/
var assumedString: String! = nil
if let definiteString = assumedString {
print(definiteString)
}
// Prints "An implicitly unwrapped optional string."คำเตือน
หากตัวแปรมีโอกาสเป็น nil จะต้องไม่ใช้ออปชันนัลที่แกะห่อโดยปริยาย
ตัวดำเนินการรวมค่าว่าง
ตัวดำเนินการรวมค่าว่าง
ตัวดำเนินการนี้ช่วยให้คลายค่าชนิดข้อมูลทางเลือกได้สะดวก
มาดูตัวอย่างกัน
let defaultColorName = "red"
// defaults to nil
var userDefinedColorName: String?
var colorNameToUse = userDefinedColorName ?? defaultColorName
/*
userDefinedColorName is nil,
so colorNameToUse is set to the default of "red"
*/
// a != nil ? a! : b
/*
We can think of it as a shortcut to the above expression.
A checks if a is nil, if a is not nil, it unwrap and eturn,
otherwise it returns the default value, ie b.
*/
ขอแสดงความยินดี
ขอแสดงความยินดี 🎉
แนวคิดเรื่องออปชันนัลเป็นหนึ่งในคุณสมบัติที่สำคัญที่สุดของสวิฟต์ การใช้ออปชันนัลช่วยให้เราไม่ต้องตรวจสอบค่าว่าง เขียนโค้ดได้อย่างเป็นระเบียบมากขึ้น และทำให้แอปพลิเคชันมีความปลอดภัยยิ่งขึ้น
พบกันในบทเรียนถัดไป 🥳

คำถามที่พบบ่อย
บทเรียน “ออปชันนัล” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ออปชันนัล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Swift Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Swift Academy มีบทเรียนทั้งหมด 1 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ออปชันนัล”
ออปชันนัล คุณปฏิบัติ Swift Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Swift Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Swift Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 1 บทเรียน
บทเรียน “ออปชันนัล” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Swift Academy นี้ได้ไหม
ได้ บทเรียน Swift Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ