ในการเปิดการประชุมนักพัฒนา WWDC 2015 Apple ได้นำเสนอการอัปเดตสำหรับแพลตฟอร์มหลัก iOS 9 และ OS X El Capitan แต่สำหรับนักพัฒนา ประกาศที่สำคัญที่สุดประการหนึ่งคือเวอร์ชันที่สองของภาษาการเขียนโปรแกรม Craig Federighi กล่าวระหว่างการนำเสนอผลิตภัณฑ์ว่า Apple พยายามสร้างภาษาที่จะปราศจากมรดกอันยุ่งยากของ Objective-C Swift ถูกสร้างขึ้นบนแพลตฟอร์ม NeXt ซึ่งกลายเป็นพื้นฐานสำหรับ OS X และ iOS

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

1. ยังไม่มีนักพัฒนา Swift ที่มีประสบการณ์อย่างแท้จริง

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

2. เป็นภาษาโปรแกรมรุ่นเยาว์

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

3. เป็นภาษาโปรแกรมที่ปลอดภัย

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

4. ไวยากรณ์ที่อ่านง่ายซึ่งได้รับแรงบันดาลใจจาก Python และ Ruby

รวดเร็ว - ง่าย ภาษาที่อ่านได้เช่นเดียวกับ Python ข้อแตกต่างที่สำคัญคือบล็อกไม่ได้คั่นด้วยเครื่องหมายเยื้อง แต่ด้วยเครื่องหมายปีกกาซึ่งคุ้นเคยและสะดวกกว่า

5. สวิฟท์โอเพ่นซอร์สของ Apple

Apple ประกาศในงาน WWDC 2015 ว่า Swift จะเป็น . ซึ่งหมายความว่าไม่เพียงแต่ Apple จะต้องพึ่งพาชุมชนนักพัฒนามากขึ้นในการปรับแต่ง แต่ยังรวมถึงศักยภาพที่จะกลายเป็นหลายแพลตฟอร์มอย่างแท้จริงแทนที่จะถูกจำกัด ระบบนิเวศของแอปเปิล- กล่าวอีกนัยหนึ่ง หากคุณพัฒนาแอปพลิเคชันใน Swift สำหรับ iOS โอกาสก็คือคุณสามารถพอร์ตแอปพลิเคชันดังกล่าวไปยัง Android ได้โดยไม่ต้องเรียนรู้ Java ซึ่งระบบปฏิบัติการของ Google ใช้

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

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

miden16 10 มิถุนายน 2557 เวลา 13:06 น

ภาษา การเขียนโปรแกรมสวิฟท์- เวอร์ชันรัสเซีย

• การพัฒนาสำหรับ iOS,
• สวิฟท์

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

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

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

ยินดีต้อนรับสู่สวิฟท์

เกี่ยวกับภาษาสวิฟท์

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

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

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

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

Swift ผสมผสานภาษาสมัยใหม่ที่ดีที่สุดเข้าด้วยกัน และได้รับการพัฒนาโดยคำนึงถึงประสบการณ์อันยาวนานของ Apple คอมไพเลอร์ของเรามีความหมายเหมือนกันกับประสิทธิภาพ และภาษาของเราได้รับการปรับให้เหมาะสมสำหรับการพัฒนาโดยไม่คำนึงถึงการประนีประนอม ได้รับการออกแบบในลักษณะที่คุณสามารถพัฒนาแอปพลิเคชัน “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)

มาทดลองกัน
ลองลบการแปลงที่ชัดเจนเป็น ประเภทสตริงในบรรทัดสุดท้าย คุณจะได้รับข้อผิดพลาดอะไร?

วิธีที่ง่ายกว่าในการรวมค่าในสตริงคือการใส่นิพจน์ไว้ในวงเล็บและนำหน้าด้วยแบ็กสแลช (\) ตัวอย่าง:

ให้แอปเปิ้ล = 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 ( สำหรับตัวเลขในตัวเลข ( ถ้าตัวเลข > ใหญ่ที่สุด ( ใหญ่ที่สุด = ตัวเลข ) ) ) ใหญ่ที่สุด

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

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

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 ฟังก์ชันถูกเรียกโดยการระบุชื่อและรายการอาร์กิวเมนต์ในวงเล็บ ประเภทการส่งคืนควรแยกออกจากรายการอาร์กิวเมนต์อย่างเป็นทางการโดยใช้ ->

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()
ในตัวอย่างนี้เราพลาดไปอย่างหนึ่ง รายละเอียดที่สำคัญ– ตัวสร้างคลาส, วิธีการเริ่มต้น

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 วิธีนี้มีสามขั้นตอนตามลำดับ:

1. การเริ่มต้นสมาชิกของคลาสย่อย
2. เรียกตัวสร้างของคลาสพาเรนต์
3. การเปลี่ยนแปลงค่าของสมาชิกของคลาสผู้ปกครอง

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

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)

ตัวนับคลาส ( นับ var: Int = 0 func increbitBy (จำนวน: 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 โดยไม่ได้ตั้งใจ

ประเภททั่วไป

หากต้องการสร้างประเภททั่วไป ให้ใส่ชื่อในวงเล็บมุม (<>).

ฟังก์ชั่นทำซ้ำ (item: ItemType, ครั้ง: Int) -> ItemType ( var result = ItemType() for i ใน 0..times ( result += item ) return result ) ทำซ้ำ("knock", 4)
สร้างฟังก์ชัน คลาส การแจงนับ และโครงสร้างทั่วไป

// ปรับใช้ประเภทตัวเลือกของไลบรารีมาตรฐาน Swift อีกครั้ง enum OptionalValue ( case none case Some(T) ) var possibleInteger: OptionalValue = .ไม่มีความเป็นไปได้จำนวนเต็ม = .บางส่วน(100)
หากคุณต้องการระบุข้อกำหนดเฉพาะสำหรับประเภททั่วไป เช่น การใช้โปรโตคอล หรือกำหนดให้สืบทอดจากคลาสใดคลาสหนึ่ง ให้ใช้ Where

Func ใด ๆCommonElements (lhs: T, rhs: U) -> Bool ( สำหรับ lhsItem ใน lhs ( สำหรับ rhsItem ใน rhs ( ถ้า lhsItem == rhsItem ( return true ) ) ) ส่งคืน false ) anyCommonElements(, )

มาทดลองกัน
แก้ไขฟังก์ชัน anyCommonElements เพื่อส่งคืนอาร์เรย์ขององค์ประกอบทั่วไป

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

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

นักพัฒนาใช้งานอยู่แล้ว
คุณสมบัติที่น่าทึ่งของ Swift

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

แอพที่ยอดเยี่ยมใน Swiftความสะดวกในการใช้งานและการตอบสนองแบบเรียลไทม์คือเหตุผลที่ VSCO เลือก Swift เพื่อสร้างแอพรูปภาพ iOS เวอร์ชันใหม่

แอปพลิเคชั่นที่ยอดเยี่ยม
พัฒนาด้วยภาษา Swift

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

ดูโอลิงโก ข่าน
คู่มือฟ้าใสของสถาบัน

สร้าง Kickstarter Eventbrite Hipmunk

ผลผลิตสูงขึ้น แอพจะดีกว่า

แอพ Swift เกินความคาดหมาย ตัวอย่างเช่น อัลกอริธึมการค้นหาปกติจะทำงานเร็วขึ้นมากใน Swift

สูงถึง 2.6 ครั้ง เร็วกว่า Objective-C

สูงถึง 8.4 ครั้ง เร็วกว่า Python 2.7

พบจำนวนเต็ม 10,000 ในกราฟโดยใช้อัลกอริธึมการค้นหาเชิงลึกก่อน*

เพิ่มภาษา Swift แล้ว
เข้าสู่หลักสูตร

ไม่เพียงแต่นักพัฒนาเท่านั้นที่ชื่นชมศักยภาพ ภาษาที่รวดเร็ว- มหาวิทยาลัยและสถาบันการศึกษาอื่นๆ สอน Swift ในชั้นเรียนเขียนโปรแกรมและเผยแพร่หลักสูตรฟรีบน iTunes U ซึ่งหมายความว่าแม้แต่ผู้เริ่มต้นก็สามารถเปลี่ยนจากการเขียนโค้ดขั้นพื้นฐานไปเป็นการเขียนโปรแกรมระดับมืออาชีพได้อย่างง่ายดาย

มหาวิทยาลัยที่รวม Swift ไว้ในหลักสูตร

• มหาวิทยาลัยแคลิฟอร์เนียที่ซานตาครูซ
• วิทยาลัยตีนเขา
• มหาวิทยาลัยเทคโนโลยีรอยัลเมลเบิร์น
• มหาวิทยาลัยเทคนิคแห่งมิวนิก
• วิทยาลัยชุมชนลอว์สัน
• วิทยาลัยชุมชนแมนฮัตตัน

• วิทยาลัยชุมชนเมซา
• วิทยาลัยชุมชนฮูสตัน
• วิทยาลัยชุมชนเซ็นทรัลพีดมอนต์
• มหาวิทยาลัยพลีมัธ
• มหาวิทยาลัยโพลีเทคนิคแห่งรัฐแคลิฟอร์เนีย
• มหาวิทยาลัยสแตนฟอร์ด

• วิทยาลัยเทคนิคแคนซัสตะวันตกเฉียงเหนือ
• สถาบันเทคโนโลยีแห่งมอนเตร์เรย์
• มหาวิทยาลัยอเบอริสต์วิธ
• มหาวิทยาลัย Sail เต็มรูปแบบ
• โรงเรียนอิงทรัพย์
• มหาวิทยาลัยเซาเทิร์นเมธอดิสต์

Swift มีอยู่ทุกที่
และตอนนี้ก็เปิดให้ทุกคนแล้ว

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

พบกับสวิฟท์

บัญชีแยกประเภททั่วไป

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

เอ็กซ์โค้ด

Xcode เป็นแอปพลิเคชัน Mac ที่ออกแบบมาเพื่อพัฒนาแอปพลิเคชันอื่นๆ สำหรับ Mac และ iOS Xcode มีเครื่องมือทั้งหมดที่คุณต้องการเพื่อสร้างแอปที่น่าทึ่ง สามารถดาวน์โหลดได้ฟรีจาก Mac App Store

เว็บไซต์นักพัฒนา

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

อัปเดตครั้งล่าสุด: 12/25/2017

อุปกรณ์ Apple เป็นผู้นำที่ได้รับการยอมรับในสาขานี้ เทคโนโลยีสารสนเทศ- จากข้อมูลล่าสุด ส่วนแบ่งของ iOS ในบรรดาระบบปฏิบัติการมือถืออื่นๆ มีความผันผวนประมาณ 15-20% และส่วนแบ่งของ Mac OSX ในหมู่ ระบบเดสก์ท็อปตามแหล่งต่าง ๆ คือ 15-20% การใช้อุปกรณ์ Apple อย่างแพร่หลายเช่นนี้ทำให้เกิดความต้องการซอฟต์แวร์สำหรับอุปกรณ์เหล่านี้

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

Swift เป็นภาษาโปรแกรมเชิงวัตถุล้วนๆ

ความเรียบง่าย ไวยากรณ์ที่ชัดเจนและกระชับ

การพิมพ์ที่เข้มงวด ตัวแปรแต่ละตัวมีประเภทเฉพาะ

การจัดการหน่วยความจำอัตโนมัติ

อย่างไรก็ตาม Swift สามารถใช้งานร่วมกับ Cocoa API ที่เขียนไว้ก่อนหน้านี้ซึ่งใช้ C และ Objective-C ได้อย่างสมบูรณ์

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

Swift เป็นภาษาโปรแกรมคอมไพล์ นั่นคือนักพัฒนาเขียนซอร์สโค้ดแล้วใช้คอมไพเลอร์เพื่อคอมไพล์โค้ดนี้ลงไป โปรแกรมควบคุม- ไฟล์โปรแกรมนี้สามารถอัปโหลดไปยัง AppStore และแจกจ่ายให้กับผู้ใช้รายอื่นได้

คุณต้องพัฒนาอะไรบ้างสำหรับ iOS?

ก่อนอื่น คุณต้องมีระบบปฏิบัติการที่เหมาะสม Mac OS 10.12 Yosemite หรือสูงกว่า หากไม่มี Mac OS แทบจะเป็นไปไม่ได้เลยที่จะคอมไพล์โปรแกรม สถานการณ์นี้จำกัดความเป็นไปได้ในการพัฒนาอย่างมาก เนื่องจาก Mac OS สามารถรับประกันได้ว่าจะทำงานบนคอมพิวเตอร์ Apple เท่านั้น (iMac, MacBook, MacBook Air, MacBook Pro) และยังทำให้คอมพิวเตอร์เครื่องเดียวกันเหล่านี้มีราคาสูงอีกด้วย อย่างไรก็ตาม แทบจะเป็นไปไม่ได้เลยที่จะสร้างแอปพลิเคชันสำหรับ iOS และ Mac OS บนพีซีทั่วไปที่ใช้ระบบปฏิบัติการ Windows หรือ Linux

นอกจากนี้ยังมีตัวเลือกด้วย เครื่องเสมือนที่ติดตั้ง Mac OS หรือใช้ Hackintosh อย่างไรก็ตาม ไม่รับประกันประสิทธิภาพของตัวเลือกดังกล่าว

มีตัวเลือกอื่น - การเขียนโค้ดในส่วนที่มีอยู่ ระบบปฏิบัติการและเรียบเรียงด้วย บริการพิเศษโดยมีค่าธรรมเนียมไปฟรี แต่เป็นที่ชัดเจนว่าความสะดวกสบายของแนวทางดังกล่าวต่ำมาก

โดยตรงสำหรับการพัฒนานั้น เราจะต้องมีเครื่องมือภาษา Swift โปรแกรมแก้ไขข้อความสำหรับการเขียนโค้ด, เครื่องจำลอง iPhone และ iPad สำหรับการดีบักแอปพลิเคชัน สำหรับคุณสมบัติการพัฒนาทั้งหมดเหล่านี้และอื่นๆ อีกมากมาย Apple มอบสภาพแวดล้อมการพัฒนา XCode ฟรี

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

การลงทะเบียนนักพัฒนา

และก่อนที่คุณจะเริ่มสร้างแอปพลิเคชัน คุณต้องลงทะเบียนใน Apple Developer Center ก่อน โดยไปที่ลิงค์ https://developer.apple.com/register/:

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