miden16 10 มิถุนายน 2557 เวลา 13:06 น
ภาษาโปรแกรมสวิฟท์ เวอร์ชั่นรัสเซีย
- การพัฒนาสำหรับ iOS,
- สวิฟท์
สวัสดีฮับ! วันที่ 2 มิถุนายน เราทุกคนได้เห็นด้วยตาตนเองว่าบริษัทเป็นอย่างไร แอปเปิ้ลเริ่มแล้วสร้างการปฏิวัติในค่ายนักพัฒนา Objective-C โดยการแนะนำโลกให้รู้จักกับภาษาการเขียนโปรแกรมใหม่ของพวกเขา - Swift ในเวลาเดียวกัน เธอได้เผยแพร่เอกสารเล็กๆ น้อยๆ เกี่ยวกับภาษานั้นต่อสาธารณะ ซึ่งเราตัดสินใจแปลหากมีความต้องการ เราขอนำเสนอการแปลบทแรกแก่คุณ หากหัวข้อน่าสนใจเราจะเผยแพร่คำแปลต่อไปทุกสัปดาห์
คู่มือภาษา
พื้นฐาน
ตัวดำเนินการขั้นพื้นฐาน
สตริงและอักขระ
ประเภทคอลเลกชัน
ควบคุมการไหล
ฟังก์ชั่น
การปิด
การแจงนับ
ชั้นเรียนและโครงสร้าง
คุณสมบัติ
วิธีการ
ตัวติดตาม
มรดก
การเริ่มต้น
การยกเลิกการกำหนดค่าเริ่มต้น
การนับการอ้างอิงอัตโนมัติ
การผูกมัดเสริม
ประเภทการหล่อ
ประเภทที่ซ้อนกัน
ส่วนขยาย
โปรโตคอล
ยาสามัญ
ตัวดำเนินการขั้นสูง
การอ้างอิงภาษา
เกี่ยวกับการอ้างอิงภาษา
โครงสร้างคำศัพท์
ประเภท
นิพจน์
งบ
คำประกาศ
คุณสมบัติ
รูปแบบ
พารามิเตอร์และอาร์กิวเมนต์ทั่วไป
สรุปไวยากรณ์
เครื่องหมายการค้า
ยินดีต้อนรับสู่สวิฟท์
เกี่ยวกับภาษาสวิฟท์
Swift เป็นภาษาการเขียนโปรแกรมใหม่สำหรับการพัฒนาแอพพลิเคชั่น iOS และ OS X ที่รวมส่วนที่ดีที่สุดของ C และ Objective-C เข้าด้วยกัน แต่ไม่มีข้อจำกัดใดๆ ที่กำหนดไว้เพื่อความเข้ากันได้กับ C Swift ใช้รูปแบบการเขียนโปรแกรมที่ปลอดภัยและเพิ่มคุณสมบัติสมัยใหม่ที่ทำให้การสร้าง แอปพลิเคชันในกระบวนการที่เรียบง่าย ยืดหยุ่นยิ่งขึ้น และสนุกสนานยิ่งขึ้น Swift ที่สร้างโดยเราด้วย กระดานชนวนที่สะอาดเป็นโอกาสในการจินตนาการถึงวิธีการพัฒนาแอปพลิเคชันใหม่Swift ได้รับการพัฒนามาหลายปีแล้ว พื้นฐานของภาษาการเขียนโปรแกรมใหม่คือคอมไพเลอร์ ดีบักเกอร์ และเฟรมเวิร์กที่มีอยู่ เราได้ทำให้การจัดการหน่วยความจำง่ายขึ้นด้วยการนับการอ้างอิงอัตโนมัติ (ARC) กรอบงานของเรายังได้รับการปรับปรุงให้ทันสมัยครั้งใหญ่อีกด้วย Objective-C เริ่มรองรับบล็อก ตัวอักษร และโมดูล - ทั้งหมดนี้สร้างเงื่อนไขที่เอื้ออำนวยสำหรับการนำเทคโนโลยีสมัยใหม่มาใช้ เป็นงานเตรียมการที่ทำหน้าที่เป็นรากฐานสำหรับภาษาการเขียนโปรแกรมใหม่ที่จะใช้ในการพัฒนาผลิตภัณฑ์ซอฟต์แวร์ในอนาคตสำหรับ Apple
นักพัฒนา Objective-C จะพบว่า Swift คุ้นเคย เป็นการรวมความสามารถในการอ่านของพารามิเตอร์ที่มีชื่อเข้ากับพลังของไดนามิก แบบจำลองวัตถุวัตถุประสงค์-C มันเปิดเฟรมเวิร์ก Cocoa ที่มีอยู่และเข้ากันได้กับโค้ดที่เขียนใน Objective-C ภาษานี้สร้างขึ้นบนพื้นฐานทั่วไปนี้ โดยนำเสนอคุณสมบัติใหม่ๆ มากมาย และรวมลักษณะขั้นตอนและเชิงวัตถุของภาษาการเขียนโปรแกรมเข้าด้วยกัน
Swift จะไม่ทำให้โปรแกรมเมอร์มือใหม่กลัวเช่นกัน นี่เป็นครั้งแรก ภาษาที่ทรงพลังการเขียนโปรแกรมที่ชัดเจนและสนุกสนานเหมือนกับภาษาสคริปต์ รองรับสิ่งที่เรียกว่า Playground ซึ่งช่วยให้โปรแกรมเมอร์ทดลองโค้ดและเห็นผลแบบเรียลไทม์ โดยไม่ต้องคอมไพล์และรันแอปพลิเคชัน
Swift ผสมผสานภาษาสมัยใหม่ที่ดีที่สุดเข้าด้วยกัน และได้รับการพัฒนาโดยใช้ประสบการณ์ที่กว้างขวาง แอปเปิล- คอมไพเลอร์ของเรามีความหมายเหมือนกันกับประสิทธิภาพ และภาษาของเราได้รับการปรับให้เหมาะสมสำหรับการพัฒนาโดยไม่คำนึงถึงการประนีประนอม ได้รับการออกแบบในลักษณะที่คุณสามารถพัฒนาแอปพลิเคชัน “hello, world!” แอปพลิเคชันแรกของคุณ หรือแม้แต่ระบบปฏิบัติการทั้งหมดได้อย่างง่ายดาย ทั้งหมดนี้ทำให้ Swift กลายเป็นเครื่องมือสำคัญสำหรับนักพัฒนาและสำหรับ Apple เอง
Swift เป็นวิธีใหม่ที่ยอดเยี่ยมในการสร้างแอพสำหรับ iOS และ OS X และเราจะพัฒนามันต่อไปด้วยสิ่งอื่นๆ เพิ่มเติม ฟังก์ชั่นใหม่และนำเสนอโอกาสใหม่ๆ เป้าหมายของเราคือความทะเยอทะยาน และเราแทบอดใจรอไม่ไหวที่จะเห็นว่าคุณสร้างสรรค์อะไรได้บ้าง
ข้อมูลเบื้องต้นเกี่ยวกับสวิฟท์
ตามธรรมเนียมที่มีมายาวนาน โปรแกรมแรกในภาษาใหม่ควรแสดงคำว่า "Hello, world" บนหน้าจอ ด้วย Swift มันทำได้ดังนี้:Println("สวัสดีชาวโลก")
หากคุณเคยพัฒนาใน C หรือ Objective-C ไวยากรณ์นี้น่าจะฟังดูคุ้นตาสำหรับคุณ - ใน Swift โค้ดบรรทัดนี้ถือเป็นโปรแกรมที่สมบูรณ์ คุณไม่จำเป็นต้องนำเข้าไลบรารีแยกต่างหากเพื่อมอบฟังก์ชันการทำงานพื้นฐาน เช่น คอนโซล I/O หรือการจัดการสตริงอีกต่อไป รหัสที่เขียนในขอบเขตสากลจึงเป็นจุดเริ่มต้นของโปรแกรมดังนั้น ฟังก์ชั่นหลักไม่จำเป็นอีกต่อไป โปรดทราบว่าไม่มีเครื่องหมายอัฒภาคที่ท้ายแต่ละบรรทัด
บทนำนี้มีข้อมูลที่เพียงพอในการเริ่มต้นเขียนโค้ดใน Swift ไม่ต้องกังวลหากคุณไม่เข้าใจอะไรบางอย่าง เราจะอธิบายทุกอย่างอย่างละเอียดในบทต่อๆ ไป
ความคิดเห็น
เพื่อความเข้าใจที่ดีขึ้นเกี่ยวกับเนื้อหา เราขอแนะนำให้ใช้โหมด Playground ใน Xcode Playground ช่วยให้คุณเห็นผลลัพธ์ทันทีที่คุณแก้ไขโค้ด โดยไม่ต้องคอมไพล์และรันแอปพลิเคชัน
ชนิดข้อมูลอย่างง่าย
ใช้ Let เพื่อสร้างค่าคงที่ และใช้ var เพื่อสร้างตัวแปร ไม่จำเป็นต้องระบุประเภทของค่าคงที่ คุณสามารถกำหนดค่าได้เพียงครั้งเดียวตัวแปร myVariable = 42 myVariable = 50 ให้ myConstant = 42
ประเภทของค่าคงที่และตัวแปรจะต้องตรงกับประเภทของค่าที่สอดคล้องกันที่กำหนดให้กับพวกเขา อย่างไรก็ตาม นี่ไม่ได้หมายความว่าคุณจะต้องระบุประเภทโดยตรง คอมไพลเลอร์จะกำหนดประเภทของค่าคงที่และตัวแปรโดยอัตโนมัติเมื่อกำหนดค่าให้กับสิ่งเหล่านั้น ดังนั้น ในตัวอย่างที่ให้มา คอมไพลเลอร์จะพิจารณาว่า myVariable มี ประเภทจำนวนเต็ม.
หากตัวเริ่มต้นหายไปหรือให้ข้อมูลไม่เพียงพอ คุณสามารถระบุประเภทด้วยตนเองหลังตัวแปร โดยแยกชื่อและประเภทด้วยเครื่องหมายโคลอน:
ให้ implicitInteger = 70 ให้ inplicitDouble = 70.0 ให้ inplicitDouble: Double = 70
มาทดลองกัน
สร้างค่าคงที่ด้วย ประเภทลูกลอยและขึ้นต้นด้วยหมายเลข 4
ค่าจะไม่ถูกแปลงเป็นประเภทอื่นโดยปริยาย หากคุณต้องการแปลงค่าเป็นประเภทอื่น ให้ทำอย่างชัดเจน:
ให้ label = "ความกว้างคือ" ให้ width = 94 ให้ widthLabel = label + String(width)
มาทดลองกัน
ลองลบการแปลงที่ชัดเจนเป็น String ในบรรทัดสุดท้าย คุณจะได้รับข้อผิดพลาดอะไร?
วิธีที่ง่ายกว่าในการรวมค่าในสตริงคือการใส่นิพจน์ไว้ในวงเล็บและนำหน้าด้วยแบ็กสแลช (\) ตัวอย่าง:
ให้แอปเปิ้ล = 3 ให้ส้ม = 5 ให้แอปเปิ้ลสรุป = "ฉันมี \(แอปเปิ้ล) แอปเปิ้ล" ให้ผลไม้สรุป = "ฉันมี \(แอปเปิ้ล + ส้ม) ผลไม้"
มาทดลองกัน
ลองใช้โครงสร้าง \() และพิมพ์สตริงรวมทั้งผลลัพธ์ของผลรวมของตัวแปรจำนวนเต็มสองตัวและชื่อของบุคคล
เมื่อทำงานกับอาร์เรย์และอาร์เรย์ที่เชื่อมโยง (พจนานุกรม) จะใช้วงเล็บเหลี่ยม ():
Var shoppingList = ["ปลาดุก", "น้ำ", "ทิวลิป", "สีฟ้า"] shoppingList = "ขวดน้ำ" var อาชีพ = [ "Malcolm": "กัปตัน", "Kaylee": "ช่างเครื่อง", ] อาชีพ ["เจย์น"] = "ประชาสัมพันธ์"
หากต้องการสร้างอาร์เรย์หรือพจนานุกรมว่าง ให้ใช้ไวยากรณ์ต่อไปนี้:
ให้ EmptyArray = String() ให้ EmptyDictionary = พจนานุกรม
หากต้องการสร้างอาร์เรย์และพจนานุกรมว่าง ให้ใช้และ [:] ตามลำดับ ตัวอย่างเช่น เมื่อคุณกำหนดค่าใหม่ให้กับตัวแปรหรือส่งอาร์กิวเมนต์ไปยังฟังก์ชัน
ShoppingList = // ไปช้อปปิ้งและซื้อทุกอย่าง
เงื่อนไขและรอบ
คำสั่ง If และ switch ถูกใช้เพื่อสร้างเงื่อนไข และใช้คำสั่ง for-in, for, while และ do- While เพื่อสร้างลูป ในกรณีนี้ ไม่จำเป็นต้องเน้นเงื่อนไขและเริ่มต้นนิพจน์ด้วยวงเล็บ ในขณะที่ต้องใช้เครื่องหมายปีกกาให้ IndividualScores = var teamScore = 0 สำหรับคะแนนใน IndividualScores ( ถ้าคะแนน > 50 ( teamScore += 3 ) else ( teamScore += 1 ) ) teamScore
เงื่อนไขภายในคำสั่ง if ต้องเป็นบูลีน ซึ่งหมายความว่าคำสั่ง if Score (...) มีข้อผิดพลาดเนื่องจากไม่มีการเปรียบเทียบที่ชัดเจน (เช่น มีศูนย์)
คำสั่ง if สามารถใช้ร่วมกับ Let และ var เพื่อทำงานกับค่าคงที่และตัวแปรที่สามารถมีค่าเป็นศูนย์ได้ ค่าคงที่และตัวแปรดังกล่าวเรียกว่าทางเลือก (นั่นคือสามารถรับค่าใดก็ได้หรือเท่ากับศูนย์) หากต้องการสร้างตัวแปรเสริมหรือค่าคงที่ ให้เพิ่มเครื่องหมายคำถาม (?) หลังประเภท
มีตัวเลือกสตริงเสริม: สตริง? = "สวัสดี" ตัวเลือกสตริง == ไม่มีชื่อตัวเลือก: สตริง? = "John Appleseed" var ทักทาย = "สวัสดี!" ถ้าให้ชื่อ = ตัวเลือกชื่อ ( คำทักทาย = "สวัสดี \(ชื่อ)" )
มาทดลองกัน
เปลี่ยน optionName เป็น nil คุณเห็นอะไรบนหน้าจอ? เพิ่มบล็อก else เพื่อจัดการกรณีที่ optionName เป็น nil
หากค่าเผื่อเลือกคือ nil เงื่อนไขจะเป็นเท็จ และโค้ดในเครื่องหมายปีกกาหลัง if จะไม่ถูกดำเนินการ มิฉะนั้น ตัวแปรคำทักทายจะถูกกำหนดค่าใหม่
สวิตช์ตัวดำเนินการแบบหลายตัวเลือกรองรับตัวดำเนินการเปรียบเทียบอื่นๆ ภายในตัวมันเอง และไม่จำกัดเพียงการเปรียบเทียบง่ายๆ:
ให้ผัก = "พริกแดง" เปลี่ยนผัก ( กรณี "ขึ้นฉ่าย": ให้ผักComment = "ใส่ลูกเกดแล้วทำมดบนขอนไม้" กรณี "แตงกวา", "วอเตอร์เครส": ให้ผักความคิดเห็น = "นั่นจะทำแซนด์วิชชาที่ดี" ." case ให้ x โดยที่ x.hasSuffix("pepper"): ให้ผักComment = "เผ็ดมั้ย \(x)?" ค่าเริ่มต้น: ให้ผักComment = "ทุกอย่างรสชาติดีในซุป" )
มาทดลองกัน
ลองลบเงื่อนไขเริ่มต้นออก คุณจะได้รับข้อผิดพลาดอะไร?
หลังจากดำเนินการบล็อคโค้ดที่เหมาะสมแล้ว โปรแกรมจะออกจากคำสั่ง switch โดยไม่ตรวจสอบเงื่อนไขที่ตามมา ด้วยวิธีนี้คุณไม่จำเป็นต้องเพิ่มคำสั่งแบ่งที่ส่วนท้ายของแต่ละบล็อกเคสด้วยตนเอง
หากต้องการวนซ้ำองค์ประกอบของอาร์เรย์ที่เชื่อมโยง ให้ใช้คำสั่ง for-in พร้อมกับระบุชื่อคู่สำหรับคู่คีย์-ค่าแต่ละคู่
ให้ InterestingNumbers = [ "Prime": , "Fibonacci": , "Square": , ] var ที่ใหญ่ที่สุด = 0 สำหรับ (ชนิด, ตัวเลข) ใน InterestingNumbers ( สำหรับตัวเลขในตัวเลข ( ถ้าตัวเลข > ใหญ่ที่สุด ( ใหญ่ที่สุด = ตัวเลข ) ) ) ใหญ่ที่สุด
มาทดลองกัน
เพิ่มตัวแปรอื่นที่จะช่วยให้คุณค้นหาว่าจำนวนสูงสุดที่พบคือประเภทใดในสามประเภท
คำสั่ง while loop ช่วยให้คุณสามารถรันบล็อกของโค้ดที่อยู่ภายในได้จนกว่าเงื่อนไขจะประเมินเป็นเท็จ เงื่อนไขยังสามารถระบุได้หลังบล็อก ซึ่งในกรณีนี้จะดำเนินการตาม อย่างน้อยครั้งหนึ่ง.
Var n = 2 ในขณะที่ n< 100 {
n = n * 2
}
n
var m = 2
do {
m = m * 2
} while m < 100
m
คำสั่ง for สามารถใช้เพื่อวนซ้ำลำดับตัวเลขโดยใช้จุดสองจุด (..) หรือใช้ตัวเริ่มต้น เงื่อนไข และการเพิ่มขึ้น ดูสิ สองลูปนี้ทำสิ่งเดียวกัน:
Var firstForLoop = 0 สำหรับ i ใน 0..3 ( firstForLoop += i ) firstForLoop var SecondForLoop = 0 สำหรับ var i = 0; ฉัน< 3; ++i {
secondForLoop += 1
}
secondForLoop
เมื่อสร้างลูป ให้ใช้จุดสองจุด (..) หากคุณไม่ต้องการรวมค่าที่มากขึ้นในช่วง และใช้จุดสามจุด (...) เพื่อรวมทั้งค่าที่น้อยกว่าและค่าที่มากขึ้น
ฟังก์ชั่นและการปิด
เพื่อประกาศการใช้ฟังก์ชัน คำหลักฟังก์ชั่น ฟังก์ชันถูกเรียกโดยการระบุชื่อและรายการอาร์กิวเมนต์ในวงเล็บ ประเภทการส่งคืนควรแยกออกจากรายการอาร์กิวเมนต์อย่างเป็นทางการโดยใช้ ->Func ทักทาย(ชื่อ: สตริง วัน: สตริง) -> สตริง ( return "สวัสดี \(ชื่อ) วันนี้คือ \(วัน)." ) ทักทาย("Bob", "วันอังคาร")
มาทดลองกัน
ลบพารามิเตอร์วัน ให้เพิ่มตัวแปรที่ระบุชื่ออาหารที่เสิร์ฟเป็นอาหารกลางวันแทน
หากฟังก์ชันส่งคืนค่าหลายค่า คุณควรใช้สิ่งอันดับ:
Func getGasPrices() -> (Double, Double, Double) ( return (3.59, 3.69, 3.79) ) getGasPrices()
ฟังก์ชันยังสามารถมีจำนวนอาร์กิวเมนต์ไม่จำกัด:
Func sumOf(numbers: Int...) -> Int ( var sum = 0 สำหรับตัวเลขเป็นตัวเลข ( sum += number ) return sum ) sumOf() sumOf(42, 597, 12)
มาทดลองกัน
เขียนฟังก์ชันเพื่อหาค่าเฉลี่ยเลขคณิต หมายเลขใดก็ได้ข้อโต้แย้งของพวกเขา
ฟังก์ชั่นสามารถซ้อนกันภายในกันและกันได้ ฟังก์ชันที่ซ้อนกันสามารถเข้าถึงตัวแปรที่ประกาศไว้ในฟังก์ชันภายนอกได้ ใช้ฟังก์ชันที่ซ้อนกันเพื่อจัดระเบียบโค้ดของฟังก์ชันที่ซับซ้อนหรือขนาดใหญ่
Func returnFifteen() -> Int ( var y = 10 func เพิ่ม() ( y += 5 ) เพิ่ม() กลับ y ) returnFifteen()
ฟังก์ชันเป็นอ็อบเจ็กต์ของคลาสแรก (ประเภทเฟิร์สคลาส) กล่าวอีกนัยหนึ่ง ฟังก์ชันสามารถส่งคืนฟังก์ชันอื่นเป็นผลลัพธ์ได้
Func makeIncreaerer() -> (Int -> Int) ( func addOne(number: Int) -> Int ( return 1 + number ) return addOne ) var increase = makeIncreaperer() เพิ่มขึ้น(7)
ฟังก์ชันยังสามารถนำฟังก์ชันอื่นมาเป็นหนึ่งในอาร์กิวเมนต์ของมันได้ด้วย
Func hasAnyMatches(list: Int, Condition: Int -> Bool) -> Bool ( สำหรับรายการในรายการ ( if Condition(item) ( return true ) ) return false ) func lessThanTen(number: Int) -> Bool ( return number< 10
}
var numbers =
hasAnyMatches(numbers, lessThanTen)
ฟังก์ชั่นเป็นกรณีพิเศษของการปิด คุณสามารถสร้างการปิดโดยไม่ต้องระบุชื่อ และโดยการล้อมส่วนเนื้อหาของการปิดด้วยเครื่องหมายปีกกา (()) หากต้องการแยกอาร์กิวเมนต์และประเภทการส่งคืนออกจากเนื้อหาของการปิด ให้ใช้ตัวดำเนินการ in
Numbers.map(( (หมายเลข: Int) -> Int ในผลลัพธ์ให้ = 3 * ผลลัพธ์การส่งคืนตัวเลข ))
มาทดลองกัน
เขียนการปิดใหม่เพื่อให้ส่งกลับศูนย์สำหรับจำนวนพิเศษทั้งหมด
มีเทคนิคหลายประการในการทำให้การปิดเรื่องกระชับยิ่งขึ้น หากประเภทของการปิดเป็นที่รู้จักในเชิงนิรนัย (ตัวอย่างเช่น เป็นการเรียกกลับของผู้รับมอบสิทธิ์) คุณสามารถละเว้นการระบุประเภทของพารามิเตอร์และ/หรือประเภทของค่าที่ส่งคืนได้ การปิดที่ประกอบด้วยนิพจน์เดียวจะส่งกลับผลลัพธ์ของนิพจน์นั้นโดยปริยาย
Numbers.map(( หมายเลขใน 3 * หมายเลข ))
ในการปิด แทนที่จะระบุชื่อตัวแปร คุณสามารถใช้มันได้ หมายเลขซีเรียล– สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อเขียน ลัดวงจร- การปิดซึ่งเป็นอาร์กิวเมนต์สุดท้ายของฟังก์ชันสามารถส่งผ่านไปได้ทันทีหลังวงเล็บพร้อมรายการพารามิเตอร์ที่เหลือ
เรียงลำดับ() ($0 > $1 )
วัตถุและคลาส
เพื่อสร้างการใช้งานชั้นเรียน คำสงวนระดับ. สมาชิกของคลาสได้รับการประกาศในลักษณะเดียวกับค่าคงที่และตัวแปรปกติ นอกจากนี้ class method ยังถูกประกาศให้เป็นฟังก์ชันธรรมดาอีกด้วยรูปร่างของคลาส ( var numberOfSides = 0 func simpleDescription() ->
มาทดลองกัน
เพิ่มค่าคงที่สมาชิกของคลาสและวิธีการเรียนที่ใช้เป็นอาร์กิวเมนต์
หากต้องการสร้างอินสแตนซ์ (วัตถุ) ของคลาส เพียงเพิ่มวงเล็บหลังชื่อคลาส วิธีการและสมาชิกชั้นเรียนสามารถเข้าถึงได้ผ่านจุด
รูปร่าง Var = Shape() shape.numberOfSides = 7 var shapeDescription = shape.simpleDescription()
ในตัวอย่างนี้ เราพลาดรายละเอียดที่สำคัญอย่างหนึ่งไป นั่นคือตัวสร้างคลาส วิธีการ init
Class NamedShape ( var numberOfSides: Int = 0 var name: String init(name: String) ( self.name = name ) func simpleDescription() -> String ( return "รูปร่างที่มีด้าน \(numberOfSides)" ) )
โปรดสังเกตว่าสมาชิกคลาสชื่อถูกแยกออกจากอาร์กิวเมนต์ตัวสร้างชื่อด้วยตนเอง อาร์กิวเมนต์จะถูกส่งผ่านไปยัง Constructor ในวิธีปกติ เช่นเดียวกับวิธีคลาสอื่นๆ โปรดทราบว่าสมาชิกคลาสแต่ละคนจะต้องเริ่มต้นได้ ไม่ว่าจะเมื่อมีการประกาศ (เช่น numberOfSides) หรือในตัวสร้าง (เช่นชื่อ)
class destructor คือเมธอด deinit ซึ่งสามารถเขียนทับได้หากจำเป็น
เพื่อสืบทอดคลาสต่อจากนี้ ชั้นเรียนที่มีอยู่หลังจากระบุชื่อของคลาสย่อยแล้ว คุณควรใส่โคลอนและระบุชื่อของคลาสพาเรนต์ ใน Swift ไม่มีข้อจำกัดในการสืบทอดภาคบังคับของคลาสมาตรฐานใดๆ
เมธอดที่ถูกแทนที่โดยคลาสย่อยจะต้องทำเครื่องหมายด้วยคีย์เวิร์ด override - การแทนที่เมธอดที่ไม่มีการแทนที่จะส่งผลให้เกิดข้อผิดพลาด คอมไพลเลอร์ยังตรวจจับวิธีการที่ถูกทำเครื่องหมายว่าแทนที่ แต่ไม่ได้แทนที่วิธีการใด ๆ ของคลาสพาเรนต์
class Square: NamedShape ( var sideLength: Double init(sideLength: Double, name: String) ( self.sideLength = sideLength super.init(name: name) numberOfSides = 4 ) func area() -> Double ( return sideLength * sideLength ) แทนที่ func simpleDescription() -> String ( return "A square with months of length \(sideLength)." ) ) ให้ test = Square(sideLength: 5.2, name: "my test square") test.area() test.simpleDescription ()
มาทดลองกัน
สร้างคลาส Circle และสืบทอดจากคลาส NamedShape ตัวสร้างสำหรับคลาส Circle รับสองอาร์กิวเมนต์: รัศมีและชื่อ แทนที่พื้นที่และอธิบายวิธีการของคลาสนี้
สมาชิกชั้นเรียนยังสามารถมี getter และ setter ของตนเองได้
คลาส EquilateralTriangle: NamedShape ( var sideLength: Double = 0.0 init(sideLength: Double, name: String) ( self.sideLength = sideLength super.init(name: name) numberOfSides = 3 ) var perimeter: Double ( get ( return 3.0 * sideLength ) set ( sideLength = newValue / 3.0 ) ) แทนที่ func simpleDescription() -> String ( return "An equilateral triagle with months of length \(sideLength)." ) ) var Triangle = EquilateralTriangle(sideLength: 3.1, name: "a Triangle ") Triangle.perimeter Triangle.perimeter = 9.9 Triangle.SideLength
ในตัวตั้งค่าของตัวแปรขอบเขต ค่าใหม่ที่กำหนดจะเรียกว่า newValue โดยปริยาย คุณสามารถเปลี่ยนชื่อของตัวแปรนี้ได้โดยใส่ไว้ในวงเล็บทันทีหลัง set
สังเกตโครงสร้างตัวสร้างของคลาส EquilateralTriangle วิธีนี้มีสามขั้นตอนตามลำดับ:
- การเริ่มต้นสมาชิกของคลาสย่อย
- เรียกตัวสร้างของคลาสพาเรนต์
- การเปลี่ยนแปลงค่าของสมาชิกของคลาสผู้ปกครอง
Class TriangleAndSquare ( var Triangle: EquilateralTriangle ( willSet ( square.sideLength = newValue.sideLength ) ) var square: Square ( willSet ( Triangle.sideLength = newValue.sideLength ) ) init(ขนาด: Double, ชื่อ: String) ( square = Square( sideLength: ขนาด, ชื่อ: ชื่อ) Triangle = EquilateralTriangle(sideLength: ขนาด, ชื่อ: ชื่อ) ) var TriangleAndSquare = TriangleAndSquare(ขนาด: 10, ชื่อ: "รูปร่างทดสอบอื่น") TriangleAndSquare.square.sideLength TriangleAndSquare.triangle.sideLength TriangleAndSquare square = Square(sideLength: 50, ชื่อ: "สี่เหลี่ยมจัตุรัสที่ใหญ่กว่า") TriangleAndSquare.triangle.sideLength
วิธีการเรียนมีความแตกต่างที่สำคัญอย่างหนึ่งจากฟังก์ชัน ชื่อของอาร์กิวเมนต์ของฟังก์ชันจะใช้ภายในฟังก์ชันนั้นเท่านั้น ในขณะที่เมธอดคลาส พารามิเตอร์จะถูกใช้เมื่อเรียกใช้เมธอดนั้นด้วย (ยกเว้นพารามิเตอร์ตัวแรก) โดยค่าเริ่มต้น วิธีการเรียนมี ชื่อเดียวกันพารามิเตอร์ทั้งเมื่อถูกเรียกและภายใน อย่างไรก็ตาม คุณสามารถระบุชื่ออื่นได้ (ในตัวอย่างด้านล่าง - ครั้ง) ซึ่งจะใช้ในวิธีนี้เท่านั้น ในกรณีนี้ เมื่อต้องการเรียกเมธอดนี้ คุณต้องใช้ชื่อ (numberOfTimes)
ตัวนับคลาส ( จำนวนนับ: Int = 0 func increaseBy(จำนวน: Int, numberOfTimes ครั้ง: Int) (นับ += จำนวน * ครั้ง ) ) var counter = Counter() counter.increatBy(2, numberOfTimes: 7)
เมื่อทำงานกับค่าทางเลือก ให้เพิ่มเครื่องหมายคำถาม (?) ก่อนวิธีการ สมาชิกชั้นเรียน ฯลฯ หากค่าที่อยู่หน้าเครื่องหมายคำถามเป็นศูนย์ ทุกอย่างที่อยู่หลัง (?) จะถูกละเว้น และนิพจน์ทั้งหมดจะเป็นศูนย์ มิฉะนั้น นิพจน์จะได้รับการประเมินตามปกติ ในทั้งสองกรณี นิพจน์ทั้งหมดจะส่งผลให้เกิดค่าที่ไม่บังคับ
ให้ตัวเลือก Square: Square? = สี่เหลี่ยมจัตุรัส(sideLength: 2.5 ชื่อ: "สี่เหลี่ยมจัตุรัสเสริม") ให้ sideLength = optionSquare?.sideLength
การแจงนับและโครงสร้าง
คำสำคัญ enum ใช้เพื่อสร้างการแจงนับ โปรดทราบว่าการแจงนับอาจมีวิธีการด้วยอันดับ Enum: Int ( case Ace = 1 case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten case Jack, Queen, King func simpleDescription() -> String ( switch self ( case .Ace: return " ace" case .Jack: return "jack" case .Queen: return "queen" case .King: return "king" default: return String(self.toRaw()) ) ) ) ให้ ace = Rank.Ace ให้ aceRawValue = ace .toRaw()
มาทดลองกัน
เขียนฟังก์ชันที่เปรียบเทียบการแจงนับ 2 อันดับตามค่าของมัน
ในตัวอย่างข้างต้น องค์ประกอบ enum เริ่มต้นด้วยประเภทจำนวนเต็ม และคุณจะต้องระบุค่าขององค์ประกอบแรกเท่านั้น - ค่าขององค์ประกอบที่เหลือจะถูกกำหนดตามลำดับที่ปรากฏ คุณยังสามารถเลือกสตริงหรือประเภทจริงเป็นค่าดิบของค่าองค์ประกอบได้
หากต้องการแปลงประเภทค่าดั้งเดิมเป็นประเภทการแจงนับ ให้ใช้ฟังก์ชัน toRaw และ fromRaw
ถ้าให้ ConvertRank = Rank.fromRaw(3) ( ให้ threeDescription = ConvertRank.simpleDescription() )
โปรดทราบว่าค่าขององค์ประกอบการแจงนับนั้นเป็นค่าจริง และไม่ใช่แค่เพียงการแสดงค่าดั้งเดิมเท่านั้น โดยทั่วไป คุณไม่จำเป็นต้องระบุค่าดั้งเดิม
Enum Suit ( case Spades, Hearts, Diamonds, Clubs func simpleDescription() -> String ( switch self ( case .Spades: return "spades" case .Hearts: return "hearts" case .Diamonds: return "diamonds" case .Clubs: กลับ "สโมสร" ) ) ) ให้ hearts = Suit.Hearts ให้ heartsDescription = hearts.simpleDescription()
มาทดลองกัน
เพิ่มวิธีการ Color ที่ส่งคืนสตริง “สีดำ” สำหรับโพดำและดอกจิก และ “สีแดง” สำหรับหัวใจและเพชร
สังเกตว่ามีการเข้าถึงสมาชิกของ Hearts ของการแจงนับ Suit อย่างไร เมื่อกำหนดค่าให้กับค่าคงที่ hearts จะใช้ชื่อเต็ม Suit.Hearts เนื่องจากเราไม่ได้ระบุประเภทของค่าคงที่อย่างชัดเจน และในสวิตช์ เราใช้รูปแบบสั้น .หัวใจ เพราะประเภทของคุณค่าในตนเองเรียกว่านิรนัย คุณสามารถใช้รูปแบบสั้นได้ตลอดตราบใดที่ระบุประเภทของตัวแปรไว้อย่างชัดเจน
คีย์เวิร์ด struct ใช้เพื่อสร้างโครงสร้าง โครงสร้างมีความคล้ายคลึงกับคลาสหลายประการ รวมถึงเมธอดและคอนสตรัคเตอร์ ความแตกต่างที่สำคัญที่สุดประการหนึ่งระหว่างโครงสร้างและคลาสก็คือ อินสแตนซ์ของโครงสร้าง ซึ่งต่างจากอินสแตนซ์ของคลาส จะถูกส่งผ่านไปยังฟังก์ชันตามค่า (นั่นคือ สำเนาในเครื่องของพวกมันจะถูกสร้างขึ้นครั้งแรก) ในขณะที่อินสแตนซ์ของคลาสจะถูกส่งผ่านโดยการอ้างอิง
Struct Card ( var rank: Rank var suit: Suit func simpleDescription() -> String ( return "The \(rank.simpleDescription()) of \(suit.simpleDescription())" ) ) ให้ threeOfSpades = Card(rank: . สาม ชุด: .Spades) ให้ threeOfSpadesDescription = threeOfSpades.simpleDescription()
มาทดลองกัน
เพิ่มวิธีการให้กับโครงสร้างการ์ดที่สร้างสำรับไพ่แบบเต็ม
อินสแตนซ์สมาชิกแจงนับสามารถมีได้ ค่าลักษณะเฉพาะและอาจแตกต่างกันได้ คุณกำหนดค่าเหล่านี้เมื่อคุณสร้างอินสแตนซ์แจงนับ (ค่าคงที่ความสำเร็จในตัวอย่าง) ค่าที่ถูกผูกไว้และค่าดั้งเดิมนั้นต่างกัน: มูลค่าเดิมสมาชิกการแจงนับจะคงที่เสมอในทุกกรณีของการแจงนับ และจะถูกระบุเมื่อมีการประกาศ
ลองพิจารณาตัวอย่างการรับเวลาพระอาทิตย์ขึ้นและพระอาทิตย์ตกจากเซิร์ฟเวอร์ เซิร์ฟเวอร์ตอบสนองด้วยข้อมูลที่เกี่ยวข้องหรือข้อความแสดงข้อผิดพลาด
Enum ServerResponse ( case Result(String, String) case Error(String) ) ให้ความสำเร็จ = ServerResponse.Result("6:00 am", "20:09 pm") ให้ความล้มเหลว = ServerResponse.Error("Out of Cheese" ) สลับความสำเร็จ ( case la .Result(sunrise, Sunset): la serverResponse = "Sunrise is at \(sunrise) and Sunset is at \(sunset)." case la .Error(error): la serverResponse = "Failure.. .\(ข้อผิดพลาด)" )
มาทดลองกัน
เพิ่มตัวเลือกที่สามให้กับคำสั่งสวิตช์แบบหลายตัวเลือก
สังเกตว่าเวลาพระอาทิตย์ขึ้นและพระอาทิตย์ตกถูกดึงออกจากวัตถุ ServerResponse อย่างไร
โปรโตคอลและส่วนขยาย
หากต้องการประกาศโปรโตคอล ให้ใช้คีย์เวิร์ดโปรโตคอลตัวอย่างโปรโตคอลโปรโตคอล ( var simpleDescription: String ( get ) การกลายพันธุ์ func adjust() )
โปรโตคอลสามารถรองรับคลาส การแจงนับ และโครงสร้างได้
คลาส SimpleClass: ExampleProtocol ( var simpleDescription: String = "คลาสที่ง่ายมาก" var anotherProperty: Int = 69105 func adjust() ( simpleDescription += " ตอนนี้ปรับแล้ว 100%" ) ) var a = SimpleClass() a.adjust( ) ให้ aDescription = a.simpleDescription struct SimpleStructure: ExampleProtocol ( var simpleDescription: String = "A simple Structure" การกลายพันธุ์ func adjust() ( simpleDescription += " (adjusted)" ) ) var b = SimpleStructure() b.adjust() la bDescription = b.simpleDescription
มาทดลองกัน
สร้างแจงนับที่จะใช้โปรโตคอลนี้
สังเกตคีย์เวิร์ดที่กลายพันธุ์ในคำจำกัดความ SimpleStructure ซึ่งบอกคอมไพลเลอร์ว่าวิธีการที่เกี่ยวข้องกำลังแก้ไขโครงสร้าง ในทางตรงกันข้าม วิธีการของคลาส SimpleClass ไม่จำเป็นต้องถูกทำเครื่องหมายว่าเป็นการกลายพันธุ์ เนื่องจากวิธีการของคลาสสามารถเปลี่ยนได้ตลอดเวลาโดยไม่มีการรบกวน
เมื่อต้องการเพิ่มเมธอดใหม่หรือสมาชิกคลาสให้กับประเภทที่มีอยู่ คุณต้องใช้ส่วนขยาย คุณยังสามารถใช้ส่วนขยายเพื่อใช้งานโปรโตคอลได้แล้ว ประเภทที่มีอยู่แม้ว่าจะถูกนำเข้าจากไลบรารีหรือกรอบงานบางส่วนก็ตาม
Extension Int: ExampleProtocol ( var simpleDescription: String ( return "The number \(self)" ) การเปลี่ยนแปลง func adjust() ( self += 42 ) ) 7.simpleDescription
มาทดลองกัน
สร้างส่วนขยายประเภท Double ด้วยตัวแปรสมาชิก AbsoluteValue
คุณสามารถใช้ชื่อโปรโตคอลได้เหมือนกับประเภทอื่นๆ ตัวอย่างเช่น เพื่อสร้างอาร์เรย์ของออบเจ็กต์ประเภทต่างๆ แต่ใช้โปรโตคอลทั่วไป โปรดทราบว่าเมื่อทำงานกับออบเจ็กต์ประเภทนี้ วิธีที่ประกาศนอกโปรโตคอลจะไม่สามารถใช้ได้
ให้ protocolValue: ExampleProtocol = a protocolValue.simpleDescription // protocolValue.anotherProperty // Uncomment เพื่อดูข้อผิดพลาด
แม้ว่าตัวแปร protocolValue จะเป็นประเภท SimpleClass ณ รันไทม์ คอมไพลเลอร์จะถือว่าประเภทของมันคือ ExampleProtocol ซึ่งหมายความว่าคุณจะไม่สามารถเข้าถึงวิธีการหรือสมาชิกของคลาสที่ใช้งานนอก ExampleProtocol โดยไม่ได้ตั้งใจ
ประเภททั่วไป
หากต้องการสร้างประเภททั่วไป ให้ใส่ชื่อในวงเล็บมุม (<>).ฟังก์ชั่นทำซ้ำ
สร้างฟังก์ชัน คลาส การแจงนับ และโครงสร้างทั่วไป
// ปรับใช้ประเภทตัวเลือกของไลบรารีมาตรฐาน Swift อีกครั้ง enum OptionalValue
หากคุณต้องการระบุข้อกำหนดเฉพาะสำหรับประเภททั่วไป เช่น การใช้โปรโตคอล หรือกำหนดให้สืบทอดจากคลาสใดคลาสหนึ่ง ให้ใช้ Where
Func ใด ๆCommonElements
มาทดลองกัน
แก้ไขฟังก์ชัน anyCommonElements เพื่อส่งคืนอาร์เรย์ขององค์ประกอบทั่วไป
ในกรณีง่ายๆ คุณสามารถละเว้นตำแหน่งและเขียนโปรโตคอลหรือชื่อคลาสหลังเครื่องหมายทวิภาคได้ การแสดงออก
ไม่นานมานี้ บริษัทชื่อดังอย่าง Apple ได้เปิดตัวภาษาการเขียนโปรแกรมใหม่ที่เรียกว่า Swift ภาษาใหม่สำหรับการพัฒนาโปรแกรมบน IOS และ OS X ซึ่งดูดซับคุณสมบัติที่ดีที่สุดของบรรพบุรุษ ได้แก่ ภาษา C และ Objective-C ในขณะเดียวกันก็ขจัดข้อบกพร่องหลักออกไป
ดังที่ Apple กล่าว ภาษาถูกสร้างขึ้นเกือบตั้งแต่เริ่มต้นและใช้รูปแบบการเขียนโปรแกรมที่ปลอดภัย โดยใช้ฟังก์ชันที่ทันสมัย ซึ่งจะทำให้กระบวนการสร้างแอปพลิเคชันเร็วขึ้นและง่ายขึ้น [แน่นอน ถ้าคุณเข้าใจว่าควรสร้างแอปพลิเคชันเหล่านี้โดยทั่วไปอย่างไร]
อย่างไรก็ตาม ฉันจะบอกว่าภาษาดังกล่าวปรากฏเมื่อวันที่ 2 มิถุนายน 2014 และไซต์ไอทีหลายแห่ง [เช่น HUB] ได้จัดการหารือเกี่ยวกับข้อดี ข้อเสีย และอื่นๆ ของภาษานี้แล้ว การประเมินทั้งหมดเห็นพ้องกันว่าภาษานี้น่าสนใจและคุ้มค่าแก่การเรียนรู้มาก
บทความนี้เป็นการแนะนำภาษา Swift เพราะฉันวางแผนที่จะเขียนบทเรียนเพิ่มเติมอีกมาก ดังนั้นหากคุณสนใจเราจะศึกษากับคุณ
น่าเสียดายหรือโชคดีที่ไม่มีแหล่งข้อมูลภาษารัสเซียปกติที่คุณสามารถเรียนรู้ภาษานี้ได้ เพราะอย่างที่ทุกคนทราบกันดีว่าข้อมูล 90% ได้รับการเผยแพร่ในตลาดภาษาอังกฤษ และแม้ว่าจะแปลเป็นภาษารัสเซีย แต่ก็สูญเสียความเกี่ยวข้องไปแล้ว ดังนั้นวิธีเดียวที่จะทันเวลาได้คือการอ่านหนังสือเป็นภาษาอังกฤษ
ซึ่งเป็นสิ่งที่ฉันวางแผนจะทำ ไม่นานมานี้ ฉันอ่านหนังสือเกี่ยวกับภาษา C เล่มใหญ่จบ และคิดที่จะเปลี่ยนมาใช้ Objective-C แต่ฉันก็ตระหนักได้ว่าในไม่ช้าภาษานั้นก็จะสูญเสียความเกี่ยวข้องไป (หากไม่สมบูรณ์ในบางส่วน) ดังนั้นตัวเลือกจึงตกอยู่ที่ Swift
ยินดีต้อนรับสู่สวิฟท์
ปรากฎว่า Swift ทำงานมาหลายปีแล้วและอาจเกิดขึ้นในช่วงเวลาของจ็อบส์ Apple วางรากฐานสำหรับภาษาในกระบวนการส่งเสริมโครงสร้างพื้นฐานคอมไพเลอร์ ดีบักเกอร์ และเฟรมเวิร์ก ระบบการจัดการหน่วยความจำง่ายขึ้นอย่างมากโดยใช้การนับอ้างอิงอัตโนมัติ
ต้องขอบคุณ Objective-C ซึ่งเริ่มรองรับบล็อก ตัวอักษร และโมดูล จึงเป็นไปได้ที่จะสร้างเทคโนโลยีภาษาสมัยใหม่ ต้องขอบคุณรากฐานนี้ที่ทำให้ Apple สามารถสร้างภาษาใหม่ที่จะกลายเป็นอนาคตของการพัฒนาซอฟต์แวร์ทั้งหมดสำหรับ Apple
ผู้คน (นักพัฒนา) ที่คุ้นเคยกับ Objective-C อยู่แล้วจะพบว่า Swift ค่อนข้างคุ้นเคย เนื่องจากมีการผสมผสานความสามารถในการอ่านพารามิเตอร์ที่ดีเข้ากับพลังของโมเดลออบเจ็กต์ไดนามิกของบรรพบุรุษ สำหรับหลาย ๆ คน คงจะเป็นเรื่องน่ายินดีอย่างยิ่งที่ Swift สามารถใช้งานร่วมกับ Objective-C และสามารถฝังอยู่ในโค้ดได้ Swift สร้างขึ้นบนพื้นฐานทั่วไป โดยมีคุณสมบัติมากมายและรวมลักษณะขั้นตอนและเชิงวัตถุของภาษาเข้าด้วยกัน
โชคดีสำหรับเราที่ต้องการเรียนรู้วิธีการเขียนโปรแกรมใน Swift ภาษาค่อนข้างเป็นมิตรและไม่ต้องใช้ IQ เกิน 200 ถึงเชี่ยวชาญ ตามที่นักพัฒนากล่าวว่าเป็นภาษาแรกที่มีพลังเพียงพอและในขณะเดียวกันก็น่าสนใจและเรียบง่ายเหมือนกับภาษาสคริปต์ [หรือที่เรียกว่าภาษาสคริปต์]
มีสนามเด็กเล่นซึ่งแปลได้ยากพอสมควร แต่ถ้าคุณอธิบาย ด้วยคำพูดง่ายๆ- นี่คือการรองรับฟังก์ชันที่ช่วยให้คุณเห็นแอปพลิเคชัน (โปรแกรม) ที่คุณกำลังสร้างโดยไม่ต้องคอมไพล์และรันโปรเจ็กต์ 
ได้ซึมซับสิ่งที่ดีที่สุดจากทุกภาษาการเขียนโปรแกรมและวัฒนธรรมทั้งหมด รวมถึงประสบการณ์ของวิศวกรของ Apple คอมไพเลอร์ XCode ผสมผสานคุณภาพและประสิทธิภาพสูงเข้าด้วยกัน และภาษาได้รับการปรับให้เหมาะสมที่สุดสำหรับนักพัฒนาโดยไม่มีการประนีประนอมใดๆ
การคำนวณคือการเขียนโปรแกรมแรกของคุณ (เช่น "Hello, World") ควรทำได้ง่ายเหมือนกับการเขียนระบบปฏิบัติการทั้งหมด ทั้งหมดนี้ทำให้ Swift กลายเป็นอนาคตของการพัฒนาสำหรับ Apple และโลกโดยรวม
Swift เป็นวิธีที่ยอดเยี่ยมในการเขียนแอพสำหรับ iOS และ OS X เป้าหมายของภาษานี้นั้นยิ่งใหญ่ และเรารู้สึกตื่นเต้นที่ได้เห็นว่าคุณสร้างสรรค์อะไรได้บ้าง!
ภาษาโปรแกรมที่รวดเร็ว - Apple
แค่นี้ผมคิดว่าก็เพียงพอแล้วสำหรับการแนะนำตัว ฉันพยายามแปลคำนำจากหนังสือภาษาอังกฤษในภาษานี้อย่างเพียงพอ ในขณะเดียวกันก็เจือจางด้วยวลีจากตัวฉันเอง ฉันหวังว่ามันจะไม่แย่ หากคุณสนใจภาษานี้ สมัครรับข้อมูลอัปเดตบนบล็อก และเริ่มเรียนภาษานี้กับฉัน - ขอให้ทุกคนโชคดี
Vasily Usov“ สวิฟท์ พื้นฐานของการพัฒนาแอปพลิเคชันสำหรับ iOS" เซนต์ปีเตอร์สเบิร์ก, 2016, 304 หน้า (6.07 mb. pdf)
หนังสือเล่มนี้ให้ข้อมูลแก่นักพัฒนาเกี่ยวกับพื้นฐานของการเขียนโปรแกรมใน Swift ซึ่งเป็นภาษาการเขียนโปรแกรมที่ออกแบบมาโดยเฉพาะสำหรับการสร้างแอปพลิเคชันในรูปแบบ . นี่เป็นภาษาเชิงวัตถุที่รวดเร็ว ชาญฉลาด ปลอดภัย และใช้งานได้จริง มันถูกสร้างและเปิดตัวในปี 2014 และสร้างความประหลาดใจอย่างมากและสร้างความฮือฮาในสภาพแวดล้อมของ iOS ผ่านไปเพียงหนึ่งปีเท่านั้น Apple อัปเดตเป็นเวอร์ชัน 2.0 และ 2.1 ซึ่งรวมถึงนวัตกรรมที่สำคัญจำนวนหนึ่ง
คู่มือการปฏิบัติที่นำเสนอประกอบด้วยข้อมูลที่สมบูรณ์ที่สุดเกี่ยวกับเทคโนโลยีการเขียนโปรแกรมใน Swift ใครก็ตามที่ต้องการเรียนรู้วิธีสร้างแอปพลิเคชันสำหรับ iOS จะสามารถใช้หนังสือเล่มนี้เป็นข้อมูลอ้างอิงและตำราเรียนได้โดยไม่ต้องหันไปพึ่งสิ่งพิมพ์อื่น หนังสือเล่มนี้ไม่เพียงแต่ให้ทฤษฎีเท่านั้น แต่ยังแสดงให้เห็นการใช้โครงสร้างภาษาด้วย ปริมาณมากตัวอย่าง และเพื่อรวบรวมความรู้และเข้าใจความซับซ้อนทั้งหมดของภาษาให้ดีขึ้น ผู้อ่านได้รับเชิญให้ทำงานภาคปฏิบัติหลายอย่างให้สำเร็จ ด้วยการเรียนรู้การเขียนโปรแกรม Swift คุณจะสามารถพัฒนาได้อย่างมีประสิทธิภาพและ แอปพลิเคชั่นที่น่าสนใจสำหรับแพลตฟอร์ม: iOS, OS X, tvOS หรือ watchOS ไอ: 978-5-496-02256-9
บทนำ 8
เกี่ยวกับสวิฟท์ 9
เกี่ยวกับเล่ม 10
ส่วนที่ 1: การแนะนำ Xcode 13
บทที่ 1 ขั้นตอนแรก 14
1 .1 .คุณต้องการ คอมพิวเตอร์แมค 14
1 .2 .ลงทะเบียนเป็นนักพัฒนา Apple 14
1.3.ติดตั้ง Xcode 16
บทที่ 2 สภาพแวดล้อม Xcode และโครงการสนามเด็กเล่น 18
2.1.ความรู้เบื้องต้นเกี่ยวกับ Xcode 18
2.2.ส่วนต่อประสานโครงการสนามเด็กเล่น 21
2.3.ความเป็นไปได้ของโครงการสนามเด็กเล่น 23
ส่วนที่ 2 คุณสมบัติพื้นฐานสวิฟท์ 27
บทที่ 3 จุดเริ่มต้น 28
3.1.การตั้งค่าและการเปลี่ยนแปลงค่า 29
3.2.ตัวแปรและค่าคงที่ 31
3.3.กฎสำหรับการประกาศตัวแปรและค่าคงที่ 34
3.4.บทสรุป ข้อมูลข้อความ 35
3 .5 .ความคิดเห็น 37
3.6.อัฒภาค 39
บทที่ 4 ชนิดข้อมูลและการดำเนินงานด้วย 40
4.1.ประเภทของคำจำกัดความของชนิดข้อมูล 40
4.2.ประเภทข้อมูลตัวเลข 43
4.3.ประเภทข้อมูลข้อความ 56
4.4.ค่าตรรกะ 62
4.5.พิมพ์นามแฝง 65
4.6 ตัวดำเนินการเปรียบเทียบ 67
ส่วนที่ 3 สินทรัพย์ถาวรที่รวดเร็ว 69
บทที่ 5 สิ่งอันดับ 70
5.1.ข้อมูลพื้นฐานเกี่ยวกับสิ่งอันดับ 70
5.2 การโต้ตอบกับองค์ประกอบของ tuple 72
บทที่ 6 ประเภทตัวเลือกข้อมูล 78
6.1.ทางเลือก 78
6.2.การดึงค่าทางเลือก 80
บทที่ 7 งบ 83
บทที่ 8 การควบคุมการไหล การแตกแขนง 86
8.1 ตัวดำเนินการแบบมีเงื่อนไขหาก 86
8.2.ผู้ควบคุมเครื่อง 97
8.3.ตัวดำเนินการพิสัย 98
8.4 สวิตช์ตัวดำเนินการแยกสาขา 98
บทที่ 9 ประเภทคอลเลกชัน 109
9.1.อาร์เรย์ 109
9.2.เซต 120
9.3.พจนานุกรม 128
บทที่ 10 การควบคุมการไหล การทำซ้ำ 135
10.1.ตัวดำเนินการทำซ้ำสำหรับ 135
10.2.ตัวดำเนินการทำซ้ำในขณะที่และทำซ้ำในขณะที่ 142
10.3.การจัดการวงจร 144
บทที่ 11 ฟังก์ชั่น 148
11.1.การประกาศฟังก์ชัน 148
11.2.ป้อนพารามิเตอร์และคืนค่า 151
11.3.ฟังก์ชั่นร่างกายเป็นค่า 162
11.4.ฟังก์ชันที่ซ้อนกัน 163
11.5.ฟังก์ชั่นการโหลดซ้ำ 164
11.6.ฟังก์ชันเรียกซ้ำเรียก 165
บทที่ 12 การปิด 167
12.1.หน้าที่เป็นการปิด 167
12.2 นิพจน์ปิด 170
12.3.การส่งคืนค่าโดยนัย 171
12.4.ชื่อพารามิเตอร์ย่อ 172
12.5.ตัวแปรการปิด 174
12.6 การจับตัวแปร 175
12.7 วิธีการเรียงลำดับอาร์เรย์ 176
ส่วนที่สี่ คุณสมบัติที่ไม่สำคัญของ Swift 178
บทที่ 13 OOP เป็นรากฐาน 180
13.1.อินสแตนซ์ 180
13.2.เนมสเปซ 182
บทที่ 14 การโอน 184
14.1.ไวยากรณ์การแจงนับ 184
14.2.พารามิเตอร์ที่เกี่ยวข้อง 187
14.3 สลับคำสั่งสำหรับการแจงนับ 189
14.4.ค่าที่เกี่ยวข้องของสมาชิกแจงนับ 190
14.5.คุณสมบัติในการแจงนับ 192
14.6.วิธีการแจกแจง 193
14 .7. ตัวดำเนินการด้วยตนเอง 194
14.8.การแจงนับแบบเรียกซ้ำ 195
บทที่ 15 โครงสร้าง 199
15.1.ไวยากรณ์สำหรับการประกาศโครงสร้าง 199
15.2.คุณสมบัติในโครงสร้าง 200
15.3.โครงสร้างเป็นเนมสเปซ 202
15.4.ตัวเริ่มต้นแบบกำหนดเอง 203
15.5.วิธีการในโครงสร้าง 204
บทที่ 16 ชั้นเรียน 206
16.1.ไวยากรณ์คลาส 207
16.2.คุณสมบัติของคลาส 207
16.3.วิธีการเรียน 210
16.4.ตัวเริ่มต้นคลาส 211
16.5.ประเภทที่ซ้อนกัน 212
บทที่ 17 คุณสมบัติ 214
17.1.ประเภททรัพย์สิน 214
17.2.ควบคุมการรับและตั้งค่า 216
17.3.คุณสมบัติของประเภท 220
บทที่ 18 ตัวติดตาม 223
18.1.วัตถุประสงค์ของตัวห้อย 223
18.2.ไวยากรณ์ตัวห้อย 224
บทที่ 19 มรดก 229
19.1.ไวยากรณ์การสืบทอด 229
19.2. นิยามองค์ประกอบที่สืบทอดมาใหม่ 231
19.3.ตัวแก้ไขเชิงป้องกันสุดท้าย 234
19.4.การทดแทนอินสแตนซ์คลาส 235
19.5.ประเภทหล่อ 235
บทที่ 20 นามแฝงใด ๆ และใด ๆ 238
20 .1 .ชื่อเล่น ใด ๆ 238
20.2.นามแฝง AnyObject 240
บทที่ 21 Initializers และ deinitializers 241
21.1.ตัวเริ่มต้น 241
21.2.ตัวกำหนดค่าเริ่มต้น 248
บทที่ 22 การลบอินสแตนซ์และ ARC 250
22.1.การทำลายสำเนา 250
22.2.หน่วยความจำรั่ว 252
22.3.การนับการอ้างอิงอัตโนมัติ 255
บทที่ 23 โซ่เสริม 258
23.1.การเข้าถึงคุณสมบัติผ่านเชนเสริม 258
23.2 การตั้งค่าผ่านเชนเสริม 260
23.3.การเข้าถึงวิธีการผ่านสายโซ่เสริม 261
บทที่ 24 ส่วนขยาย 262
24.1 คุณสมบัติการคำนวณในส่วนขยาย 263
24.2.ตัวเริ่มต้นในส่วนขยาย 264
24.3.วิธีการในส่วนขยาย 265
24.4.ตัวห้อยในส่วนขยาย 266
บทที่ 25 โปรโตคอล 267
25.1.คุณสมบัติที่ต้องการ 268
25.2.วิธีการบังคับ 269
25.3.ตัวเริ่มต้นที่จำเป็น 270
25.4.โปรโตคอลเป็นข้อมูลประเภท 271
25.5.ส่วนขยายและโปรโตคอล 271
25.6. การสืบทอดโปรโตคอล 272
25.7. โปรโตคอลคลาส 273
25.8.องค์ประกอบของโปรโตคอล 274
บทที่ 26 ชนิดข้อมูลและการดึงข้อมูลที่ไม่ได้มาตรฐาน ข้อมูลอ้างอิง 275
บทที่ 27 เทมเพลตสากล 283
27 .1 .คุณสมบัติอเนกประสงค์ 283
27.2.ประเภทสากล 285
27.3.ข้อจำกัดประเภท 287
27.4.ส่วนขยายประเภทสากล 288
27.5.ประเภทที่เกี่ยวข้อง 288
บทที่ 28 การจัดการข้อผิดพลาด 291
28.1.การขว้างข้อผิดพลาด 291
28.2.การจัดการข้อผิดพลาด 292
28.3 การดำเนินการทำความสะอาดรอการตัดบัญชี 297
บทที่ 29 การใช้ตัวดำเนินการที่ไม่สำคัญ 298
29.1.ฟังก์ชันตัวดำเนินการ 298
29.2.ตัวดำเนินการผู้ใช้ 301
Chris Lattner ใช้เวลาหนึ่งปีครึ่งในการสร้างภาษาการเขียนโปรแกรมใหม่ ในช่วงเวลานี้เขาไม่ได้พูดถึงงานของเขากับใครเลยแม้แต่กับเพื่อนสนิทก็ตาม เขาเริ่มทำงานในฤดูร้อนปี 2010 โดยทุ่มเทเวลากลางคืนและวันหยุดสุดสัปดาห์ให้กับงานนี้ และในสิ้นปีถัดมา เขาได้พัฒนาพื้นฐานของภาษาในอนาคต จากนั้นคริสจึงเปิดเผยความลับของเขาภายในบริษัท ซึ่งผู้จัดการระดับสูงประทับใจมากพอที่จะเพิ่มวิศวกรที่มีประสบการณ์หลายคนเข้ามาในโปรเจ็กต์นี้ อีกปีครึ่งต่อมา โครงการของ Lattner ก็รวมอยู่ในรายการทิศทางหลักของบริษัท และทีมพัฒนาก็ขยายตัวอย่างมีนัยสำคัญ ปัจจุบัน ภาษาใหม่กำลังเข้ามาเปลี่ยนแปลงโลกแห่งคอมพิวเตอร์ บริษัทที่ Chris Lattner ทำงานด้วยเรียกว่า Apple และภาษาที่เขาสร้างขึ้นเรียกว่า Swift
วันที่ 2 มิถุนายน 2557 เวลา การนำเสนอของ WWDCภาษาที่รวดเร็ว บริษัทได้เปิดตัวเวอร์ชันทดสอบสำหรับนักพัฒนาและโปรแกรมเมอร์บุคคลที่สาม โดยวางตำแหน่งภาษาให้เป็นวิธีที่รวดเร็วและมีประสิทธิภาพมากขึ้นในการสร้างโปรแกรมสำหรับ iPhone, iPad และ Mac แม้ว่า Chris Lattner จะเริ่มทำงานกับ Swift แล้ว ข้อมูลเกี่ยวกับผลิตภัณฑ์นี้ก็ทำให้ทุกคนตกใจ ยกเว้นพนักงาน Apple เพียงไม่กี่คน แม้แต่คนที่มีส่วนร่วมทางอ้อมในการสร้างภาษาและช่วยเหลือคริสก็ยังแปลกใจมากที่รู้ว่าฤดูร้อนนี้เขากำลังทำอะไรอยู่
Swift ดึงดูดผู้ชม
โดยปกติแล้วภาษาใหม่จะใช้เวลาหลายปีหลังจากการแนะนำจึงจะดึงดูดผู้ฟังได้ กฎนี้ใช้กับกรณีดังกล่าวด้วย บริษัทขนาดใหญ่เช่นเดียวกับแอปเปิ้ล ตัวอย่างที่ดีก็คือ บริษัทกูเกิลด้วยภาษา Go ที่เปิดตัวในปี 2009 Ken Thompson และ Rob Pike ผู้มีสติปัญญาเฉียบแหลมที่สุดในโลกการพัฒนาซอฟต์แวร์ ทำงานกับ Go แต่จนถึงทุกวันนี้มีการใช้ความพยายามอย่างมากเพื่อให้แน่ใจว่าภาษานั้นมีผู้ติดตาม แต่สวิฟท์เป็นสัตว์ร้ายสายพันธุ์อื่น เมื่อภาษาดังกล่าวเปิดตัวอย่างเป็นทางการในฤดูใบไม้ร่วงนี้ ก็คาดว่าจะดึงดูดผู้ชมในอัตราที่ไม่เคยมีมาก่อน ซึ่งแซงหน้าอัตราการใช้ภาษาอย่าง Java และ C# ในปี 1990 และต้นปี 2000
จะอธิบายสมมติฐานในแง่ดีดังกล่าวได้อย่างไร? ในความเป็นจริง Swift ได้รับการออกแบบมาสำหรับโปรแกรมเมอร์ทั่วไป แม้แต่แอปพลิเคชันที่ง่ายที่สุดก็สามารถเขียนด้วยภาษาได้ และด้วยเครื่องมืออันชาญฉลาดบางอย่าง ภาษานี้จึงเป็นวิธีที่มีประสิทธิภาพในการเรียนรู้การเขียนด้วยตัวเอง แต่เหตุผลหลักที่ทำให้ภาษานี้ได้รับความนิยมในอนาคตนั้นอยู่ที่อื่น ปัจจุบันนักพัฒนาหลายแสนคนสร้างแอพพลิเคชั่นสำหรับอุปกรณ์ Apple โดยใช้ Objective-C อุปกรณ์ Apple ได้รับความนิยมอย่างมากซึ่งหมายความว่านักพัฒนาเหล่านี้จะยังคงสร้างแอปพลิเคชันสำหรับพวกเขาต่อไป แต่ใน Swift เนื่องจากดีกว่าและมีประสิทธิภาพมากกว่า Objective-C มาก
“ไม่มีแรงจูงใจอย่างแท้จริงในการใช้ Google Go” Paul Jansen ผู้ซึ่งติดตามความก้าวหน้าของภาษาการเขียนโปรแกรมต่างๆ ประมาณสิบห้าปีกล่าว “สิ่งที่ทำให้ Swift แตกต่างคือแรงจูงใจ”
วันนี้ที่ GitHub พื้นที่เก็บข้อมูลยอดนิยมการพัฒนาโอเพ่นซอร์สมีโครงการมากกว่า 2,400 โครงการที่ใช้ Swift อย่างไรก็ตาม มันก็คุ้มค่าที่จะจำไว้ว่า ในขณะนี้ภาษาที่ใช้ได้เท่านั้น จำนวนจำกัดโปรแกรมเมอร์
ข้อดีเหนือ Objective-C
หากต้องการละทิ้งภาษาที่มีการเขียนผลิตภัณฑ์หลายอย่างแล้วและเริ่มเรียนรู้ภาษาใหม่ โปรแกรมเมอร์จำเป็นต้องมีเหตุผลที่ดีจริงๆ การเรียนรู้ใหม่ต้องใช้เวลาและความพยายาม และจนถึงทุกวันนี้ Chris Lattner เป็นเพียงคนเดียวที่มีประสบการณ์การเขียนโปรแกรม Swift เป็นเวลาสี่ปี อย่างไรก็ตาม ได้มีการนำเสนอเหตุผลที่น่าสนใจเหล่านี้แล้ว
ไม่ใช่ว่า Swift มีความน่าดึงดูดมากกว่าภาษาอื่น ๆ เช่น C#, Ruby หรือ Python อย่างมาก แต่ Swift นั้นมีเสน่ห์มากกว่า Objective-C ซึ่งแทบจะเรียกได้ว่าเป็นภาษาสมัยใหม่ไม่ได้เลย ไวยากรณ์ที่รวดเร็วคุ้นเคยมากขึ้น ภาษานี้ยังมีเครื่องมือหลายอย่างสำหรับการป้องกันข้อผิดพลาดและจุดบกพร่อง Swift เข้าใจการกระทำของผู้เขียนโค้ดได้ดีขึ้น และทำให้งานของเขามีประสิทธิภาพมากขึ้น ทำให้เขาสามารถทำงานได้มากขึ้นโดยใช้เวลาน้อยลง แต่สิ่งที่น่าสนใจที่สุดของภาษาคือสิ่งที่เรียกว่าสนามเด็กเล่น
สนามเด็กเล่น
Playgrounds ได้รับการออกแบบมาเพื่อให้การเขียนโปรแกรมมีการโต้ตอบและเข้าถึงได้มากขึ้น แนวคิดก็คือเมื่อโปรแกรมเมอร์เขียนโค้ดลงบนครึ่งหนึ่งของหน้าจอ เขาจะเห็นผลลัพธ์ในอีกครึ่งหนึ่ง จึงสามารถสังเกตการสร้างโปรแกรมได้แบบเรียลไทม์ เมื่อโปรแกรมเมอร์ทำการเปลี่ยนแปลงโค้ด การเปลี่ยนแปลงดังกล่าวจะส่งผลต่อเวอร์ชันที่รันอยู่ของโปรแกรมด้วย ทำให้ไม่จำเป็นต้องคอมไพล์ซ้ำแล้วรีสตาร์ท
วิธีเขียนโค้ดนี้ไม่เพียงแต่ทำให้งานของโปรแกรมเมอร์ง่ายขึ้นเท่านั้น แต่ยังเปลี่ยนวิธีคิดของเราเกี่ยวกับการเขียนโปรแกรม และยกระดับความเข้าใจไปอีกระดับหนึ่ง Chris Lattner ยังหวังว่าการทำให้การเขียนโค้ดง่ายขึ้นและสนุกยิ่งขึ้น เขาจะช่วยกำหนดวิธีการสอนวิทยาการคอมพิวเตอร์ในปัจจุบันใหม่
มากกว่าภาษา
Chris Lattner ผู้สร้าง Swift ดูแลเครื่องมือนักพัฒนาทั้งหมดของ Apple ทุกอย่างที่ใช้สร้างโปรแกรมสำหรับโทรศัพท์ แท็บเล็ต และ คอมพิวเตอร์แอปเปิ้ลทั้งนักพัฒนาบุคคลที่สามและวิศวกรของบริษัท ในฐานะนักศึกษาระดับบัณฑิตศึกษาที่มหาวิทยาลัยอิลลินอยส์ เขาได้สร้างเครื่องมือสำหรับนักพัฒนาประเภทหนึ่งที่เรียกว่า LLVM ซึ่งเป็นพื้นฐานของ Xcode ในปัจจุบัน
Apple ใช้ LLVM เพื่อเปลี่ยนวิธีการใช้ Objective-C ในการสร้างแอปพลิเคชัน สิ่งนี้เกิดขึ้นหลังจากที่ Lattner เข้าร่วมกับ Apple ในปี 2548 และห้าปีต่อมาเขาใช้ LLVM เป็นพื้นฐานสำหรับ Swift ผลิตภัณฑ์ทั้งสองนี้ได้รับการออกแบบมาโดยเฉพาะให้ทำงานควบคู่กัน กล่าวอีกนัยหนึ่ง Swift ไม่ใช่แค่ภาษา แต่เป็นภาษาที่เกี่ยวข้องอย่างใกล้ชิดกับทุกสิ่งที่นักพัฒนาจำเป็นต้องใช้ในการทำงานของตน ซึ่งรวมถึงไม่เพียงแต่สภาพแวดล้อมการพัฒนาแบบผสานรวมเท่านั้น แต่ยังรวมไปถึงเครื่องมืออื่นๆ อีกมากมายที่นักพัฒนา Apple ทุกคนคุ้นเคยอยู่แล้ว เช่น ดีบักเกอร์ กล่าวอีกนัยหนึ่ง มีเหตุผลว่าทำไมโปรแกรมเมอร์หลายหมื่นคนควรเขียนแอพ Swift อยู่แล้ว
ความเร็ว
นี่เป็นคำที่แสดงถึงคุณสมบัติต่างๆ ของภาษา Swift ใหม่ได้ดีที่สุด ภาษาแสดงให้เห็นถึงความเร็วที่น่าทึ่งในการแปลงโค้ดดิบให้เป็นแอปพลิเคชันที่ปฏิบัติการได้ ความเร็วของแอปพลิเคชันเหล่านี้บนโทรศัพท์และแท็บเล็ตน่าประหลาดใจ Swift ไม่เพียงแต่เป็นมิตรกับมนุษย์เท่านั้น แต่ยังเป็นมิตรกับคอมพิวเตอร์ด้วย และคุณภาพประการที่สามที่เราได้พูดถึงไปแล้วคือความเร็วของการแพร่กระจาย
Apple ไม่ใช่บริษัทแรกที่เข้าสู่วงแหวนนี้ มีอยู่แล้ว , Google และ Mozilla ในบางแง่ ภาษาของบริษัทเหล่านี้ได้พัฒนาไปไกลกว่านั้นมาก เนื่องจากมีการใช้ภาษาเหล่านี้สำหรับงานภายในแล้ว นอกจากนี้ส่วนใหญ่เป็นโอเพ่นซอร์สซึ่งทำให้ง่ายต่อการเผยแพร่ไปยังบริษัทอื่น Apple มีชื่อเสียงในด้านการควบคุมผลิตภัณฑ์ของตนเองอย่างเข้มงวดและในขณะนี้ ซอร์สโค้ดปิดอยู่ ซึ่งอาจทำให้ยากต่อการสร้างโปรแกรมข้ามแพลตฟอร์ม เป็นต้น อย่างไรก็ตาม เชื่อกันว่าในที่สุด Swift จะกลายเป็นโอเพ่นซอร์ส
ไม่ว่า Swift จะเป็นโอเพ่นซอร์สหรือไม่ก็ตาม ก็คาดว่าจะได้รับความนิยมและอัตราการนำไปใช้อย่างที่ไม่เคยมีมาก่อน ความเป็นเอกลักษณ์ของภาษาตลอดจนความนิยมของผลิตภัณฑ์ Apple จะทำงานได้อย่างไม่ต้องสงสัย
ขึ้นอยู่กับแบบมีสาย
Apple เปิดตัวภาษาการเขียนโปรแกรมใหม่ Swift เรามาดูกันว่าเหตุใดจึงมีความจำเป็นและเหตุใดนักพัฒนาจึงมีความหวังสูงเช่นนี้
สวิฟท์คืออะไร?
เป็นภาษาโปรแกรมใหม่ที่พัฒนาโดย Apple สำหรับการสร้างแอปพลิเคชันสำหรับ iOS และ OS X โดยสร้างขึ้นจาก C และ Objective-C แต่เรียบง่ายและยืดหยุ่นกว่า นอกจากนี้ผู้สร้าง Swift ยังยืมองค์ประกอบที่ดีที่สุดของภาษาอีกด้วย การเขียนโปรแกรมจาวาสคริปต์และหลาม
มันดีกว่าภาษาโปรแกรมอื่นยังไง?
นักพัฒนา Apple พยายามสร้างภาษาที่ทันสมัยที่สุดเท่าที่จะเป็นไปได้: Swift นั้นรวดเร็ว (ความเร็วในการนำอัลกอริธึมบางตัวไปใช้งานเร็วกว่าใน Python ถึง 3.9 เท่า) และกระชับ (นักพัฒนาได้กำจัดการใช้คำฟุ่มเฟือยของ Objective-C) นวัตกรรมที่สำคัญอีกประการหนึ่งคือความสามารถในการเขียนโค้ดและเห็นผลแบบเรียลไทม์ ก่อนหน้านี้ กระบวนการสร้างผลิตภัณฑ์และผลิตภัณฑ์นั้นถูกแยกออกจากกันเป็นเวลานาน และด้วยเหตุนี้ โปรแกรมเมอร์จึงต้องใช้เวลามากในการตรวจสอบและเพิ่มประสิทธิภาพโค้ด ใน Swift พวกเขาสามารถปรับเปลี่ยนและดูผลลัพธ์ได้ทันที ซึ่งหมายความว่านักพัฒนาสามารถทดสอบแนวคิดของตนได้เร็วขึ้นและสร้างแอปโดยรวมได้เร็วขึ้น
วิธีการเรียนรู้การเขียนโปรแกรมในภาษานี้?
พร้อมๆ กับการปล่อยวาง สวิฟท์ แอปเปิลเปิดตัวหนังสือเกี่ยวกับเขาซึ่งสามารถดาวน์โหลดได้ฟรีจาก iTunes Store ตัดสินโดยปฏิกิริยาของผู้เชี่ยวชาญ ซึ่งหลายคนอ่านมันในชั่วโมงแรกหลังจากการนำเสนอภาษาที่ WWDC ในอีกไม่กี่สัปดาห์ข้างหน้า เราควรคาดหวังวิดีโอการสอนและการอภิปรายหลายร้อยรายการ - ครั้งแรก สาธารณะได้ปรากฏแล้ว
ทำไม Apple ถึงทำเช่นนี้?
ประการแรก Swift คือการตอบสนองของ Apple ต่อการกำเนิดของภาษาการเขียนโปรแกรมที่พัฒนาโดยคู่แข่งของ Google นับตั้งแต่เปิดตัว OS X นั้น Apple ใช้เฉพาะ Objective-C เท่านั้น และการมาถึงของ Swift ถือเป็นก้าวสำคัญสู่อนาคต ประการที่สอง ด้วยการสร้างภาษาที่เรียบง่ายและทันสมัย Apple หวังที่จะดึงดูดไม่เพียงแต่นักพัฒนาที่มีประสบการณ์ซึ่งรู้วิธีทำงานกับ Objective-C และ C เท่านั้น แต่ยังรวมถึงผู้เริ่มต้นที่อาจใช้ประโยชน์จากโอกาสนี้และเริ่มเรียนรู้ Swift ตลาดแอปจะเติบโตอีกครั้ง ซึ่งหมายความว่าอิทธิพลของ Apple จะเพิ่มขึ้น
Flappy Bird ได้รับการสร้างขึ้นใหม่ใน Swift และโพสต์บน GitHub
ผู้เชี่ยวชาญพูดว่าอย่างไร?
แอนตัน โดมาชเนฟ
นักพัฒนา iOS ดูที่สื่อ
“โปรแกรมเมอร์ iOS และ OS X หลายคนใฝ่ฝันถึงภาษาดังกล่าว เพราะมันสะดวกกว่า Objective-C แต่ฉันไม่สามารถพูดได้ว่า Objective-C เป็นภาษาที่ไม่ดีและจำเป็นต้องเปลี่ยนภาษาอย่างมาก อย่างไรก็ตาม ฉันชอบความจริงที่ว่า Swift นั้นอ่านง่ายกว่ามากและโค้ดที่เขียนด้วย Swift จะสั้นกว่าโค้ดที่คล้ายกันใน Objective-C หลายเท่า ซึ่งจะเพิ่มความเร็วของการพัฒนา เมื่อพิจารณาจากสิ่งที่ฉันเห็นที่ WWDC เราคาดว่าเกมสำหรับ iOS จะได้รับความนิยมอย่างมาก เนื่องจาก Apple เปิดตัวยูทิลิตี้ Interactive Playgrounds ที่น่าสนใจมาก ซึ่งจะช่วยเพิ่มความสนใจในการพัฒนาเกมสำหรับอุปกรณ์ Apple วันนี้ฉันจะเริ่มอ่านบทช่วยสอนเกี่ยวกับภาษานี้ - เมื่อพิจารณาจากสิ่งที่แสดงในงานนำเสนอ การเปลี่ยนไปใช้ Swift นั้นไม่ใช่เรื่องยาก เนื่องจากโครงสร้างหลายอย่างมีความคล้ายคลึงกับโครงสร้างที่เราใช้ในปัจจุบันในการพัฒนา Objective-C ฉันจะเขียนโปรเจ็กต์ใหม่ของฉันใน Swift”
วลาดิมีร์ โบโบรฟ
ผู้อำนวยการฝ่ายเทคนิค มองสื่อ
“แน่นอนว่าการเปิดตัว Swift ถือเป็นก้าวที่ยอดเยี่ยมสำหรับทั้ง Apple และชุมชนนักพัฒนา ภาษาใหม่จะดึงดูด มากกว่านักพัฒนาด้วยการลดอุปสรรคในการเข้าสู่ระบบนิเวศการพัฒนาของ Apple ซึ่งค่อนข้างสูงเนื่องจากภาษา Objective-C นอกจากนี้ ชุดเครื่องมือที่นำเสนอ (Interactive Playgrounds, REPL) จะช่วยให้คุณสามารถดีบักโปรแกรมและเกมของคุณได้อย่างรวดเร็ว ฉันเชื่อว่าคุณสมบัติของภาษา Swift และการสนับสนุนอย่างมากจาก Apple จะทำให้ภาษาดังกล่าวได้รับความนิยมอย่างมากในหมู่นักพัฒนาซอฟต์แวร์ที่เน้นไปที่ผู้ใช้จำนวนมาก"
อะไรอีก?
คุณสามารถใช้อิโมจิใน Swift
