สูงสุด 40 Swift คำถามและคำตอบในการสัมภาษณ์ (2026)

โดย: ลูคัส เบนเน็ตต์ ลูคัส เบนเน็ตต์
Hours วันที่อัพเดท

Swift คำถามและคำตอบสัมภาษณ์

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

ตำแหน่งงานเหล่านี้เปิดเส้นทางอาชีพที่แข็งแกร่ง เนื่องจากระบบ iOS กำลังได้รับความนิยมเพิ่มขึ้น โดยให้รางวัลแก่ผู้ที่มีความเชี่ยวชาญด้านเทคนิค ความเชี่ยวชาญเฉพาะด้าน และประสบการณ์การทำงานจริง ผู้เชี่ยวชาญที่ทำงานในสาขานี้จะใช้การวิเคราะห์ พัฒนาทักษะให้ลึกซึ้งยิ่งขึ้น ทำงานร่วมกับทีม ช่วยเหลือผู้จัดการและผู้บริหารระดับสูง และสามารถตอบคำถามทั่วไปได้อย่างมั่นใจ ตั้งแต่ระดับเริ่มต้นจนถึงระดับผู้มีประสบการณ์ทั่วโลกในปัจจุบัน อ่านเพิ่มเติม ...

👉 ดาวน์โหลด PDF ฟรี: Swift คำถามและคำตอบในการสัมภาษณ์

Top Swift คำถามและคำตอบสัมภาษณ์

1) คืออะไร Swift แล้วอะไรทำให้มันได้รับความนิยมในการพัฒนาแอปพลิเคชัน iOS?

Swift คือ ภาษาโปรแกรมสมัยใหม่ระดับสูงที่พัฒนาโดย Apple สำหรับการสร้างแอปพลิเคชันบน iOS macOSwatchOS และ tvOS โดยเน้นย้ำถึง... ความปลอดภัย ประสิทธิภาพ และการแสดงออก, โดยมีคุณสมบัติ เช่น ประเภทเสริม, การอนุมานประเภทและ การจัดการหน่วยความจำอัตโนมัติ. Swiftไวยากรณ์ของภาษานี้กระชับแต่ทรงพลัง ซึ่งช่วยลดโอกาสเกิดข้อผิดพลาดในการเขียนโปรแกรมทั่วไป เช่น การเข้าถึงพอยเตอร์ที่เป็นค่าว่าง และความไม่ตรงกันของชนิดข้อมูล Swift ยังรองรับ การเขียนโปรแกรมเชิงโปรโตคอล (POP) ควบคู่ไปกับแนวคิดการเขียนโปรแกรมเชิงวัตถุแบบดั้งเดิม ช่วยให้สามารถเขียนโค้ดแบบโมดูลาร์และนำกลับมาใช้ใหม่ได้มากขึ้น

ตัวอย่าง: Swift's ประเภทเสริม ห่อหุ้มตัวแปรที่อาจมีหรือไม่มีค่าอยู่ภายใน ป้องกันการเกิดข้อผิดพลาดขณะรันไทม์โดยไม่คาดคิดเนื่องจากการอ้างอิงค่าว่าง ซึ่งเป็นสาเหตุหลักของข้อบกพร่องในภาษาโปรแกรมรุ่นก่อนๆ เช่น Objective-C

2) คุณประกาศตัวแปรและค่าคงที่อย่างไรใน Swiftvar กับ let ต่างกันอย่างไร?

เพื่อประกาศตัวแปรใน Swiftคุณใช้ varในการประกาศค่าคงที่ คุณใช้ let. ตัวแปร (var) ค่าของมันสามารถเปลี่ยนแปลงได้หลังจากได้รับการกำหนดค่าแล้ว ในขณะที่ คงที่ (let) ไม่สามารถกำหนดค่าใหม่ได้เมื่อเริ่มต้นใช้งานแล้ว ซึ่งส่งเสริมให้โค้ดมีความปลอดภัยและคาดเดาได้มากขึ้น

ตัวอย่าง:

var age = 25      // Variable
let name = "John" // Constant, value cannot change

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

3) วิชาเลือกในข้อนี้มีอะไรบ้าง Swift แล้วทำไมสิ่งเหล่านี้ถึงสำคัญ?

ตัวเลือกเสริมใน Swift เป็น คุณลักษณะทางภาษาที่แสดงถึงความเป็นไปได้ที่ตัวแปรอาจไม่มีค่าแทนที่จะสันนิษฐานโดยปริยายว่าตัวแปรนั้นเก็บข้อมูลอยู่เสมอ Swift ใช้ ? ไวยากรณ์ที่ใช้ระบุว่าตัวแปรอาจเป็น nilซึ่งทำให้โค้ดปลอดภัยยิ่งขึ้นโดยบังคับให้นักพัฒนาต้องแกะค่าหรือจัดการกับการไม่มีค่าอย่างชัดเจน

ตัวอย่าง:

var number: Int? = nil // This variable might hold an Int or nil

if let safeNumber = number {
    print(safeNumber)
} else {
    print("No value present")
}

ตัวเลือกเสริมช่วยตรวจจับข้อผิดพลาดในขั้นตอนการคอมไพล์ ซึ่งหากไม่เช่นนั้นจะปรากฏขึ้นในขั้นตอนการทำงาน

4) ความแตกต่างระหว่างประเภทค่าและประเภทอ้างอิงคืออะไร Swift?

In Swift, ประเภทค่า (เช่น struct, enum, tuple) จัดเก็บสำเนาที่ไม่ซ้ำกัน ของข้อมูล ในขณะที่ ประเภทการอ้างอิง (เช่น class) แชร์อินสแตนซ์เดียว จากแหล่งอ้างอิงหลายแห่ง

คุณสมบัติ (Feature) ประเภทค่า (struct, enum) ประเภทอ้างอิง (คลาส)
พฤติกรรมความจำ คัดลอกลงในงานที่ได้รับมอบหมาย การอ้างอิงร่วมกัน
ใช้กรณี แบบจำลองข้อมูล ข้อมูลน้ำหนักเบา วัตถุ สถานะที่ใช้ร่วมกัน
มรดก ไม่ได้รับการสนับสนุน ที่สนับสนุน
ตัวอย่าง struct Point { … } class Person { … }

ตัวอย่าง:

struct Score { var value: Int }
var first = Score(value: 10)
var second = first
second.value = 20
print(first.value) // 10 (unchanged)

นี่แสดงให้เห็นว่าการเปลี่ยนแปลงในสำเนาจะไม่ส่งผลกระทบต่อต้นฉบับสำหรับประเภทค่า

5) การนับอ้างอิงอัตโนมัติ (ARC) คืออะไร และทำงานอย่างไร Swift?

การนับอ้างอิงอัตโนมัติ (ARC) คือ Swift's ระบบจัดการหน่วยความจำ ซึ่งจะจัดการการจัดสรรและการยกเลิกการจัดสรรหน่วยความจำสำหรับอินสแตนซ์ของคลาสโดยอัตโนมัติ เมื่อมีการสร้างอินสแตนซ์ ARC จะ... tracks คือจำนวนการอ้างอิงที่ชี้ไปยังอินสแตนซ์นั้น เมื่อจำนวนการอ้างอิงลดลงเหลือศูนย์ อินสแตนซ์นั้นจะถูกยกเลิกการจัดสรร

ประเด็นสำคัญ:

  • แหล่งอ้างอิงที่น่าเชื่อถือ เพิ่มจำนวนการอ้างอิง
  • แหล่งอ้างอิงที่ไม่น่าเชื่อถือหรือไม่เป็นเจ้าของ อย่าเพิ่มจำนวนครั้ง และช่วยป้องกันวงจรการคงค่า (retain cycles) ซึ่งอาจทำให้เกิดการรั่วไหลของหน่วยความจำในแอป iOS

ตัวอย่าง: วงจรการอ้างอิงแบบคงค่า (retain cycle) ที่พบได้ทั่วไปเกิดขึ้นเมื่อวัตถุสองชิ้นถือการอ้างอิงที่แข็งแกร่งต่อกัน โดยใช้ weak or unowned คีย์เวิร์ดสามารถช่วยทำลายวงจรนี้ได้

6) Optional Chaining คืออะไร?

Optional chaining เป็นวิธีที่กระชับในการสอบถามและเรียกใช้คุณสมบัติ เมธอด และดัชนีบนออบเจ็กต์ Optional ที่อาจถูกกำหนดค่าไว้แล้ว nilถ้าตัวแปรเสริมมีค่า การเรียกใช้งานจะสำเร็จ ถ้าไม่มีค่า การเรียกใช้งานจะไม่สำเร็จ nilห่วงโซ่ทั้งหมดจึงกลับคืนมา nil โดยไม่เกิดการขัดข้อง

ตัวอย่าง:

let text: String? = "Hello"
let count = text?.count // count is an Optional<Int>

เทคนิคนี้ช่วยหลีกเลี่ยงการคลายห่อแบบบังคับping (!), ส่งผลให้โค้ดปลอดภัยยิ่งขึ้นและมีข้อผิดพลาดน้อยลง

7) คำสั่ง guard แตกต่างจากคำสั่ง if อย่างไร Swift?

การขอ guard คำสั่งนี้ใช้สำหรับการออกจากโปรแกรมก่อนกำหนด หากเงื่อนไขไม่เป็นไปตามที่กำหนด จะต้องออกจากขอบเขตปัจจุบัน (ด้วย) return, break, continueหรือ throw) เมื่อเงื่อนไขไม่เป็นไปตามที่กำหนด วิธีนี้จะช่วยให้จัดการกับสถานะที่ไม่ถูกต้องได้อย่างชัดเจนตั้งแต่เริ่มต้น

ตัวอย่าง:

func checkUsername(_ name: String?) {
    guard let safeName = name else {
        print("Username was nil")
        return
    }
    print("User: \(safeName)")
}

ไม่เหมือนไฟล์ if ประโยคที่มีตรรกะซ้อนกัน guard ช่วยลดความซับซ้อนของโค้ดและเพิ่มความอ่านง่าย

บทความที่เกี่ยวข้อง

8) การปิดใน... คืออะไร Swiftมีประโยชน์อย่างไรบ้าง?

การปิดให้บริการคือ บล็อกโค้ดที่แยกเป็นอิสระ ซึ่งสามารถส่งต่อได้เหมือนค่าต่างๆ และใช้เป็นตัวจัดการการเรียกกลับ (callback handler), ตัวจัดการการเสร็จสิ้น (completion handler) หรือตรรกะการดำเนินการแบบกำหนดเอง (custom operation logic) คล้ายกับฟังก์ชันแลมบ์ดาหรือฟังก์ชันนิรนามในภาษาโปรแกรมอื่นๆ

ตัวอย่าง:

let sumClosure = { (a: Int, b: Int) -> Int in
    return a + b
}
print(sumClosure(5, 7)) // 12

Closure จะดึงค่าจากบริบทโดยรอบ ทำให้เกิดรูปแบบการเขียนโปรแกรมแบบอะซิงโครนัสและเชิงฟังก์ชันที่มีประสิทธิภาพ

9) อธิบายเกี่ยวกับเจเนริกใน Swift และความสำคัญของพวกเขา

Generics ช่วยให้คุณสามารถเขียนฟังก์ชันและประเภทข้อมูลที่ยืดหยุ่นและนำกลับมาใช้ซ้ำได้ ใช้งานได้กับทุกประเภท ในขณะที่ยังคงรักษาความปลอดภัยของประเภทไว้ มีการใช้งานอย่างแพร่หลายใน Swift ไลบรารีมาตรฐาน (เช่น Array, Dictionaryฯลฯ )

ตัวอย่าง:

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

Generics ช่วยเพิ่มประสิทธิภาพการนำโค้ดกลับมาใช้ใหม่และลดความซ้ำซ้อน ทำให้คุณสามารถเขียนโค้ดที่มีประสิทธิภาพได้tracดำเนินการอย่างปลอดภัย

10) ความแตกต่างระหว่าง map, filter และ reduce คืออะไร Swift?

ฟังก์ชันเหล่านี้เป็นส่วนหนึ่งของ Swift's ยูทิลิตี้การเขียนโปรแกรมเชิงฟังก์ชัน เกี่ยวกับคอลเลกชัน:

  • แผนที่: เปลี่ยนแปลงองค์ประกอบแต่ละอย่าง
  • กรอง: เลือกองค์ประกอบที่ตรงตามเงื่อนไข
  • ลด: รวมองค์ประกอบทั้งหมดเข้าเป็นค่าเดียว

ตัวอย่าง:

let numbers = [1, 2, 3, 4, 5]
let squares = numbers.map { $0 * $0 }      // [1,4,9,16,25]
let evens = numbers.filter { $0 % 2 == 0 } // [2,4]
let sum = numbers.reduce(0, +)             // 15

เครื่องมือเหล่านี้ช่วยให้การจัดการข้อมูลมีประสิทธิภาพและกระชับยิ่งขึ้น Swift คอลเลกชัน

11) การอนุมานประเภททำงานอย่างไรใน Swiftและประโยชน์ของมันคืออะไร?

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

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

ตัวอย่าง:

let count = 10        // Inferred as Int
let message = "Hi"    // Inferred as String
let price = 19.99     // Inferred as Double

การอนุมานประเภททำงานได้อย่างราบรื่นกับเจเนริกส์ โคลเชอร์ และคอลเลกชัน ทำให้สามารถ Swift เพื่อรักษาความชัดเจนแม้ในสำนวนที่ซับซ้อน

12) โปรโตคอลในคืออะไร Swiftและอินเทอร์เฟซเหล่านี้แตกต่างจากอินเทอร์เฟซในภาษาโปรแกรมอื่นๆ อย่างไร?

โปรโตคอลใน Swift กำหนด แผนผังแสดงวิธีการ คุณสมบัติ และข้อกำหนด ซึ่งประเภทที่สอดคล้องกันจะต้องนำไปใช้ สิ่งเหล่านี้เป็นหัวใจสำคัญของ การเขียนโปรแกรมเชิงโปรโตคอล (POP)ซึ่งเป็นแบบแผนที่ได้รับการสนับสนุนอย่างมากจาก Swiftแตกต่างจากอินเทอร์เฟซแบบดั้งเดิมในบางภาษา Swift โปรโตคอลสามารถให้ การใช้งานเริ่มต้น ผ่านการขยายโปรโตคอล

โปรโตคอลสามารถนำไปใช้กับคลาส โครงสร้าง และ enum ได้ ซึ่งทำให้มีความยืดหยุ่นมากกว่า abs ที่อิงตามการสืบทอดtracนอกจากนี้ยังรองรับการปฏิบัติตามข้อกำหนดหลายรูปแบบ ซึ่งแตกต่างจากการสืบทอดแบบเดียวในคลาส

ตัวอย่าง:

protocol Drivable {
    var speed: Int { get }
    func drive()
}

extension Drivable {
    func drive() {
        print("Driving at speed \(speed)")
    }
}

แนวทางนี้ส่งเสริมการเชื่อมต่อแบบหลวมๆ ความสามารถในการทดสอบ และตรรกะที่นำกลับมาใช้ใหม่ได้ในประเภทที่ไม่เกี่ยวข้องกัน ทำให้โปรโตคอลมีประสิทธิภาพมากกว่าอินเทอร์เฟซแบบดั้งเดิม

13) จงอธิบายความแตกต่างระหว่าง struct และ class ใน Swift พร้อมตัวอย่าง

ความแตกต่างระหว่าง struct และ class in Swift ส่วนใหญ่อยู่ใน ความหมายของค่าเทียบกับความหมายของการอ้างอิงโครงสร้าง (Structures) เป็นชนิดข้อมูลแบบค่า (Value types) หมายความว่าค่าของมันจะถูกคัดลอกเมื่อมีการกำหนดค่าหรือส่งต่อ ส่วนคลาส (Classes) เป็นชนิดข้อมูลแบบอ้างอิง (Reference types) หมายความว่าการอ้างอิงหลายครั้งสามารถชี้ไปยังอินสแตนซ์เดียวกันได้

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

ตัวอย่าง:

struct User {
    var name: String
}

var user1 = User(name: "Alice")
var user2 = user1
user2.name = "Bob"

ที่นี่ user1 ยังคงไม่เปลี่ยนแปลง ความสามารถในการคาดเดาได้นี้ทำให้โครงสร้างข้อมูล (struct) เหมาะอย่างยิ่งสำหรับแบบจำลองและที่เก็บข้อมูล

14) วงจรชีวิตของแอปพลิเคชัน iOS ที่เขียนด้วยภาษาอะไร Swift?

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

ขั้นตอนสำคัญในวงจรชีวิตผลิตภัณฑ์ ได้แก่:

  • การเปิดตัวแอป
  • สถานะใช้งาน
  • สถานะพื้นหลัง
  • สถานะระงับ
  • สถานะสิ้นสุด

Swift แอปพลิเคชันจะจัดการการเปลี่ยนผ่านเหล่านี้เป็นหลักผ่านทาง AppDelegate และ ตัวแทนฉาก วิธีการต่างๆ ตัวอย่างเช่น application(_:didFinishLaunchingWithOptions:) ใช้สำหรับการตั้งค่าเริ่มต้น ในขณะที่ sceneDidEnterBackground(_:) ใช้เพื่อปล่อยทรัพยากรที่ใช้ร่วมกัน

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

15) ผู้สังเกตการณ์คุณสมบัติใน คืออะไร Swiftและควรใช้เมื่อใด?

ผู้สังเกตการณ์ทรัพย์สินใน Swift ช่วยให้นักพัฒนาสามารถตรวจสอบและตอบสนองต่อการเปลี่ยนแปลงในมูลค่าของอสังหาริมทรัพย์ได้ โดยจะนำไปใช้งานโดยใช้ willSet และ didSetซึ่งจะดำเนินการก่อนและหลังการเปลี่ยนแปลงคุณสมบัติ ตามลำดับ

ตัวสังเกตคุณสมบัติมีประโยชน์สำหรับการกระตุ้นผลข้างเคียง เช่น การอัปเดต UI การตรวจสอบความถูกต้องของข้อมูล หรือการซิงโครไนซ์ข้อมูลเมื่อค่าเปลี่ยนแปลง

ตัวอย่าง:

var score: Int = 0 {
    willSet {
        print("Score will change to \(newValue)")
    }
    didSet {
        print("Score changed from \(oldValue)")
    }
}

ตัวสังเกตการณ์จะไม่ทำงานในระหว่างการเริ่มต้นระบบ ซึ่งจะช่วยป้องกันพฤติกรรมที่ไม่คาดคิดในขณะสร้างวัตถุ จึงเหมาะสำหรับการตรวจสอบตรรกะอย่างง่ายมากกว่าการคำนวณที่ซับซ้อน

16) การจัดการข้อผิดพลาดทำงานอย่างไรใน Swift?

Swift ใช้โมเดลการจัดการข้อผิดพลาดที่มีโครงสร้างโดยอิงจาก การโยน การรับ และการแพร่กระจายข้อผิดพลาดข้อผิดพลาดต้องเป็นไปตามข้อกำหนด Error โปรโตคอลและได้รับการจัดการโดยใช้ do-try-catch บล็อก

ส่วนประกอบที่สำคัญ ได้แก่ :

  • throws คำหลักสำหรับฟังก์ชัน
  • try, try?และ try!
  • enum ข้อผิดพลาดแบบกำหนดเอง

ตัวอย่าง:

enum LoginError: Error {
    case invalidCredentials
}

func login(user: String) throws {
    throw LoginError.invalidCredentials
}

แนวทางนี้บังคับใช้การจัดการข้อผิดพลาดอย่างชัดเจนและปรับปรุงความน่าเชื่อถือโดยการป้องกันความล้มเหลวที่เกิดขึ้นโดยไม่แสดงอาการ Swift แอปพลิเคชันมีความแข็งแกร่งและบำรุงรักษาได้ง่ายขึ้น

17) Dependency Injection คืออะไรใน Swiftและทำไมจึงสำคัญ?

Dependency Injection (DI) เป็นรูปแบบการออกแบบที่วัตถุรับส่วนประกอบที่จำเป็นจากแหล่งภายนอกแทนที่จะสร้างขึ้นภายในเอง SwiftDI ช่วยเพิ่มความเป็นโมดูล ความสามารถในการทดสอบ และความยืดหยุ่นของโค้ด

ประเภทของการฉีดการพึ่งพา (Dependency Injection) ได้แก่:

  • การฉีดคอนสตรัคเตอร์
  • การฉีดทรัพย์สิน
  • วิธีการฉีด

ตัวอย่าง:

class NetworkService { }

class ViewModel {
    let service: NetworkService
    init(service: NetworkService) {
        self.service = service
    }
}

ด้วยการฉีด Dependency (Dependency Injection) นักพัฒนาสามารถสลับการใช้งานต่างๆ ได้อย่างง่ายดาย เช่น การจำลองบริการระหว่างการทดสอบ โดยไม่ต้องเปลี่ยนแปลงตรรกะหลัก DI ถูกนำมาใช้กันอย่างแพร่หลายในระบบที่สามารถขยายขนาดได้ Swift การใช้งาน

18) อธิบายข้อดีและข้อเสียของการใช้โคลเชอร์ใน Swift.

การปิดเป็นเครื่องมือที่มีประสิทธิภาพใน Swiftแต่ก็มีทั้งข้อดีและข้อเสีย

ข้อดี ข้อเสีย
ไวยากรณ์ที่กระชับ อาจลดความสามารถในการอ่านลงได้
เปิดใช้งานการเรียกกลับแบบอะซิงโครนัส ความเสี่ยงของวงจรการคงอยู่
บันทึกบริบท ความซับซ้อนของการดีบัก
การเขียนโปรแกรมเชิงฟังก์ชัน การใช้งานมากเกินไปอาจทำให้การไหลเวียนสับสนได้

Closure มักใช้สำหรับตัวจัดการการเสร็จสิ้น แอนิเมชัน และการแปลงฟังก์ชัน อย่างไรก็ตาม การใช้งานที่ไม่เหมาะสม โดยเฉพาะอย่างยิ่งกับการจับภาพอ้างอิงที่เข้มงวด อาจนำไปสู่การรั่วไหลของหน่วยความจำได้ [weak self] or [unowned self] ช่วยลดความเสี่ยงนี้ลง

ควรใช้ตัวปิดอย่างรอบคอบเพื่อให้เกิดความสมดุลระหว่างการแสดงออกและความสามารถในการบำรุงรักษา

19) อะไรคือความแตกต่างระหว่างการอ้างอิงแบบอ่อนและการอ้างอิงที่ไม่มีเจ้าของใน Swift?

ทั้งสอง weak และ unowned การอ้างอิงถูกนำมาใช้เพื่อป้องกัน รักษาวงจร ภายใต้ ARC ความแตกต่างที่สำคัญคือวิธีการจัดการการจัดสรรใหม่

แง่มุม อ่อนแอ ไม่มีเจ้าของ
สามารถเลือกหรือไม่เลือกก็ได้ มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่
ตั้งค่าเป็นศูนย์ อัตโนมัติ ไม่
ความปลอดภัย ปลอดภัยมากขึ้น อาจเป็นอันตรายหากใช้ไม่ถูกต้อง
ใช้กรณี ผู้ได้รับมอบหมาย รับประกันตลอดอายุการใช้งาน

ตัวอย่าง:

weak var delegate: SomeDelegate?

weak วิธีนี้เหมาะสมกว่าเมื่อวัตถุที่อ้างอิงอาจกลายเป็นค่าว่าง (nil) unowned ควรใช้เฉพาะเมื่อรับประกันวงจรชีวิต เช่น ความสัมพันธ์ระหว่างพ่อแม่และลูก

20) การทำงานแบบขนาน (Concurrency) ทำงานอย่างไรใน Swift ใช้ GCD และ async/await ใช่หรือไม่?

Swift รองรับการทำงานพร้อมกันผ่านทาง แกรนด์เซ็นทรัลดิสแพตช์ (GCD) และใหม่กว่า async/รอ โมเดล GCD ใช้คิวในการจัดการงานเบื้องหลัง ในขณะที่ async/await ให้แนวทางการทำงานพร้อมกันที่อ่านง่ายและมีโครงสร้างมากกว่า

ตัวอย่าง (async/await):

func fetchData() async throws -> String {
    return "Data loaded"
}

Async/await ช่วยลดการซ้อนของ Callback ปรับปรุงความอ่านง่าย และลดโอกาสเกิดข้อผิดพลาดในโค้ด GCD ยังคงมีประโยชน์สำหรับการจัดการงานระดับต่ำ แต่ในยุคปัจจุบันนั้น... Swift การพัฒนาในปัจจุบันให้ความสำคัญกับการทำงานพร้อมกันแบบมีโครงสร้างมากขึ้น

21) ระดับการควบคุมการเข้าถึงในคืออะไร Swiftและทำไมมันจึงสำคัญ?

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

ระดับการเข้าถึง ขอบเขต
open โมดูลภายนอกที่สามารถเข้าถึงได้และสร้างคลาสย่อยได้
public โมดูลภายนอกที่เข้าถึงได้
internal โดยค่าเริ่มต้น สามารถเข้าถึงได้ภายในโมดูล
fileprivate สามารถเข้าถึงได้ภายในไฟล์เดียวกัน
private สามารถเข้าถึงได้ภายในคำประกาศเดียวกัน

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

22) อธิบายความแตกต่างระหว่างตัวปรับแต่งการเข้าถึงแบบเปิดและแบบสาธารณะใน Swift.

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

คุณสมบัติ (Feature) เปิด สาธารณะ
โมดูลภายนอกที่เข้าถึงได้ มี (ใบกำกับภาษีเต็มรูปแบบ) มี (ใบกำกับภาษีเต็มรูปแบบ)
โมดูลภายนอกที่สามารถสร้างคลาสย่อยได้ มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่
โมดูลภายนอกที่สามารถเขียนทับได้ มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่

ตัวอย่างกรณีการใช้งาน: นักพัฒนาเฟรมเวิร์กใช้ public เมื่อพวกเขาต้องการเปิดเผยฟังก์ชันการทำงาน แต่ป้องกันการปรับแต่ง open ใช้เมื่อต้องการความสามารถในการขยาย เช่น เฟรมเวิร์ก UI ที่อนุญาตให้ปรับแต่งคลาสย่อยได้

ความแตกต่างนี้ช่วยให้ Swift เพื่อสร้างสมดุลระหว่างความปลอดภัยและความยืดหยุ่นในการออกแบบ API

23) การเริ่มต้นแบบเลซี่ (Lazy Initialization) คืออะไรใน Swiftและควรใช้เมื่อใด?

การเริ่มต้นแบบเลซี่ (Lazy initialization) จะเลื่อนการสร้างคุณสมบัติออกไปจนกว่าจะมีการเรียกใช้เป็นครั้งแรก Swiftซึ่งสามารถทำได้โดยใช้ lazy คำหลักนี้มักใช้เพื่อปรับปรุงประสิทธิภาพและลดการใช้หน่วยความจำที่ไม่จำเป็น

ตัวอย่าง:

class DataManager {
    lazy var dataSource = loadData()
    func loadData() -> [String] {
        return ["A", "B", "C"]
    }
}

คุณสมบัติแบบ Lazy มีประโยชน์อย่างยิ่งเมื่อการเริ่มต้นใช้งานมีค่าใช้จ่ายสูง เช่น การโหลดไฟล์ การร้องขอผ่านเครือข่าย หรือการเชื่อมต่อฐานข้อมูล ต้องประกาศคุณสมบัติเหล่านี้เป็นตัวแปรเสมอ (varเนื่องจากค่าของพวกมันถูกกำหนดหลังจากเริ่มต้นระบบแล้ว

การเริ่มต้นระบบแบบ Lazy Initialization ช่วยเพิ่มประสิทธิภาพในการเริ่มต้นระบบและประหยัดทรัพยากรเมื่อใช้งานอย่างเหมาะสม

24) ส่วนขยายใน คืออะไร Swiftแล้วพวกมันช่วยแก้ปัญหาอะไรบ้าง?

ส่วนขยายช่วยให้นักพัฒนาสามารถเพิ่มฟังก์ชันการทำงานใหม่ให้กับประเภทที่มีอยู่โดยไม่ต้องแก้ไขการใช้งานดั้งเดิม Swift ส่วนขยายสามารถเพิ่มเมธอด คุณสมบัติที่คำนวณได้ การปฏิบัติตามโปรโตคอล และประเภทที่ซ้อนกันได้

ตัวอย่าง:

extension Int {
    func squared() -> Int {
        return self * self
    }
}

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

ส่วนขยายช่วยให้โค้ดมีความเป็นโมดูล อ่านง่าย และบำรุงรักษาได้ง่าย โดยเฉพาะในโครงการขนาดใหญ่

25) จงอธิบายความแตกต่างระหว่างเมธอดแบบสแตติกและเมธอดแบบคลาสใน Swift.

ทั้งสอง static และ class คีย์เวิร์ดกำหนดเมธอดระดับประเภท แต่พฤติกรรมของคีย์เวิร์ดเหล่านั้นจะแตกต่างกันในสถานการณ์การสืบทอด

คำหลัก สามารถแทนที่ได้ การใช้
คงที่ ไม่ การใช้งานที่แก้ไขแล้ว
ชั้น มี (ใบกำกับภาษีเต็มรูปแบบ) ออกแบบมาเพื่อการสร้างคลาสย่อย

ตัวอย่าง:

class Vehicle {
    class func type() -> String {
        return "Vehicle"
    }
}

ใช้ static เมื่อพฤติกรรมควรคงเดิมในคลาสย่อยต่างๆ ให้ใช้ class เมื่อต้องการใช้โพลีมอร์ฟิซึม ความแตกต่างนี้มีความสำคัญในการออกแบบเฟรมเวิร์กและ API ซึ่งการตัดสินใจเกี่ยวกับความสามารถในการขยายนั้นมีความสำคัญ

26) ฟังก์ชันลำดับสูงคืออะไรใน Swiftโปรดตอบพร้อมยกตัวอย่างประกอบ

ฟังก์ชันลำดับสูง คือ ฟังก์ชันที่รับฟังก์ชันอื่นเป็นพารามิเตอร์ หรือส่งคืนฟังก์ชันเป็นผลลัพธ์ Swift แนวคิดนี้ได้รับการสนับสนุนอย่างมากผ่านวิธีการปิดและการรวบรวมต่างๆ

ฟังก์ชันลำดับสูงทั่วไป ได้แก่:

  • map
  • filter
  • reduce
  • compactMap
  • flatMap

ตัวอย่าง:

let values = [1, 2, 3, 4]
let doubled = values.map { $0 * 2 }

ฟังก์ชันลำดับสูงช่วยเพิ่มความชัดเจนในการแสดงออกของโค้ดและลดโค้ดซ้ำซ้อนในรูปแบบคำสั่ง ฟังก์ชันเหล่านี้ถูกใช้กันอย่างแพร่หลายในการเขียนโปรแกรมเชิงฟังก์ชันและเป็นพื้นฐานสำคัญในการเขียนโค้ดที่สะอาดและชัดเจน Swift รหัส.

27) วงจรการคงอยู่คืออะไร และจะป้องกันได้อย่างไร Swift?

วงจรการอ้างอิงแบบคงค่า (retain cycle) เกิดขึ้นเมื่ออินสแตนซ์ของคลาสสองตัวขึ้นไปถือการอ้างอิงที่แข็งแกร่งถึงกัน ทำให้ ARC ไม่สามารถปลดปล่อยหน่วยความจำได้ ส่งผลให้เกิดการรั่วไหลของหน่วยความจำ

สถานการณ์ทั่วไป:

การปิดที่จับภาพ self มีผลการเรียนดีเยี่ยมในชั้นเรียน

เทคนิคการป้องกัน:

  • ใช้ weak การอ้างอิง
  • ใช้ unowned การอ้างอิง
  • รายการจับภาพในการปิด

ตัวอย่าง:

someClosure = { [weak self] in
    self?.doSomething()
}

การทำความเข้าใจวงจรการเก็บรักษา (retain cycles) เป็นสิ่งสำคัญสำหรับการสร้างแอปพลิเคชัน iOS ที่ประหยัดหน่วยความจำ โดยเฉพาะอย่างยิ่งเมื่อทำงานกับ closures และ delegates

28) จงอธิบายความแตกต่างระหว่างโค้ดแบบซิงโครนัสและแบบอะซิงโครนัสใน Swift.

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

แง่มุม Syncมีเกียรติ ไม่ตรงกัน
การกระทำ การปิดกั้น ไม่ปิดกั้น
ประสิทธิภาพ UI ที่ทำงานช้าลง UI ที่ตอบสนอง
ใช้กรณี งานง่ายๆ การโทรผ่านเครือข่าย

Swift จัดการการเขียนโปรแกรมแบบอะซิงโครนัสโดยใช้ GCD, ตัวจัดการการเสร็จสิ้นและ async/รอการเขียนโค้ดแบบอะซิงโครนัสมีความสำคัญอย่างยิ่งต่อการรักษาประสบการณ์การใช้งานที่ราบรื่นในแอปพลิเคชันในโลกแห่งความเป็นจริง

29) Codable คืออะไรใน Swiftและทำไมมันถึงมีประโยชน์?

Codable เป็นโปรโตคอลที่ช่วยให้การเข้ารหัสและถอดรหัสข้อมูลระหว่างกันทำได้ง่าย Swift วัตถุและการแสดงผลภายนอก เช่น JSON หรือ Property Lists มันเป็นการผสมผสานระหว่าง Encodable และ Decodable.

ตัวอย่าง:

struct User: Codable {
    let id: Int
    let name: String
}

Codable ช่วยลดโค้ดซ้ำซ้อนและเพิ่มความน่าเชื่อถือในการจัดการ API ช่วยให้มั่นใจได้ถึงความปลอดภัยของประเภทข้อมูลและผสานรวมได้อย่างราบรื่นกับระบบอื่นๆ Swiftเป็นไลบรารีมาตรฐานของระบบ ทำให้เป็นโซลูชันที่ได้รับความนิยมสำหรับการแปลงข้อมูลเป็นรูปแบบอนุกรม (Data Serialization)

30) อะไรคือความแตกต่างที่สำคัญระหว่าง Array, Set และ Dictionary ใน Swift?

Swift มีประเภทการรวบรวมข้อมูลหลักสามประเภท โดยแต่ละประเภทได้รับการปรับให้เหมาะสมกับกรณีการใช้งานที่แตกต่างกัน

ชุด สั่ง คุณค่าที่เป็นเอกลักษณ์ ตามคีย์
แถว มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่ ไม่
ชุด ไม่ มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่
พจนานุกรม ไม่ กุญแจที่ไม่ซ้ำกัน มี (ใบกำกับภาษีเต็มรูปแบบ)

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

31) การเขียนโปรแกรมเชิงโปรโตคอลคืออะไรใน Swiftและเหตุใดจึงนิยมใช้มากกว่าการสืบทอดทางกรรมพันธุ์?

การเขียนโปรแกรมเชิงโปรโตคอล (Protocol-Oriented Programming หรือ POP) เป็นปรัชญาการออกแบบหลักใน Swift ซึ่งเน้นการกำหนดพฤติกรรมโดยใช้โปรโตคอลแทนที่จะพึ่งพาการสืบทอดคลาสอย่างมาก ใน POP โปรโตคอลจะกำหนดว่าประเภทหนึ่งๆ สามารถทำอะไรได้บ้าง และส่วนขยายของโปรโตคอลจะให้การใช้งานเริ่มต้น แนวทางนี้ช่วยหลีกเลี่ยงปัญหาหลายอย่างที่เกี่ยวข้องกับลำดับชั้นการสืบทอดที่ลึก เช่น การเชื่อมโยงที่แน่นหนาและคลาสพื้นฐานที่เปราะบาง

POP ทำงานร่วมกับ struct, enum และ class ทำให้มีความยืดหยุ่นมากกว่าการสืบทอดแบบเชิงวัตถุ นอกจากนี้ยังส่งเสริมการประกอบมากกว่าการสืบทอด ซึ่งช่วยปรับปรุงความสามารถในการทดสอบและการขยายขนาด

ตัวอย่าง: Swiftประเภทไลบรารีมาตรฐานของ เช่น Array และ Dictionary พึ่งพาโปรโตคอลต่างๆ อย่างมาก เช่น Sequence และ Collectionซึ่งแสดงให้เห็นว่า POP ช่วยให้สามารถนำพฤติกรรมที่นำกลับมาใช้ซ้ำได้และมีความสม่ำเสมอในประเภทที่ไม่เกี่ยวข้องกันได้อย่างไร

32) อธิบายความแตกต่างระหว่างรูปแบบการมอบหมายงาน (delegation) และรูปแบบการแจ้งเตือน (notification) ใน iOS โดยใช้ตัวอย่าง Swift.

การมอบหมายอำนาจและการแจ้งเตือนเป็นรูปแบบการสื่อสารทั่วไปสองแบบในการพัฒนา iOS การมอบหมายอำนาจเป็นการสร้าง... หนึ่งต่อหนึ่ง ความสัมพันธ์ที่วัตถุหนึ่งสื่อสารกลับไปยังอีกวัตถุหนึ่งผ่านโปรโตคอล การแจ้งเตือนจะตามมา อย่างใดอย่างหนึ่งต่อหลายคน รูปแบบที่ผู้สังเกตการณ์หลายคนสามารถรับฟังเหตุการณ์ต่างๆ ได้

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

การมอบหมายสิทธิ์เหมาะสำหรับการจัดการปฏิสัมพันธ์ของผู้ใช้ ในขณะที่การแจ้งเตือนเหมาะกว่าสำหรับการเผยแพร่การเปลี่ยนแปลงทั่วทั้งระบบ เช่น ลักษณะของแป้นพิมพ์

33) เฟรมและขอบเขตต่างกันอย่างไรใน Swift การพัฒนา UI?

frame และ bounds กำหนดขนาดและตำแหน่งของมุมมอง แต่ในระบบพิกัดที่แตกต่างกัน frame สัมพันธ์กับมุมมองหลัก ในขณะที่ bounds ขึ้นอยู่กับมุมมองนั้นๆ

อสังหาริมทรัพย์ กรอบ ขอบเขต
ระบบพิกัด มุมมองของผู้ปกครอง ความคิดเห็นส่วนตัว
ตำแหน่งดังกล่าวรวมถึง มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่
ได้รับผลกระทบจากการแปลง มี (ใบกำกับภาษีเต็มรูปแบบ) ไม่

การเข้าใจความแตกต่างนี้มีความสำคัญอย่างยิ่งเมื่อทำการสร้างแอนิเมชั่น การแปลงรูปทรง หรือการวาดภาพแบบกำหนดเอง

34) ฟังก์ชัน Auto Layout ทำงานอย่างไรใน Swiftแล้วข้อจำกัดคืออะไร?

Auto Layout คือระบบจัดวางเลย์เอาต์ที่คำนวณขนาดและตำแหน่งขององค์ประกอบต่างๆ บนหน้าจอโดยอัตโนมัติตามข้อจำกัด ข้อจำกัดเหล่านี้กำหนดความสัมพันธ์ต่างๆ เช่น ระยะห่าง การจัดแนว และอัตราส่วนขนาดระหว่างองค์ประกอบ UI

ฟังก์ชัน Auto Layout จะปรับเลย์เอาต์ให้เข้ากับขนาดหน้าจอ การวางแนว และการตั้งค่าการเข้าถึงที่แตกต่างกัน สามารถกำหนดข้อจำกัดได้โดยใช้ Interface Builder, ตัวยึด หรือโดยการเขียนโปรแกรม

ตัวอย่าง:

view.leadingAnchor.constraint(equalTo: parent.leadingAnchor).isActive = true

Auto Layout ช่วยให้การออกแบบ UI ตอบสนองและปรับเปลี่ยนได้ตามต้องการ ซึ่งเป็นสิ่งสำคัญสำหรับแอป iOS ในยุคปัจจุบัน

35) ข้อจำกัดของเจเนริกคืออะไรใน Swiftโปรดตอบพร้อมยกตัวอย่างประกอบ

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

ตัวอย่าง:

func printValues<T: Comparable>(_ a: T, _ b: T) {
    print(max(a, b))
}

ข้อจำกัดทั่วไปมีความสำคัญอย่างยิ่งต่อการเขียนโครงสร้างข้อมูลแบบนามธรรมที่สามารถนำกลับมาใช้ซ้ำได้แต่ยังคงควบคุมได้tracข้อกำหนดเหล่านี้ช่วยให้นักพัฒนาสามารถบังคับใช้ข้อกำหนดด้านพฤติกรรมได้ ในขณะเดียวกันก็รักษาความยืดหยุ่นไว้ได้

36) อธิบายความแตกต่างระหว่างสำเนา, แข็งแกร่ง และอ่อนแอ Swift การจัดการหน่วยความจำ

คำหลักเหล่านี้กำหนดวิธีการจัดการข้อมูลอ้างอิงภายใต้ ARC

อ้างอิง รักษาจำนวน ใช้กรณี
แข็งแรง เพิ่มขึ้น กรรมสิทธิ์เริ่มต้น
อ่อนแอ ไม่เพิ่มขึ้น หลีกเลี่ยงวงจรการคงสภาพ
สำเนา สร้างใหม่ การแยกคุณค่า

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

37) Method swizzling คืออะไรใน Swiftแล้วเมื่อใดควรหลีกเลี่ยง?

Method swizzling เป็นเทคนิคที่ทำงานในขณะรันไทม์ ซึ่งเปลี่ยนแปลงการใช้งานของเมธอดที่มีอยู่แล้ว แม้ว่าจะมีประสิทธิภาพ แต่ก็อันตรายและไม่แนะนำให้ใช้ Swift เนื่องจากเป็นการข้ามขั้นตอนการตรวจสอบความปลอดภัยในขั้นตอนการคอมไพล์

การใช้วิธี Swizzling อาจนำไปสู่พฤติกรรมที่ไม่คาดคิด ทำให้การอัปเดตระบบหยุดชะงัก และทำให้การแก้ไขข้อผิดพลาดซับซ้อนขึ้น ควรใช้เฉพาะในสถานการณ์ที่ควบคุมได้ เช่น ในเฟรมเวิร์กสำหรับการวิเคราะห์หรือการแก้ไขข้อผิดพลาดเท่านั้น

Swiftการเน้นย้ำเรื่องความปลอดภัยและการควบคุมทิศทางอย่างคงที่ ทำให้การสลับทิศทางเป็นทางเลือกสุดท้าย

38) เป็นยังไงบ้าง Swift จัดการกับความปลอดภัยของเธรดและการแข่งขันข้อมูลได้อย่างไร?

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

ตัวอย่าง:

actor Counter {
    var value = 0
    func increment() {
        value += 1
    }
}

Actor ช่วยลดความซับซ้อนของความปลอดภัยในการทำงานแบบมัลติเธรดและลดโอกาสการเกิด Data Race ทำให้การเขียนโปรแกรมแบบขนานมีความปลอดภัยและเข้าถึงได้ง่ายขึ้น

39) อะไรคือความแตกต่างระหว่าง @escaping และไม่ใช่การหนีping การปิดใน Swift?

การปิดประตูไม่ใช่ทางขึ้นลงบันไดping โดยค่าเริ่มต้น หมายความว่าคำสั่งเหล่านั้นจะถูกดำเนินการภายในขอบเขตของฟังก์ชัน Escaping closures จะมีอายุยืนยาวกว่าการเรียกใช้ฟังก์ชัน และต้องระบุอย่างชัดเจนด้วย @escaping.

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

ทำความเข้าใจเกี่ยวกับการหลบหนีping การปิดตัวแปรมีความสำคัญอย่างยิ่งต่อการจัดการหน่วยความจำและการหลีกเลี่ยงวงจรการเก็บรักษาข้อมูล

40) ข้อดีและข้อเสียของการใช้มีอะไรบ้าง SwiftUI เมื่อเทียบกับ UIKit?

SwiftUI เป็นเฟรมเวิร์ก UI แบบประกาศ (declarative) ที่ Apple นำเสนอ ในขณะที่ UIKit เป็นแบบคำสั่ง (imperative)

Swiftข้อดีของ UI Swiftข้อเสียของ UI
Less ต้นแบบ การสนับสนุนย้อนหลังที่จำกัด
การแสดงตัวอย่างสด Less เป็นผู้ใหญ่
ไวยากรณ์เชิงประกาศ มีจุดเชื่อมต่อการปรับแต่งน้อยลง

SwiftUI ช่วยเร่งการพัฒนา แต่ UIKit ยังคงจำเป็นสำหรับแอปพลิเคชันที่ซับซ้อนหรือแอปพลิเคชันรุ่นเก่า แอปพลิเคชันในเวอร์ชันใช้งานจริงจำนวนมากใช้วิธีการแบบผสมผสาน

🔍 ด้านบน Swift คำถามสัมภาษณ์พร้อมสถานการณ์จริงและคำตอบเชิงกลยุทธ์

1) คุณลักษณะสำคัญของมีอะไรบ้าง Swift อะไรคือสิ่งที่ทำให้มันแตกต่างจาก Objective-C?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการประเมินความเข้าใจของคุณ Swift หลักการพื้นฐานและเหตุผลที่วิธีการนี้เป็นที่นิยมสำหรับการพัฒนา iOS ในยุคปัจจุบัน

ตัวอย่างคำตอบ: Swift ภาษา Objective-C นำเสนอความปลอดภัยของชนิดข้อมูลที่แข็งแกร่ง ตัวเลือกเสริมเพื่อป้องกันข้อผิดพลาดการอ้างอิงค่าว่าง การจัดการหน่วยความจำอัตโนมัติผ่าน ARC และความสามารถในการอ่านที่ดียิ่งขึ้นด้วยไวยากรณ์ที่สะอาดตา นอกจากนี้ยังมอบคุณสมบัติที่ทรงพลัง เช่น ชนิดค่า การเขียนโปรแกรมเชิงโปรโตคอล และการจับคู่รูปแบบ ซึ่งทำให้แอปพลิเคชันปลอดภัยและบำรุงรักษาง่ายกว่าเมื่อเทียบกับ Objective-C

2) คุณช่วยอธิบายความแตกต่างระหว่างประเภทค่า (Value types) และประเภทอ้างอิง (Reference types) ได้ไหม Swift?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์กำลังทดสอบความเข้าใจของคุณเกี่ยวกับการจัดการหน่วยความจำและพฤติกรรมของข้อมูล Swift.

ตัวอย่างคำตอบ: ประเภทข้อมูลแบบค่า เช่น struct และ enum จะถูกคัดลอกเมื่อมีการกำหนดค่าหรือส่งผ่าน ทำให้มั่นใจได้ถึงการแยกข้อมูล ส่วนประเภทข้อมูลแบบอ้างอิง เช่น คลาส จะใช้การอ้างอิงหน่วยความจำร่วมกัน หมายความว่าการเปลี่ยนแปลงในที่ใดที่หนึ่งจะส่งผลกระทบต่อการอ้างอิงทั้งหมด การเลือกใช้ระหว่างสองประเภทนี้ขึ้นอยู่กับว่าต้องการสถานะที่เปลี่ยนแปลงได้ร่วมกันหรือไม่

3) ตัวเลือกเสริมทำงานอย่างไรใน Swiftและทำไมมันจึงสำคัญ?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการทราบว่าคุณจัดการกับค่าว่าง (nil) อย่างปลอดภัยและหลีกเลี่ยงข้อผิดพลาดขณะรันโปรแกรมได้อย่างไร

ตัวอย่างคำตอบ: ตัวแปร Optional แสดงถึงการมีอยู่หรือไม่มีอยู่ของค่า มีความสำคัญเพราะบังคับให้นักพัฒนาต้องจัดการกับกรณีค่าว่าง (nil) อย่างชัดเจนโดยใช้ Optional Binding, Optional Chaining หรือ Guard Statement การออกแบบนี้ช่วยลดการเกิดข้อผิดพลาดที่ไม่คาดคิดและเพิ่มเสถียรภาพของแอปพลิเคชันได้อย่างมาก

4) อธิบายสถานการณ์ที่คุณใช้การเขียนโปรแกรมเชิงโปรโตคอลใน Swift.

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการดูว่าคุณนำทักษะขั้นสูงไปประยุกต์ใช้อย่างไร Swift แนวคิดต่างๆ ในโครงการจริง

ตัวอย่างคำตอบ: ในบทบาทก่อนหน้านี้ ผมใช้การเขียนโปรแกรมเชิงโปรโตคอลเพื่อกำหนดพฤติกรรมร่วมกันในวิวโมเดลหลายๆ ตัว โดยการใช้โปรโตคอลที่มีการใช้งานเริ่มต้น ผมลดการทำซ้ำโค้ดและปรับปรุงความสามารถในการทดสอบ ในขณะเดียวกันก็รักษา...ping ส่วนประกอบต่างๆ เชื่อมต่อกันอย่างหลวมๆ

5) คุณจัดการหน่วยความจำอย่างมีประสิทธิภาพอย่างไรใน Swift แอพพลิเคชั่น?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์กำลังประเมินความเข้าใจของคุณเกี่ยวกับ ARC และข้อควรพิจารณาด้านผลการปฏิบัติงาน

ตัวอย่างคำตอบ: ในตำแหน่งงานก่อนหน้านี้ ฉันจัดการหน่วยความจำโดยใช้การอ้างอิงแบบอ่อนและแบบไม่เป็นเจ้าของอย่างระมัดระวัง เพื่อหลีกเลี่ยงวงจรการอ้างอิง โดยเฉพาะอย่างยิ่งในรูปแบบการปิดและตัวแทน นอกจากนี้ ฉันยังใช้เครื่องมือ Instruments เพื่อระบุการรั่วไหลของหน่วยความจำ และตรวจสอบให้แน่ใจว่าตัวควบคุมมุมมองได้รับการปลดปล่อยอย่างถูกต้อง

6) คุณจัดการกับการดำเนินการแบบอะซิงโครนัสอย่างไรใน Swift?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการทราบว่าคุณจัดการกับการทำงานพร้อมกันและการตอบสนองในแอปพลิเคชันอย่างไร

ตัวอย่างคำตอบ: ฉันจัดการการทำงานแบบอะซิงโครนัสโดยใช้ Grand Central Dispatch และ Swift คุณสมบัติการทำงานพร้อมกัน เช่น async และ await เครื่องมือเหล่านี้ช่วยให้ฉันสามารถรักษาการตอบสนองของส่วนติดต่อผู้ใช้ในขณะที่ดำเนินการงานเบื้องหลัง เช่น การเรียกใช้เครือข่ายหรือการประมวลผลข้อมูล

7) อธิบายข้อผิดพลาดที่ท้าทายที่คุณพบเจอในระหว่างการใช้งานโปรแกรม Swift โครงการและวิธีการแก้ไขปัญหาของคุณ

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์กำลังประเมินวิธีการแก้ปัญหาและทักษะการแก้ไขข้อผิดพลาดของคุณ

ตัวอย่างคำตอบ: ในงานก่อนหน้านี้ ผมเจอปัญหาโปรแกรมล่มเพราะใช้ force-unwrapping เกิดข้อผิดพลาดที่ไม่จำเป็นระหว่างการตอบสนองของเครือข่าย ผมแก้ไขปัญหานี้โดยการเพิ่มการผูกค่าที่ไม่จำเป็นอย่างเหมาะสมและเพิ่มการตรวจสอบเชิงป้องกัน ซึ่งช่วยขจัดปัญหาการหยุดทำงานและปรับปรุงการจัดการข้อผิดพลาดทั่วทั้งโมดูล

8) คุณมั่นใจได้อย่างไรว่าโค้ดมีคุณภาพและสามารถบำรุงรักษาได้ง่าย Swift โครงการ?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการทราบถึงระเบียบวินัยในการพัฒนาบุคลากรและแนวทางการทำงานเป็นทีมของคุณ

ตัวอย่างคำตอบ: ฉันรับประกันคุณภาพของโค้ดโดยปฏิบัติตามวิธีต่อไปนี้ Swift ฉันใช้แนวทางการเขียนโค้ดแบบกำหนดรูปแบบ การเขียนโค้ดแบบแยกส่วน และการใช้หลักการตั้งชื่อที่มีความหมาย นอกจากนี้ ฉันยังใช้การตรวจสอบโค้ด การทดสอบหน่วย และเอกสารประกอบ เพื่อให้แน่ใจว่าโค้ดเบสยังคงสามารถบำรุงรักษาและเข้าใจได้สำหรับทุกคนในทีม

9) คุณจะจัดการกับสถานการณ์ที่ต้องส่งมอบฟีเจอร์อย่างรวดเร็ว แต่ข้อกำหนดไม่ชัดเจนอย่างไร?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการประเมินทักษะการสื่อสารและการตัดสินใจของคุณภายใต้ความกดดัน

ตัวอย่างคำตอบ: ฉันจะเริ่มต้นด้วยการชี้แจงข้อกำหนดหลักกับผู้มีส่วนได้ส่วนเสียและระบุฟังก์ชันการทำงานขั้นต่ำที่ใช้งานได้จริง จากนั้นฉันจะสื่อสารข้อสมมติฐานอย่างชัดเจน พัฒนาฟีเจอร์ทีละขั้นตอน และมีความยืดหยุ่นเพื่อนำข้อเสนอแนะมาปรับใช้ในขณะที่ยังคงรักษาเวลาส่งงานให้ตรงตามกำหนด

10) อะไรเป็นแรงบันดาลใจให้คุณทำงานกับ Swift แล้วการพัฒนา iOS ล่ะ?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการเข้าใจถึงความมุ่งมั่นและความสนใจในระยะยาวของคุณที่มีต่อเทคโนโลยีนี้

ตัวอย่างคำตอบ: ในบทบาทล่าสุดของฉัน ฉันได้รับแรงบันดาลใจจาก... Swiftผมให้ความสำคัญกับความปลอดภัย ประสิทธิภาพ และการออกแบบภาษาโปรแกรมที่ทันสมัย ​​การสร้างแอปพลิเคชันที่ส่งผลกระทบโดยตรงต่อผู้ใช้ ในขณะที่ทำงานร่วมกับระบบนิเวศที่เปลี่ยนแปลงอยู่ตลอดเวลา ทำให้ผมรู้สึกมีส่วนร่วมและกระตือรือร้นที่จะเติบโตในฐานะนักพัฒนาซอฟต์แวร์

สรุปโพสต์นี้ด้วย: