0Pricing
Swift Academy · บทเรียน

ออปชันนัล

ออปชันนัล

ออปชันนัล เป็นบทเรียน 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.
*/

ขอแสดงความยินดี

ขอแสดงความยินดี 🎉

แนวคิดเรื่องออปชันนัลเป็นหนึ่งในคุณสมบัติที่สำคัญที่สุดของสวิฟต์ การใช้ออปชันนัลช่วยให้เราไม่ต้องตรวจสอบค่าว่าง เขียนโค้ดได้อย่างเป็นระเบียบมากขึ้น และทำให้แอปพลิเคชันมีความปลอดภัยยิ่งขึ้น

พบกันในบทเรียนถัดไป 🥳

ออปชันนัล — ภาพประกอบ 12

คำถามที่พบบ่อย

บทเรียน “ออปชันนัล” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ออปชันนัล” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

← กลับไปที่ Swift Academy