อยากรู้ทุกอย่าง. ภาษาคอตลิน

ภาษาโปรแกรม Kotlin พัฒนาโดย JetBrains บริษัทเซนต์ปีเตอร์สเบิร์ก ได้กลายเป็นภาษาพัฒนาอย่างเป็นทางการสำหรับ Android มีการประกาศอย่างเป็นทางการในการประชุม Google I/O ทีม Kotlin นำโดย Andrey Breslav บัณฑิตจากมหาวิทยาลัย ITMO เหตุใด Kotlin จึงเป็นที่รักของยักษ์ใหญ่ด้านไอทีในบรรดาภาษา "รุ่นใหม่" อื่น ๆ อย่างไรและทำไมภาษาการเขียนโปรแกรมใหม่จึงปรากฏโดยทั่วไปอ่านในความคิดเห็นของผู้เชี่ยวชาญและการรวบรวมข้อมูลของ ITMO.NEWS

วิธีการพัฒนาภาษาโปรแกรม

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

« โปรแกรมเมอร์ไม่พอใจกับภาษา C++ และ Java อย่างสมบูรณ์ เนื่องจากเป็นภาษาเหล่านี้ค่อนข้างซับซ้อน และภาษาแรกนั้นยากกว่าภาษาที่สอง ดังนั้นภาษาสกาล่าจึงปรากฏขึ้นซึ่งโปรแกรมเมอร์หลายคนชอบ แต่ก็ซับซ้อนมากเช่นกัน ประสบการณ์มากมายของ JetBrains ในการสร้างเครื่องมือพัฒนาโปรแกรมสำหรับภาษาโปรแกรมต่างๆ ทำให้สามารถสร้างภาษา Kotlin ได้ภายในเจ็ดปี ซึ่งเข้ากันได้กับ Java อย่างสมบูรณ์ แต่ง่ายกว่าและสะดวกกว่า ภาษาการเขียนโปรแกรมได้รับการพัฒนาอย่างต่อเนื่อง ไม่มีใครกำหนดหน้าที่ในการสร้างภาษาสากลอีกต่อไป อย่างไรก็ตาม แต่ละภาษาก็มีประสิทธิภาพมากกว่าในบางพื้นที่ที่มีการใช้บ่อยที่สุด มีแม้กระทั่งทิศทางในการสร้างภาษาเมื่อได้รับการพัฒนาสำหรับสาขาวิชาเฉพาะ" หัวหน้าภาควิชาเทคโนโลยีการเขียนโปรแกรม มหาวิทยาลัย ITMO ให้ความเห็น

ปัจจุบัน บางบริษัทถึงกับรวบรวมการให้คะแนนภาษาของตนเองด้วยซ้ำ ตัวอย่างเช่น บริษัท TIOBE ซึ่งเชี่ยวชาญในการประเมินคุณภาพของซอฟต์แวร์ ได้คำนวณดัชนีความนิยมของบางภาษาทุกเดือนตั้งแต่ปี 2544 รายการที่สร้างขึ้นประกอบด้วย 50 บรรทัด และเพื่อที่จะรวมภาษาการเขียนโปรแกรมไว้ในดัชนี นักพัฒนาจะต้องเขียนจดหมายที่เกี่ยวข้องถึงบริษัท การคำนวณขึ้นอยู่กับข้อมูลจากเครื่องมือค้นหาทางอินเทอร์เน็ต 25 รายการ จนถึงตอนนี้ Java เป็นผู้นำในการจัดอันดับด้วยอัตรากำไรขั้นต้นที่กว้าง ตามมาด้วย C ในขณะเดียวกันผู้รวบรวมรายการเน้นย้ำว่าในปีที่ผ่านมา ภาษาโปรแกรมทั้งสองภาษาได้รับความนิยมน้อยลงประมาณ 6% ในเวลาเดียวกัน TIOBE แสดงให้เห็นว่า C เป็นภาษาอันดับ 1 จนถึงปี 2545 และ Java อยู่ในอันดับที่ 14 ในปี 1997 แต่ห้าปีต่อมาก็เข้ามาแทนที่ C ในตำแหน่งแรก

คุณสามารถบรรยายที่ยอดเยี่ยมเกี่ยวกับประวัติความเป็นมาของการพัฒนาภาษา: ภัณฑารักษ์หลักสูตรการศึกษาที่ Yandex ผู้อำนวยการศูนย์การแข่งขันนักเรียนที่คณะวิทยาการคอมพิวเตอร์ที่โรงเรียนเศรษฐศาสตร์ชั้นสูงพูดถึงภาษา C , PHP, Ruby และ Java ปรากฏขึ้น มิคาอิล กุสโตคาชิน- อาจารย์เน้นย้ำว่าควรเลือกภาษาการเขียนโปรแกรมที่แตกต่างกันสำหรับแต่ละงาน ตัวอย่างเช่น เขาบอกว่าสำหรับอุตสาหกรรมการทหาร วิธีที่ดีที่สุดคือเขียนด้วยภาษาปาสคาลเก่าๆ ซึ่งเป็นภาษาที่เกิดในปี 1970! ทำไม เพราะมันน่าเชื่อถือกว่า แอปพลิเคชันทางธุรกิจสามารถเขียนด้วยภาษา Java ได้เนื่องจากภาษานี้ค่อนข้างน่าเชื่อถือ แต่ใช้งานง่ายกว่ามาก ผู้เชี่ยวชาญยังเน้นย้ำว่าการรักษาความสนใจในภาษาในหมู่โปรแกรมเมอร์เป็นสิ่งสำคัญโดยการสร้างชุมชนนักพัฒนาที่เขียนด้วยภาษานี้ หากมีการสร้างโครงสร้างพื้นฐานสำหรับภาษาใหม่และผู้คนรวมตัวกันเพื่อใช้ภาษานั้น ภาษานั้นจึงจะได้รับความนิยม อย่างไรก็ตาม นักพัฒนา Kotlin ยังได้นำกลยุทธ์นี้ไปใช้ด้วย

เล็กน้อยเกี่ยวกับ Kotlin

ภาษาโปรแกรม Kotlin เริ่มได้รับการพัฒนาที่บริษัท JetBrains ในเซนต์ปีเตอร์สเบิร์กในปี 2010 เปิดตัวผลิตภัณฑ์อย่างเป็นทางการในปี 2559 ภาษานี้ได้รับชื่อนี้เพื่อเป็นเกียรติแก่เกาะในอ่าวฟินแลนด์ซึ่งเป็นที่ตั้งของครอนสตัดท์ ด้วยความบังเอิญที่น่าสนใจ ชื่อของภาษาชวายอดนิยมก็เป็นชื่อของเกาะในประเทศอินโดนีเซียด้วย ความบังเอิญคงไม่ใช่เรื่องบังเอิญ ตามที่ระบุไว้ในข่าวประชาสัมพันธ์ Kotlin ควรทำงานทุกที่ที่ Java ทำงาน และหนึ่งในเป้าหมายคือการสร้างผลิตภัณฑ์ที่สามารถใช้ในโครงการผสมที่สร้างขึ้นในหลายภาษา

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

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

ทำไม Google ถึงชอบ Kotlin

บนเว็บไซต์อย่างเป็นทางการ นักพัฒนา Android เขียนว่าพวกเขาสังเกตเห็น "การเพิ่มขึ้น" ของ Kotlin ในช่วงไม่กี่ปีที่ผ่านมา ชาว Google ไม่อายที่จะอธิบายว่าภาษานั้นน่าประทับใจ กระชับ ทรงพลัง และสนุกสนานในการทำงานด้วย มีประสิทธิผลเพิ่มขึ้น: โค้ดโปรแกรมในนั้นสั้นกว่าภาษาอื่นโดยเฉลี่ย 40% และ Kotlin ยังช่วยให้คุณหลีกเลี่ยงข้อผิดพลาดในโค้ดได้อีกด้วย ปัจจัยหนึ่งที่กำหนดความนิยมของ Kotlin ใน Google ก็คือมันเข้ากันได้กับ Java ซึ่งใช้ในการพัฒนาแอปพลิเคชันสำหรับ Android แล้ว

ตอนนี้ เมื่อโปรแกรมเมอร์เริ่มสร้างแอปพลิเคชันใหม่ในสภาพแวดล้อมการพัฒนา Android Studio อย่างเป็นทางการ พวกเขาสามารถเปิดใช้งานปลั๊กอิน “การสนับสนุน Kotlin” ได้ทันที คุณยังสามารถแปลงบรรทัดโค้ดที่สร้างไว้แล้วในภาษาอื่นเป็นภาษา Kotlin แทรกบล็อกในภาษาอื่นลงในบรรทัดของโค้ดใน Kotlin ในอนาคต จะมีการพัฒนาห้องสมุดและเครื่องมือสำหรับภาษามากขึ้น มีการพัฒนาสื่อการฝึกอบรมเพิ่มเติม และจะหาแนวทางแก้ไขปัญหาที่เป็นไปได้ได้ง่ายขึ้น

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

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

Google ยังเน้นย้ำว่าพวกเขาได้รับแรงบันดาลใจจากแนวคิดของภาษา Kotlin ตามที่นักพัฒนาใช้มาโดยตลอดและจะยังคงฟรีสำหรับนักพัฒนานั่นคือโครงการโอเพ่นซอร์ส ซึ่งหมายความว่าภาษาไม่ได้เชื่อมโยงกับบริษัทใดๆ และซอร์สโค้ดได้รับการเผยแพร่ภายใต้ใบอนุญาตฟรี คุณสามารถดาวน์โหลดผลิตภัณฑ์ เพื่อสนับสนุนการพัฒนา Kotlin นั้น Google และ JetBrains จะสร้างความร่วมมือที่ไม่แสวงหากำไร นอกจากนี้ ในฐานะที่เป็นส่วนหนึ่งของ "ภารกิจ" ของ Android สิ่งสำคัญอย่างยิ่งคือผู้เขียน Kotlin จะต้องสร้างชุมชนผู้คนที่เกี่ยวข้องกับผลิตภัณฑ์ของตนที่มีส่วนร่วมอย่างมืออาชีพในการพัฒนาในภาษานี้และชอบที่จะแบ่งปันประสบการณ์ของพวกเขา ตัวอย่างเช่น ในเดือนพฤศจิกายน การประชุม Kotlin จะจัดขึ้นในสหรัฐอเมริกา และนักพัฒนายังสามารถรับข่าวสารรายวันและเคล็ดลับเกี่ยวกับผลิตภัณฑ์ซอฟต์แวร์และพบปะในพื้นที่ได้

อย่างไรก็ตาม โครงการ Android Studio นั้นได้รับการพัฒนาบนพื้นฐานของสภาพแวดล้อมการพัฒนาซอฟต์แวร์ IntelliJ IDEA ซึ่งสร้างโดย JetBrains เช่นกัน แต่ถึงแม้จะมีความร่วมมืออย่างใกล้ชิด แต่บริษัทในเซนต์ปีเตอร์สเบิร์กก็เน้นย้ำว่าไม่มีการพูดถึงการขาย JetBrains ให้กับยักษ์ใหญ่ด้านไอทีของอเมริกา ในขณะเดียวกัน Koltin จะไม่ได้รับการออกแบบสำหรับ Android เท่านั้น เป้าหมายของบริษัทคือการทำให้ภาษาการเขียนโปรแกรมเหมาะสมกับแพลตฟอร์มการพัฒนาต่างๆ

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

11/07/2011 อันเดรย์ เบรสลาฟ

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

ประวัติความเป็นมาของการพัฒนาภาษา "ทางเลือก" บนแพลตฟอร์ม Java ย้อนกลับไปกว่าทศวรรษ แต่ภาษาดังกล่าวได้แพร่หลายไปเมื่อไม่นานมานี้เท่านั้น JRuby, Groovy และ Clojure ได้รับความนิยมเพิ่มขึ้นด้วยภาษาที่พิมพ์แบบไดนามิก ในขณะที่ภาษาที่พิมพ์แบบคงที่ ได้แก่ Scala, Fantom และ Gosu ภาษา Java เองก็ไม่ได้หยุดนิ่งเช่นกัน แต่การพัฒนานั้นซับซ้อนทั้งจากความจำเป็นในการรักษาความเข้ากันได้แบบย้อนหลังและจากชะตากรรมที่ยากลำบากของ Sun Microsystems ซึ่งถูกดูดซับโดย Oracle Corporation

เมื่อเทียบกับพื้นหลังนี้ โครงการ JetBrains ใหม่ซึ่งมีชื่อรหัสว่า Kotlin (เน้นที่ "o") ในแง่หนึ่งดูเหมือนเกือบจะเป็นเครื่องบรรณาการให้กับแฟชั่นและในทางกลับกันก็ถูกรายล้อมไปด้วยคู่แข่งจำนวนมากที่เห็นได้ชัดเจน อย่างไรก็ตาม เราค่อนข้างมั่นใจในสถานการณ์นี้ และมีเหตุผลหลายประการสำหรับเรื่องนี้ ประการแรก JetBrains ได้รับการพัฒนาสภาพแวดล้อมการพัฒนาแบบบูรณาการสำหรับภาษาการเขียนโปรแกรมที่หลากหลาย (หลายภาษาทำงานบนแพลตฟอร์ม Java) มานานกว่าทศวรรษ และได้สร้างทีมผู้เชี่ยวชาญที่แข็งแกร่งและมีประสบการณ์มากมายในภาษาการเขียนโปรแกรมและภาษาที่เกี่ยวข้อง เทคโนโลยี ประการที่สอง เราไม่สามารถพูดได้ว่าภาษาใด ๆ ที่มีอยู่ในแพลตฟอร์ม Java ตรงตามความต้องการของเรา และเราเชื่อว่าตามข้อเสนอแนะเบื้องต้นจากโปรแกรมเมอร์ทั่วโลก ว่าเพื่อนร่วมงานของเราในบริษัทอื่น ๆ กำลังประสบปัญหาที่คล้ายกัน

การพัฒนาโครงการ Kotlin เริ่มขึ้นในฤดูร้อนปี 2553 ในเดือนกรกฎาคม 2554 มีการประกาศโครงการอย่างเป็นทางการและมีการโพสต์คำอธิบายของภาษาบนเว็บไซต์ คอมไพเลอร์เวอร์ชันเบต้าสาธารณะมีการวางแผนในต้นปี 2555

เมื่อสร้างภาษา เราได้รับคำแนะนำจากข้อกำหนดหลายประการที่ดูเหมือนสำคัญที่สุดสำหรับโครงการดังกล่าว

เข้ากันได้กับจาวาแพลตฟอร์ม Java มาก่อน ระบบนิเวศ: นอกเหนือจากผลิตภัณฑ์ "อย่างเป็นทางการ" ของ Oracle แล้ว ยังรวมถึงโครงการโอเพ่นซอร์สอีกมากมาย: ไลบรารีและเฟรมเวิร์กของโปรไฟล์ต่างๆ ซึ่งมีการสร้างแอปพลิเคชันจำนวนมาก ดังนั้นสำหรับภาษาที่คอมไพล์สำหรับแพลตฟอร์มนี้ ความเข้ากันได้กับโค้ดที่มีอยู่ซึ่งเขียนด้วย Java จึงมีความสำคัญมาก ในขณะเดียวกันก็จำเป็นที่โปรเจ็กต์ที่มีอยู่จะค่อยๆ เปลี่ยนไปใช้ภาษาใหม่ได้ กล่าวคือ ไม่เพียงแต่โค้ด Kotlin เท่านั้นที่ควรเรียกโค้ด Java ได้อย่างง่ายดาย แต่ยังในทางกลับกันด้วย

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

ความเร็วในการรวบรวมการตรวจสอบแบบคงที่ทำให้การเขียนโปรแกรมง่ายขึ้น แต่จะทำให้การคอมไพล์ช้าลง และยังมีความสมดุลที่ต้องแก้ไข ประสบการณ์ในการสร้างภาษาด้วยระบบการพิมพ์ที่ทรงพลัง (Scala เป็นตัวอย่างที่โดดเด่นที่สุด) แสดงให้เห็นว่าความสมดุลนี้หาไม่ได้ง่าย: การคอมไพล์มักจะยาวจนไม่อาจยอมรับได้ โดยทั่วไปลักษณะของภาษาเช่นเวลาในการรวบรวมโครงการอาจดูเหมือนมีความสำคัญรอง แต่ในเงื่อนไขการพัฒนาทางอุตสาหกรรมเมื่อปริมาณของโค้ดที่คอมไพล์มีขนาดใหญ่มากปรากฎว่าปัจจัยนี้มีความสำคัญมาก - หลังจากนั้นในขณะที่ มีการคอมไพล์โค้ดโปรแกรมเมอร์มักจะไม่สามารถทำงานต่อไปได้ โดยเฉพาะอย่างยิ่งการคอมไพล์อย่างรวดเร็วเป็นหนึ่งในข้อดีที่สำคัญของ Java เหนือ C++ และ Kotlin ควรรักษาข้อได้เปรียบนี้ไว้

ความกระชับ.เป็นที่ทราบกันดีว่าโปรแกรมเมอร์มักจะใช้เวลาในการอ่านโค้ดมากกว่าการเขียนโค้ด ดังนั้นจึงเป็นเรื่องสำคัญที่โครงสร้างที่มีอยู่ในภาษาการเขียนโปรแกรมจะช่วยให้คุณสามารถเขียนโปรแกรมได้อย่างกระชับและชัดเจน Java ถือเป็นภาษาพิธีการและ Kotlin มีเป้าหมายที่จะปรับปรุงสถานการณ์ในเรื่องนี้ น่าเสียดายที่วิธีการที่เข้มงวดในการประเมินภาษาในแง่ของความกระชับนั้นค่อนข้างพัฒนาได้ไม่ดี แต่มีเกณฑ์ทางอ้อม หนึ่งในนั้นคือความสามารถในการสร้างไลบรารี่ที่ทำงานใกล้ตัว ภาษาเฉพาะโดเมน(ภาษาเฉพาะโดเมน, DSL) ในการสร้างไลบรารีดังกล่าว จำเป็นต้องมีความยืดหยุ่นทางไวยากรณ์บางอย่างร่วมกับ การก่อสร้างลำดับที่สูงขึ้น- ที่พบบ่อยที่สุดคือฟังก์ชันลำดับที่สูงกว่า นั่นคือ ฟังก์ชันที่รับฟังก์ชันอื่นเป็นพารามิเตอร์

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

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

องค์ประกอบพื้นฐานของภาษา

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

การประกาศใน Kotlin จะรวมกันเป็น เนมสเปซ(เนมสเปซ) และฟังก์ชันสามารถประกาศได้โดยตรงภายในเนมสเปซ:

เนมสเปซตัวอย่าง ( สนุกสูงสุด(a: Int, b: Int) : Int ( ถ้า(การกลับมา กลับข ) )

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

ตัวแปรใน Kotlin เช่นเดียวกับใน Scala พวกเขาจะถูกประกาศโดยใช้คำหลัก วาล(ตัวแปรที่ไม่เปลี่ยนรูป) และ var(เปลี่ยนแปลงได้):

var sinSum: สองเท่า = 0.0 สำหรับ(x ใน xs) { วาล y = บาป(x) บาป += y )

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

ชั้นเรียนเครื่องมือการแยกส่วนหลักใน Kotlin เช่นเดียวกับภาษาเชิงวัตถุอื่นๆ คือคลาส เมื่อประกาศคลาส รายการพารามิเตอร์คอนสตรัคเตอร์จะถูกระบุโดยตรงในส่วนหัว:

ระดับ IntPair(x: Int, y: Int) (...)

อินสแตนซ์ของคลาสถูกสร้างขึ้นโดยการเรียกตัวสร้างโดยตรง คำสำคัญ ใหม่ใน Kotlin ไม่มี:

วาล xy = IntPair(x, y)

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

ระดับ MyList (ความยาว: Int): List , Serializable (...)

ลักษณะ.คลาสสามารถสืบทอดจากคลาสเดียวหรือหลายคลาสได้ ลักษณะ(ลักษณะ - อักษร "ลักษณะเฉพาะ" คุณลักษณะ) ลักษณะจะคล้ายกับคลาสตรงที่พวกมันยังกำหนดประเภท สามารถมีฟังก์ชันสมาชิกได้ และสืบทอดจากคุณสมบัติอื่น ๆ ความแตกต่างที่สำคัญคือลักษณะไม่มีตัวสร้างและด้วยเหตุนี้จึงไม่มี สถานะ(เขตข้อมูล) เราสามารถพูดได้ว่าคุณลักษณะนั้นเป็นอินเทอร์เฟซที่คุ้นเคยจากภาษา Java เท่านั้น มีเพียงฟังก์ชันในนั้นเท่านั้นที่สามารถนำไปใช้ได้ ข้อจำกัดเกี่ยวกับลักษณะจะหลีกเลี่ยงปัญหาที่เกี่ยวข้องกับการสืบทอดหลายคลาส

ฟังก์ชั่นภายนอกกลไกอีกประการหนึ่งสำหรับประเภท "การขยาย" ใน Kotlin คือฟังก์ชันภายนอก (ฟังก์ชันส่วนขยาย) ฟังก์ชั่นดังกล่าวสามารถประกาศนอกคลาสได้และยังคงถูกเรียกเหมือนกับว่าถูกประกาศไว้ภายใน นี่คือตัวอย่างการประกาศฟังก์ชันภายนอกสำหรับประเภท Int:

สนุก Int.abs() : Int ( ถ้า(นี้กลับ -นี้ อื่น คืนสิ่งนี้ }

ประเภทที่ฟังก์ชันกำหนดขยายจะถูกระบุหน้าชื่อและคั่นด้วยจุด ซึ่งสอดคล้องกับการประกาศพารามิเตอร์ "โดยนัย" ซึ่งระบุภายในฟังก์ชันด้วยคำหลัก นี้- ตัวอย่างเช่น ในตัวอย่างของเรา ฟังก์ชัน abs() จะขยายประเภท Int และพารามิเตอร์โดยนัย นี้เป็นจำนวนเต็ม ฟังก์ชันดังกล่าวสามารถเรียกได้โดยใช้การดำเนินการ "dot" เช่นเดียวกับฟังก์ชันสมาชิกของคลาส:

วาล x = (-1).เอบีเอส()

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

ฟังก์ชันภายนอกผูก แบบคงที่นั่นคือพวกมันไม่ใช่เสมือนจริง

โครงสร้างการควบคุม เมื่อไร

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

เมื่อไร(x) ( 1 => พิมพ์("หนึ่ง") 2, 3 => พิมพ์("สองหรือสาม") อื่น=> print("หมายเลขที่ไม่รู้จัก") )

ทางด้านซ้ายของเครื่องหมาย "=>" คือนิพจน์หรือรายการนิพจน์ที่คั่นด้วยเครื่องหมายจุลภาคที่เรียกว่า เงื่อนไข- ถ้า การโต้แย้งการออกแบบ เมื่อไร(ในตัวอย่างของเรา ตัวแปร x) เท่ากับอย่างน้อยหนึ่งในนิพจน์เหล่านี้ เนื้อความของเงื่อนไขนี้จะถูกดำเนินการ นั่นคือนิพจน์หรือบล็อกที่ระบุทางด้านขวาของเครื่องหมาย “=>” มีการตรวจสอบเงื่อนไขตามลำดับจากบนลงล่าง หากไม่มีเงื่อนไขใดตรงไป รหัสจะระบุหลังจากดำเนินการคำนั้น อื่น- ไม่เหมือน สวิตช์, โดยใช้ เมื่อไรเงื่อนไขไม่ใช่ป้ายกำกับ ดังนั้นจึงไม่จำเป็นต้องลงท้ายเนื้อหาของเงื่อนไขด้วยคำนั้น หยุดพัก.

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

เมื่อไร(x) ( ใน set => พิมพ์ (“ในชุด”) ใน 1..10 => พิมพ์(“1..10”) อื่น=> print("สาขาเริ่มต้น") )

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

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

เมื่อไร(x) ( เป็นสตริง => println("สตริง") เป็น Int => println("Int") เป็น Array => println("Array of Double") )

ประเภทระบบ

ลิงก์เป็นศูนย์ระบบประเภทภาษา Kotlin ช่วยให้มั่นใจได้ว่าโปรแกรมไม่มีข้อผิดพลาดบางประเภท เช่น การเปลี่ยนเส้นทางการอ้างอิงแบบ null ประเภทใน Kotlin แบ่งออกเป็นประเภทที่มี โมฆะและไม่มี โมฆะ- ประเภทที่มี โมฆะโดยมีเครื่องหมายคำถามกำกับไว้ว่า

สนุก isEmpty(s: String?): บูลีน (...)

เครื่องหมายคำถามหลังชื่อประเภท (สตริง) หมายความว่าการอ้างอิงชี้ไปที่อ็อบเจ็กต์ของคลาส String หรือเรื่องต่างๆ โมฆะ - ผลลัพธ์ของฟังก์ชัน isEmpty จะต้องเป็นค่าบูลีนและไม่สามารถมีค่าได้ โมฆะเนื่องจากประเภทที่เกี่ยวข้องไม่มีเครื่องหมายคำถามกำกับไว้

กลับ s.length() == 0 // ข้อผิดพลาด: การยกเลิกการอ้างอิงที่เป็นโมฆะ

คุณต้องตรวจสอบอย่างชัดเจนว่า s อ้างถึงวัตถุที่มีอยู่หรือไม่:

ฉัน ฉ (ส != โมฆะ) { กลับ s.length() == 0 // s อ้างอิงถึงวัตถุที่มีอยู่อย่างแน่นอน) อื่น{ กลับเป็นจริง} กลับ(ส == โมฆะ- s.length() == 0//Operator||ให้การยืนยัน

มักจะมีการโทรเป็นสายยาว ซึ่งแต่ละสายสามารถโทรกลับได้ โมฆะ- ผลลัพธ์คือเงื่อนไขที่ซ้อนกันหลายรายการที่จะตรวจสอบสิ่งที่การเรียกแต่ละครั้งในสายโซ่ส่งคืน เพื่อหลีกเลี่ยงไม่ให้โค้ดยุ่งเหยิง Kotlin รองรับโอเปอเรเตอร์ โทรอย่างปลอดภัย, แสดงโดย "?.":

A?.getB()?.getC()?.getD()

ถ้า a ไม่เท่ากัน โมฆะนิพจน์ a?.getB() ส่งคืน a.getB() มิฉะนั้น - โมฆะ.

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

วาล x: วัตถุ = ... ถ้า(x คือ String) ( print(x.length()) )

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

การหล่อแบบอัตโนมัติใช้ได้กับทุกเงื่อนไข: ถ้า, เมื่อไร, ในขณะที่, ||, && ฯลฯ

ฟังก์ชั่นลำดับที่สูงขึ้น

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

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

วาลภาคแสดง: สนุก(x: Int): บูลีน =...

ในตัวอย่างนี้ ตัวแปรภาคแสดงมี ประเภทการทำงาน « สนุก(x: Int): Boolean" หมายถึงค่าที่เก็บไว้เป็นฟังก์ชันที่รับพารามิเตอร์จำนวนเต็มและส่งกลับค่าบูลีน โดยเฉพาะเราสามารถเรียกฟังก์ชันนี้:

วาล yesOrNo = ภาคแสดง (1)

สามารถใช้ฟังก์ชันดังกล่าวได้ เช่น เมื่อกรองชุดจำนวนเต็ม:

สนุกคอลเลกชัน .intFilter (ภาคแสดง: สนุก(x: Int): บูลีน): คอลเลกชัน (...)

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

สนุกคอลเลกชัน .filter (ภาคแสดง: สนุก(x: T) : บูลีน) : คอลเลกชัน ( วาลผลลัพธ์ = ArrayList() สำหรับ(x ในเรื่องนี้) ถ้า (ภาคแสดง(x)) result.add(x) กลับผลลัพธ์)

(นี่เป็นเพียงการใช้งานฟังก์ชัน filter() แบบไร้เดียงสา การใช้งานที่สมจริงกว่านี้จะต้องมีการประเมินแบบสันหลังยาว แต่นั่นอยู่นอกเหนือขอบเขตของบทความนี้)

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

Ints.filter((x => x % 2 == 0))

ในตัวอย่างนี้ อาร์กิวเมนต์ของฟังก์ชันภายนอก filter() คือฟังก์ชันลิเทอรัล นั่นคือการประกาศฟังก์ชันแบบสั้น จะต้องอยู่ในเครื่องหมายปีกกาก่อนที่สัญลักษณ์ “=>” จะมีการประกาศพารามิเตอร์และหลังจากนั้นจะมีเนื้อความของฟังก์ชันและไม่จำเป็นต้องใช้คำสั่ง return เนื่องจากจะพิจารณาผลลัพธ์ การแสดงออกครั้งสุดท้ายในร่างกายของตัวอักษร ดังนั้นจากคอลเลกชัน ints จะถูกเลือก เลขคู่เท่านั้นเนื่องจากค่าตามตัวอักษรของเราจะคืนค่าเป็นจริงก็ต่อเมื่อเศษของ x หารด้วย 2 เป็นศูนย์เท่านั้น

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

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

Ints.filter((it % 2 == 0)) // โทรคล้ายกับตัวอย่างก่อนหน้า

ประการที่สอง หากอาร์กิวเมนต์สุดท้ายของการเรียกใช้ฟังก์ชันเป็นฟังก์ชันลิเทอรัล อาร์กิวเมนต์นั้นสามารถส่งผ่านนอกวงเล็บได้ และหากไม่มีอาร์กิวเมนต์อื่น ก็สามารถละเว้นวงเล็บได้:

Ints.filter (it % 2 == 0) // โทรคล้ายกับสองตัวอย่างก่อนหน้านี้

ไวยากรณ์นี้ช่วยให้คุณสามารถเขียนการแปลงคอลเลกชันในรูปแบบที่ชวนให้นึกถึง LINQ:

Ints.select(มัน * มัน) โดยที่ (มัน % 2 == 0) // ท่ามกลางกำลังสองขององค์ประกอบคอลเลกชัน // เลือกคู่

(ในที่นี้ฟังก์ชันwhere()ทำหน้าที่เหมือนกับฟังก์ชันfilter())

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

สนุกซิงโครไนซ์ (l: ล็อค, เนื้อหา: สนุก() : T) : T ( l.ล็อค() พยายาม{ กลับร่างกาย()) ในที่สุด( l.ปลดล็อค() ) )

หากต้องการเรียกส่วนของโค้ดที่ซิงโครไนซ์โดยใช้ฟังก์ชันนี้ เพียงแค่เขียน:

ซิงโครไนซ์ (myLock) ( // รหัสที่จะดำเนินการ )

ตัวอย่างนี้แสดงให้เห็นว่า Kotlin คุณสามารถใช้ภาษาเพื่อแสดงโครงสร้างที่มีอยู่แล้วภายใน Java ได้อย่างไร

ภาษาเฉพาะโดเมน

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

วาล homeDir = "..." module("org.jetbrains.test") ( // ขึ้นอยู่กับการประกาศโมดูล(MavenRepo(" [ป้องกันอีเมล]")) // การพึ่งพา importNamespace("java.lang") // ค่าเริ่มต้นการนำเข้า importNamespace("org.junit") // ค่าเริ่มต้นการนำเข้า sourceRoot("$homeDir/src") // พาธไปยังไฟล์ต้นฉบับ testSourceRoot(" $homeDir /tests") // เส้นทางสู่การทดสอบ )

แม้ว่านี่จะเป็นโปรแกรม Kotlin ธรรมดา แต่ดูเหมือนว่าโปรแกรมในภาษาพิเศษที่ออกแบบมาเพื่อคำอธิบายโมดูลที่เปิดเผย วิธีการอธิบายโครงสร้างข้อมูลนี้ได้รับความนิยมอย่างมากในภาษา Groovy และภาษาไดนามิกอื่นๆ เนื่องจากหลีกเลี่ยงคำอธิบายที่ยุ่งยากและอ่านยากที่เขียนด้วย XML ใน Groovy วิธีการนี้เรียกว่า Builders ตัวอย่างที่เด่นชัดของการใช้งานคือไลบรารี Gradle

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

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

// โมดูลบทคัดย่อ คลาสนามธรรมโมดูล (ชื่อ: สตริง) ( วาลการขึ้นต่อกัน: List = ArrayList() ) // โมดูลที่ประกอบด้วยคลาสที่เขียนด้วย Kotlin ระดับ KotlinModule (ชื่อ: String) : โมดูล (ชื่อ) ( สนุกการพึ่งพา (โมดูล: โมดูล) ( dependencies.add (โมดูล) ) ) // โมดูลตามที่เก็บ Maven ระดับ MavenRepo(ชื่อ: String) : โมดูล(ชื่อ) ( ... )

มากำหนดฟังก์ชัน module() ที่สร้างโมดูลใหม่:

สนุกโมดูล (ชื่อ: สตริง, เริ่มต้น: สนุก KotlinModule.() : หน่วย) : KotlinModule ( วาลผล = KotlinModule (ชื่อ) result.init () กลับผลลัพธ์)

ฟังก์ชันนี้เป็นฟังก์ชันลำดับที่สูงกว่า เนื่องจากพารามิเตอร์ init นั้นเป็นฟังก์ชันในตัวมันเอง และ ภายนอกฟังก์ชัน: ซึ่งระบุโดยประเภท KotlinModule ที่ระบุก่อนรายการพารามิเตอร์ (ว่าง) ในประเภทฟังก์ชัน ซึ่งหมายความว่าสามารถเรียกใช้ฟังก์ชัน module() ได้ดังนี้:

โมดูล (“org.jetbrains.test”) ( // เนื้อหาของฟังก์ชัน init)

ซึ่งคล้ายกับสถานการณ์ตัวอย่างที่เราได้เห็นไปแล้ว โปรดทราบว่าพารามิเตอร์โดยนัยมีอยู่ในฟังก์ชันลิเทอรัล นี้พิมพ์ KotlinModule (เนื่องจากตัวอักษรนี้เป็นประเภท "ฟังก์ชันภายนอก") และเราสามารถใช้มันได้:

โมดูล (“org.jetbrains.test”) ( นี้.การพึ่งพา(MavenRepo(" [ป้องกันอีเมล]")) นี้.dependency(anotherModule) // ... )

ยังคงเป็นที่น่าสังเกตว่า นี้ตามปกติสามารถละเว้นได้ และเราได้รับไวยากรณ์เหมือนกับในสคริปต์ตัวอย่างที่ให้ไว้ตอนต้นของส่วนนี้ทุกประการ:

โมดูล (“org.jetbrains.test”) ( การพึ่งพา (MavenRepo(" [ป้องกันอีเมล]")) การพึ่งพา (anotherModule) // ... )

ภาษาที่ประกาศหลายภาษารวมถึงภาษามาร์กอัปเช่น HTML สามารถนำไปใช้ในลักษณะเดียวกันได้ ในกรณีนี้ แทนที่จะใช้แท็ก จะใช้การเรียกไปยังฟังก์ชันลำดับที่สูงกว่า และการใช้ "แท็ก" ดังกล่าวอย่างถูกต้อง รวมถึงคุณลักษณะต่างๆ จะได้รับการรับประกันโดยระบบประเภท:

Html ( head ( title (+"การเข้ารหัส XML ด้วย Kotlin") ) body ( h1 (+"การเข้ารหัส XML ด้วย Kotlin") p ( +"นี่คือข้อความบางส่วน สำหรับข้อมูลเพิ่มเติม โปรดดูที่" a(href = "http:// jetbrains.com/kotlin") (+"หน้าแรกของ Kotlin") ) )

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

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

วรรณกรรม

1. Bloch J. Java ที่มีประสิทธิภาพ ฉบับที่สอง. - ห้องโถงฝึกหัด, 2551.
2. Gamma E., Helm R., Johnson R., Vlissides J. เทคนิคการออกแบบเชิงวัตถุ รูปแบบการออกแบบ - เซนต์ปีเตอร์สเบิร์ก: ปีเตอร์ 2550
3. ภาษาและแพลตฟอร์มการเขียนโปรแกรม Troelsen E. C# 2008 เน็ต 3.5 - ม.: วิลเลียมส์, 2010.

ยกเว้นในกรณีที่การรวบรวมแยกไม่สอดคล้องกัน - บันทึก ผู้เขียน.

การดำเนินการ is ยังช่วยให้คุณทำได้เช่นกัน การจับคู่รูปแบบ(การจับคู่รูปแบบ) - ประมาณ ผู้เขียน.

อันเดรย์ เบรสลาฟ ([ป้องกันอีเมล]) - ผู้พัฒนาชั้นนำของภาษา Kotlin บริษัท JetBrains

ในปี 2010 กลุ่มนักพัฒนาจาก JetBrains สาขารัสเซียได้เริ่มพัฒนาภาษาที่จะสะดวกและปลอดภัยต่อการพิมพ์มากกว่า Java แต่ไม่ซับซ้อนเท่ากับ Scala ชื่อของภาษานี้ตั้งชื่อเพื่อเป็นเกียรติแก่เกาะ Kotlin ซึ่งตั้งอยู่ในอ่าวฟินแลนด์ (โดยการเปรียบเทียบกับชวาซึ่งตั้งชื่อตามเกาะด้วย)

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

ไวยากรณ์

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

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

อย่างไรก็ตาม เราจะยังคงทิ้งโค้ดเล็กๆ น้อยๆ ไว้:

สนุกหลัก (args: Array ) {
ขอบเขตวาล = "โลก"
println("สวัสดี $ขอบเขต!")
}

รายการง่ายๆ อย่างยิ่งที่ใครก็ตามที่เคยเรียนการเขียนโปรแกรมที่โรงเรียนหรือมหาวิทยาลัยมาอย่างน้อยหนึ่งปีควรเข้าใจได้

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

ข้อดี

โดยทั่วไปแล้ว มีการกล่าวถึงข้อดีทั้งหมดเมื่อเปรียบเทียบกับ Java แล้ว ดังนั้นเราจะรวบรวมไว้ในที่เดียว:

ปริมาณรหัส การไม่ใช้โค้ดเก่าๆ ที่ไม่จำเป็นจะช่วยเร่งกระบวนการพัฒนาและเพิ่มความสามารถในการอ่าน

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

ความเข้ากันได้ใน Java สะดวกทั้งในแง่ของการเรียนรู้ภาษาใหม่และจากมุมมองของการค่อยๆ ถ่ายโอนผลิตภัณฑ์ซอฟต์แวร์ของคุณจาก Java ไปยัง Kotlin ตัวอย่างเช่น นี่คือสิ่งที่เกิดขึ้นกับแอปพลิเคชัน Basecamp

ข้อบกพร่อง

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

ขณะนี้ Kotlin จัดการกับงานหลักได้ และความเข้ากันได้อย่างสมบูรณ์กับ Java ช่วยให้เราปิดช่องว่างเหล่านี้ได้

อนาคต

แม้ว่าการพัฒนา Kotlin จะเริ่มในปี 2010 แต่เวอร์ชันอย่างเป็นทางการครั้งแรกนั้นเปิดตัวในเดือนกุมภาพันธ์ 2559 เท่านั้น ตั้งแต่นั้นมาความต้องการภาษาก็เพิ่มขึ้นอย่างรวดเร็ว โดยในการจัดอันดับ TIOBE ก็บุกเข้าสู่ TOP-50 ภายในหนึ่งปี และเมื่อเดือนที่แล้วที่การประชุม Google I /O ได้ประกาศการสนับสนุนอย่างเป็นทางการสำหรับ Kotlin ในระบบการพัฒนาแอปพลิเคชัน Android

เมื่อพิจารณาถึงความนิยมอย่างสูงของ IntelliJ IDEA ในหมู่นักพัฒนาและการมุ่งเน้นเชิงกลยุทธ์ของบริษัทที่ Kotlin เราสามารถพูดได้อย่างมั่นใจว่าภายใน 3-4 ปีเราจะได้เห็นมันเป็นหนึ่งในคู่แข่งที่เต็มเปี่ยมของ Java และ Swift ในด้านการพัฒนามือถือ นอกจากนี้ หากผู้สร้างภาษาไม่ผิดหวังกับผลิตภัณฑ์ของตน Kotlin ก็จะมุ่งไปสู่ขอบเขตอื่น ๆ อย่างจริงจังอย่างแน่นอน: เว็บ, AI, อินเทอร์เน็ตของสรรพสิ่ง, ข้อมูลขนาดใหญ่, แอปพลิเคชันเดสก์ท็อป

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

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

เกี่ยวกับโครงการ

ไม่นานมานี้ JetBrains บริษัทที่สร้างสภาพแวดล้อมการพัฒนา ได้ประกาศผลิตภัณฑ์ใหม่นั่นคือภาษาการเขียนโปรแกรม Kotlin คลื่นแห่งการวิพากษ์วิจารณ์โจมตีบริษัท: นักวิจารณ์แนะนำว่าบริษัทมีสติและทำปลั๊กอินสำหรับ Scala ให้สมบูรณ์ แทนที่จะพัฒนาภาษาของตัวเอง นักพัฒนา Scala ขาดสภาพแวดล้อมการพัฒนาที่ดีจริงๆ แต่ปัญหาของนักพัฒนาปลั๊กอินนั้นเข้าใจได้: Scala ซึ่งเกิดมาต้องขอบคุณนักวิจัยจากสวิตเซอร์แลนด์ ได้รวมเอาแนวคิดและวิธีการทางวิทยาศาสตร์ที่เป็นนวัตกรรมใหม่ ๆ มากมาย ซึ่งทำให้การสร้างเครื่องมือการพัฒนาที่ดีเป็นงานที่ยากมาก . ในขณะนี้ ส่วนของภาษาที่พิมพ์แบบคงที่สมัยใหม่สำหรับ JVM ยังมีขนาดเล็ก ดังนั้นการตัดสินใจสร้างภาษาของคุณเองพร้อมกับสภาพแวดล้อมการพัฒนาจึงดูมองการณ์ไกลมาก แม้ว่าภาษานี้จะไม่ได้หยั่งรากในชุมชนเลย แต่ JetBrains ก็ทำตามความต้องการเป็นหลัก โปรแกรมเมอร์ Java ทุกคนสามารถเข้าใจความต้องการเหล่านี้: Java เป็นภาษากำลังพัฒนาช้ามาก คุณสมบัติใหม่ไม่ปรากฏในภาษา (เรารอฟังก์ชันลำดับแรกมาหลายปีแล้ว) ความเข้ากันได้กับเวอร์ชันเก่าของภาษาทำให้ เป็นไปไม่ได้ที่สิ่งที่มีประโยชน์มากมายจะปรากฏในอนาคตอันใกล้นี้ (เช่น การกำหนดพารามิเตอร์ประเภทที่เหมาะสม) สำหรับบริษัทที่กำลังพัฒนาซอฟต์แวร์ ภาษาการเขียนโปรแกรมเป็นเครื่องมือในการทำงานหลัก ดังนั้นประสิทธิภาพและความเรียบง่ายของภาษาจึงเป็นตัวบ่งชี้ที่ไม่เพียงแต่ขึ้นอยู่กับความง่ายในการพัฒนาเครื่องมือเท่านั้น แต่ยังรวมถึงต้นทุนการเข้ารหัสของโปรแกรมเมอร์ด้วย เช่น ง่ายเพียงใด จะต้องรักษาโค้ดนี้และทำความเข้าใจกับมัน

เกี่ยวกับภาษา

ภาษาถูกพิมพ์แบบคงที่ แต่เมื่อเทียบกับ java คอมไพเลอร์ Kotlin จะเพิ่มข้อมูลให้กับประเภทว่าการอ้างอิงสามารถมีค่าว่างได้หรือไม่ ซึ่งทำให้การตรวจสอบประเภทเข้มงวดขึ้นและทำให้การดำเนินการปลอดภัยยิ่งขึ้น:

สนุก foo(text:String) ( println(text.toLowerCase()) // NPE? No! ) val str:String? = null // สตริง? -- ประเภทที่เป็นโมฆะ foo(str) //<- компилятор не пропустит такой вызов -- // тип str должен быть String, чтобы // передать его в foo

แม้ว่าวิธีการนี้สามารถช่วยโปรแกรมเมอร์จากปัญหาหลายประการที่เกี่ยวข้องกับ NPE ได้ แต่ดูเหมือนว่าไม่จำเป็นสำหรับโปรแกรมเมอร์ Java ในตอนแรก - คุณต้องทำการตรวจสอบหรือการแปลงที่ไม่จำเป็น แต่หลังจากเขียนโปรแกรมด้วย kotlin มาระยะหนึ่ง และกลับมาใช้ java คุณรู้สึกว่าขาดข้อมูลเกี่ยวกับประเภทนี้ และคุณคิดที่จะใช้คำอธิบายประกอบแบบ Nullable/NotNull ที่เกี่ยวข้องกับเรื่องนี้คือปัญหาความเข้ากันได้แบบย้อนหลังกับ java - ข้อมูลนี้ไม่ได้อยู่ในโค้ดไบต์ของ java แต่เท่าที่ฉันรู้ ปัญหานี้ยังอยู่ในขั้นตอนการแก้ไข และสำหรับตอนนี้ทุกประเภทที่มาจาก java จะเป็นโมฆะได้

อย่างไรก็ตามเกี่ยวกับความเข้ากันได้แบบย้อนหลัง: Kotlin ถูกคอมไพล์เป็นรหัสไบต์ JVM (ผู้สร้างภาษาใช้ความพยายามอย่างมากในการรักษาความเข้ากันได้) ซึ่งช่วยให้สามารถใช้ในโครงการเดียวกันกับ java และความสามารถในการใช้ java ร่วมกัน และคลาส Kotlin เป็นเกณฑ์สำหรับการแนะนำ Kotlin เข้ากับโปรเจ็กต์ Java ที่น้อยที่สุดที่มีอยู่ขนาดใหญ่ ในเรื่องนี้ ความสามารถในการใช้การพัฒนา Java หลายรายการโดยการสร้างโปรเจ็กต์ทั้งหมดใน Kotlin เป็นสิ่งสำคัญ ตัวอย่างเช่น มันเกือบจะง่ายสำหรับฉันที่จะสร้างโปรเจ็กต์ขนาดเล็กโดยใช้ spring-webmvc

ลองดูที่ส่วนของตัวควบคุม:

Path(array("/notes/")) คลาสคอนโทรลเลอร์ NotesController ( val ส่วนตัวที่เชื่อมต่ออัตโนมัติ NotesService: NotesService? = null path(array("all")) fun all() = render("notes/notes") ( addObject(" บันทึก", หมายเหตุบริการ!!.ทั้งหมด) ) //... )

ลักษณะเฉพาะของการใช้คำอธิบายประกอบใน Kotlin นั้นมองเห็นได้: ในบางสถานที่มันดูไม่เรียบร้อยเหมือนใน java (สิ่งนี้ใช้กับกรณีพิเศษเช่นอาร์เรย์ขององค์ประกอบเดียว) แต่คำอธิบายประกอบสามารถใช้เป็นคำหลัก "โฮมเมด" เช่น เป็นแบบ autowired หรือตัวควบคุม (หากคุณระบุประเภทนามแฝงเมื่อนำเข้า) และในแง่ของความสามารถ คำอธิบายประกอบจะใกล้เคียงกับคลาสจริงมากขึ้น

ควรสังเกตว่า Spring ไม่สามารถรวมคลาส Kotlin เพื่อจัดการธุรกรรมได้ - ฉันหวังว่าสิ่งนี้จะเป็นไปได้ในอนาคต

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

Fun doSomething(thing:()->Unit) ( // ประกาศพารามิเตอร์ประเภทฟังก์ชัน // ()->Unit ไม่ยอมรับสิ่งใด ๆ และ // ไม่ส่งคืนสิ่งใดที่สำคัญ() // call ) doSomething() ( // และทันทีที่เราสร้างฟังก์ชันประเภท // ()->Unit และส่งผ่านไปยังฟังก์ชัน doShomething // หากฟังก์ชันเป็นพารามิเตอร์ตัวสุดท้าย คุณสามารถ // ย้ายออกไปนอกวงเล็บเรียก println("Hello world ") )

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

สนุก รายการ .filter(เงื่อนไข:(T)->บูลีน):รายการ ( ผลลัพธ์ val = รายการ () for(item in this) ( if(condition(item)) result.add(item) ) return result ) val someList = list(1, 2, 3, 4).filter ( it > 2 ) // someList= =

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

เพื่อแสดงหัวข้อของคลาสและความกระชับ ลองดูโค้ดต่อไปนี้:

// การสร้างคลาส bean กลายเป็น // พูดน้อย สามารถประกาศฟิลด์ได้ // โดยตรงในคลาสการประกาศคอนสตรัคเตอร์ TimeLord (ชื่อวาล: สตริง) // คลาสอาจไม่มีเนื้อหาในทุกคลาส ควานหา (เจ้าของวาล: TimeLord) fun main (args:Array ) ( val doctor = TimeLord("Doctor") val tardis = ควานหา(หมอ) println(tardis.owner.name) )

ในไม่กี่บรรทัด เราสามารถประกาศสองคลาส สร้างสองวัตถุ และพิมพ์ชื่อของเจ้าของควานหา! คุณจะสังเกตได้ว่าคลาสนั้นถูกประกาศด้วยพารามิเตอร์ของตัวสร้างที่เป็นไปได้เท่านั้น ซึ่งเป็นการประกาศคุณสมบัติด้วย สั้นมากแต่ได้ความรู้ แน่นอนว่าจะต้องมีผู้ประณามความเป็นไปไม่ได้ในการประกาศคอนสตรัคเตอร์มากกว่าหนึ่งตัว แต่สำหรับฉันดูเหมือนว่าสิ่งนี้มีการปฏิบัตินิยมในตัวเอง - หลังจากนั้นคอนสตรัคเตอร์หลายตัวใน java ก็อนุญาตให้คุณประกาศพารามิเตอร์เริ่มต้นซึ่ง Kotlin รองรับในภาษานั้น ระดับหรือแปลงประเภทหนึ่งไปเป็นอีกประเภทหนึ่งซึ่งคลาสนี้จะใช้งานได้และสามารถปล่อยให้ใช้วิธีการของโรงงานได้อย่างปลอดภัย ให้ความสนใจกับการประกาศ "ตัวแปร" และฟิลด์ต่างๆ Kotlin บังคับให้เราเลือก: val หรือ var โดยที่ val ประกาศการอ้างอิงขั้นสุดท้ายที่ไม่เปลี่ยนรูป และ var ประกาศตัวแปร ซึ่งช่วยหลีกเลี่ยงการใช้การอ้างอิงที่ไม่แน่นอนอย่างกว้างขวาง

ตัวอย่าง

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

นี่คือสิ่งที่ฉันต้องการให้การใช้งานมีลักษณะดังนี้:

หลักสนุก (args: Array ) ( // สร้างต้นไม้ขนาดเล็ก val tree= tree("root") ( node("1-1") ( node("2-1") node("2-2") ) node("1-2 " ) ( node("2-3") ) ) // สำรวจและพิมพ์ค่าไปยังคอนโซล tree.traverse ( println(it) ) )

ตอนนี้เรามาลองใช้สิ่งนี้กัน มาสร้างคลาสโหนดต้นไม้กันเถอะ:

/** * @param ค่าโหนด data */ class Node (ค่า val:T) ( // โหนดเด็ก val ส่วนตัว เด็ก ๆ:List > = arrayList() /** * วิธีการสร้างและเพิ่มลูกให้กับโหนด * @param value ค่าสำหรับโหนดใหม่ * ฟังก์ชัน @param init เพื่อเริ่มต้นโหนดใหม่ ตัวเลือก * พารามิเตอร์ */ fun node(value: T, เริ่มต้น:โหนด .()->หน่วย = ()):โหนด ( โหนดวาล = โหนด (value) node.init() children.add(node) return node ) /** * เมธอดนี้จะวนซ้ำโหนดลูกทั้งหมดโดยเริ่มจากโหนด * เอง โดยแต่ละโหนดจะได้รับแจ้งถึงตัวจัดการ * @param ตัวจัดการฟังก์ชันตัวจัดการสำหรับ ค่าของแต่ละโหนด */ fun traverse(handler:(T)->Unit) ( handler(value) children.forEach ( child -> child.traverse(handler) ) ) )

ตอนนี้เรามาเพิ่มฟังก์ชันเพื่อสร้างส่วนบนสุดของแผนผัง:

/** * สร้างโหนดต้นไม้ที่มีค่าและเริ่มต้น * ลูก ๆ ของมันด้วยวิธี init */ สนุก ต้นไม้ (value:T, init:Node .()->หน่วย): โหนด ( val node = Node(value) // เรียกใช้เมธอด init ที่ส่งผ่านในพารามิเตอร์ // บนวัตถุโหนด node.init() return node )

ในสองตำแหน่งในโค้ด มีการใช้โครงสร้างเช่น Node.()->Unit ความหมายของมันคือคาดว่าประเภทฟังก์ชันจะเป็นอินพุต ซึ่งจะถูกดำเนินการเป็นวิธีการของอ็อบเจ็กต์ประเภท Node จากเนื้อความของฟังก์ชันนี้จะสามารถเข้าถึงวิธีการอื่นๆ ของอ็อบเจ็กต์นี้ได้ เช่น วิธีการ Node.node() ซึ่งช่วยให้คุณสามารถเริ่มต้นโครงสร้างต้นไม้ได้คล้ายกับที่อธิบายไว้ในตัวอย่าง

แทนที่จะได้ข้อสรุป

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

หากคุณสนใจในภาษานี้ ข้อมูลทั้งหมดเกี่ยวกับภาษานั้นสามารถพบได้บนเว็บไซต์อย่างเป็นทางการของโครงการ สามารถดูแหล่งที่มาได้บน GitHub และข้อผิดพลาดใดๆ ที่พบสามารถโพสต์ได้ใน Issue Tracker ยังคงมีปัญหาอีกมากมาย แต่นักพัฒนาภาษากำลังต่อสู้กับปัญหาเหล่านี้อย่างแข็งขัน ตอนนี้ทีมงานกำลังทำงานในเวอร์ชันที่ยังไม่เสถียรของ Milestone 3 หลังจากที่รักษาเสถียรภาพแล้ว เท่าที่ฉันรู้ มีการวางแผนที่จะใช้ภาษาภายในบริษัท JetBrains หลังจากนั้นก็มีการวางแผนการเปิดตัวครั้งแรกแล้ว

แท็ก:

• คอตลิน
• ชวา
• เจ็ตเบรน

เพิ่มแท็ก

ปี 2017 มีกระแสใหม่เกิดขึ้นรอบๆ YP (ภาษาโปรแกรม) Kotlin และจากภูมิหลังนี้ฉันอยากจะบอกคุณเกี่ยวกับนวัตกรรมอื่น ๆ ในการพัฒนาโปรแกรมสำหรับสมาร์ทโฟนที่ใช้ระบบปฏิบัติการ Android แต่นี่คือบล็อกส่วนตัวของฉันไม่ใช่แหล่งข้อมูลทางวิชาการดังนั้นก่อนอื่นฉันจะยอมให้ตัวเองพูดนอกเรื่องโคลงสั้น ๆ ออกไปด้านข้างโดยหันเหความสนใจไปที่อดีต

ทัศนศึกษาทางประวัติศาสตร์

ความคุ้นเคยครั้งแรกของฉันกับการเขียนโปรแกรมสมาร์ทโฟนที่ใช้ระบบปฏิบัติการ Android คือ เมื่อต้นปี 2555นั่นคือเมื่อ 6 ปีที่แล้ว ในช่วงเวลาอันห่างไกลนั้น Google ยังไม่ได้สร้าง IDE อันงดงามของตัวเอง (สภาพแวดล้อมการพัฒนาแบบบูรณาการ, สภาพแวดล้อมการพัฒนาแบบบูรณาการ) Android Studio และฉันอยู่ใน Eclipse IDE โดยติดตั้งปลั๊กอิน ADT (เครื่องมือพัฒนา Android, เครื่องมือสำหรับนักพัฒนา Android)- เหตุผลที่เรารู้จักคือซื้อสมาร์ทโฟนเครื่องแรกของฉัน HTC Desire HD เมื่อไม่ถึงหนึ่งปีก่อนหน้านี้ในช่วงต้นฤดูร้อนปี 2554

Java ถือเป็นภาษาการเขียนโปรแกรมดั้งเดิมสำหรับ Android มันเป็นภาษาใหม่สำหรับฉัน ดังนั้นฉันจึงมีความท้าทายสามประการ: IDE ใหม่ ภาษาใหม่ และระบบปฏิบัติการใหม่ (ระบบปฏิบัติการ)และทั้งหมดนี้ในเวลาเดียวกัน อย่างไรก็ตาม ฉันได้เรียนรู้วิธีการเขียนโปรแกรมสำหรับ Android และได้เขียนผลิตภัณฑ์เชิงพาณิชย์รายการหนึ่ง ซึ่งฉันยินดีรับเงินจูงใจ 1,000 ยูโร

อย่างไรก็ตาม การเขียนโปรแกรมสำหรับ Android นั้นไม่สะดวกอย่างยิ่ง ซึ่งฉันถึงกับพูดถึงเป็นระยะๆ นี่คือความไม่สมบูรณ์ของ IDE และความล้าหลังของไลบรารีมาตรฐานในทิศทางของ Android และข้อบกพร่องเหล่านี้แยกจากกัน

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

ในปี 2014 IDE เวอร์ชันเสถียรรุ่นแรกจาก Google ปรากฏขึ้นแล้ว (แม้ว่าจะใช้ IntelliJ IDEA IDE ซึ่งเขียนในบริษัท JetBrains ของเช็กที่ถูกกฎหมาย ซึ่งก่อตั้งในกรุงปรากโดยโปรแกรมเมอร์ชาวรัสเซียสามคน).

โดยทั่วไปแล้ว ทุกอย่างเริ่มต้นจากบริษัท StarSoft ของรัสเซีย ซึ่งเริ่มกิจกรรมทันทีหลังจากการรัฐประหารในเดือนสิงหาคม พ.ศ. 2534 บนพื้นฐานของห้องปฏิบัติการซอฟต์แวร์ที่ Independent Humanitarian Academy ในเซนต์ปีเตอร์สเบิร์ก จากนั้นประกอบด้วยคนสามคน ในปี 1993 งานเริ่มในโครงการ Together (เครื่องมือออกแบบซอฟต์แวร์)ซึ่งเป็นแนวคิดที่เสนอโดยชาวเยอรมันที่มาจากประเทศเยอรมนี ในปี 1995 บริษัทได้เปลี่ยนชื่อเป็น STAR SPb และจดทะเบียนอย่างเป็นทางการเป็นสำนักงานตัวแทนของ STAR Group ในรัสเซีย ในปี 1999 บริษัท TogetherSoft ซึ่งเป็นบริษัท "รัสเซีย-เยอรมัน" ซึ่งประกอบด้วยผู้เชี่ยวชาญที่ทำงานเกี่ยวกับผลิตภัณฑ์ Together ได้แยกตัวออกจาก STAR SPb ในบรรดาผู้ร่วมก่อตั้งเช่นเคย มีชาวอเมริกันที่ตัดสินใจว่าโปรแกรมเมอร์ที่ดีจำเป็นต้องถูกย้ายจากเซนต์ปีเตอร์สเบิร์กไปยังยุโรปอย่างเร่งด่วน และในปี 1999 เดียวกันนั้น ทีมชั้นนำของ TogetherSoft (ประมาณ 50 คน)ไปปราก หนึ่งในนั้นคือผู้ก่อตั้ง JetBrains ในอนาคตสามคน ดังนั้น ในปี 2000 พวกเขาจึงก่อตั้งบริษัท JetBrains และจดทะเบียนในสถานที่เดียวกับที่พวกเขาอาศัยอยู่ขณะนั้นในกรุงปราก

ผลิตภัณฑ์เรือธงของ JetBrains คือ IntelliJ IDEA ซึ่งเป็น IDE สำหรับภาษาการเขียนโปรแกรมหลายภาษา Google ใช้เป็นพื้นฐานสำหรับ IDE Android Studio อย่างไรก็ตาม ผู้ร่วมก่อตั้ง Google ก็มาจากรัสเซียเช่นกัน หากคุณขุดสักหน่อย รากรัสเซียก็แผ่กระจายไปทั่ว... เขาเกิดที่มอสโกวและอาศัยอยู่ที่นั่นจนกระทั่งเขาอายุ 5 ขวบ จากนั้นครอบครัวของเขาก็อพยพไปอเมริกาในปี 2522 ตามธรรมเนียมของชาวยิวในตอนนั้น เนื่องจากการต่อต้านชาวยิวโดยเฉพาะโควต้าสำหรับชาวยิวในการเข้ามหาวิทยาลัย ในตอนแรก ชาวยิวในฐานะประชาชนแยกตัวเอง เน้นย้ำถึงการเลือกของพระเจ้าในทุกวิถีทางที่เป็นไปได้ และไม่ปิดบังความคิดที่ไม่เป็นที่ยอมรับเสมอไปในภูมิภาคที่มีศาสนาที่โดดเด่นและความคิดที่แตกต่างกัน จากนั้นพวกเขาก็ประหลาดใจกับผลลัพธ์ . อย่างไรก็ตามนี่เป็นอีกหัวข้อหนึ่ง แม้ว่าเขาจะพูดอย่างอ่อนโยนและไม่เชื่อต่อบ้านเกิดเมืองนอนของเขาก็ตาม (คุณคาดหวังอะไรอีกจากบุคคลที่เลี้ยงดูโดยผู้อพยพชาวโซเวียต)ฉันแบ่งปันความคิดเห็นของเขาอย่างสมบูรณ์โดยเฉพาะทางอินเทอร์เน็ต และคำกล่าวเชิงวิพากษ์วิจารณ์มากมายเกี่ยวกับรัสเซียนั้นค่อนข้างยุติธรรม แม้ว่าจะไม่เป็นที่พอใจเมื่อได้ยินจากปากของชาวต่างชาติก็ตาม แต่ฉันก็กลับถูกรบกวนอีกครั้ง...

ดังนั้น เมื่อ Android Studio ปรากฏขึ้น ฉันก็เปลี่ยนมาใช้มันทันทีเนื่องจากเป็น IDE ที่น่าจะมีแนวโน้มมากกว่าสำหรับการพัฒนาสำหรับ Android ฉันต้องบอกว่าในตอนแรกทั้งข้อดีและข้อเสียของมันเห็นได้ชัดเจนเมื่อเทียบกับ Eclipse อย่างไรก็ตาม มีข้อดีอีกมากมาย และฉันก็ติดใจมันมาก

ในฐานะมือสมัครเล่น ฉันไม่ได้เขียนโปรแกรมเป็นประจำ และฉันพลาดปี 2017 ที่ผ่านมาอย่างสิ้นเชิงในแง่ของ Android และตอนนี้ฉันตัดสินใจอัปเดต IDE และดูว่ามีอะไรใหม่เกิดขึ้นในช่วงเวลาดังกล่าว และปรากฎว่ามีสิ่งสำคัญมากมายปรากฏขึ้นที่นั่น! ด้านล่างนี้ฉันจะแสดงรายการนวัตกรรมที่โดดเด่นเป็นพิเศษซึ่งฉันให้คะแนนในเชิงบวกมาก

ภาษาโปรแกรมใหม่ Kotlin

จนกระทั่งเมื่อไม่นานมานี้ Android Studio รองรับเฉพาะการเขียนโปรแกรมใน Java เท่านั้น (ชวา ก่อนหน้านี้มักเรียกว่า ชวา ภาษานี้ตั้งชื่อตามยี่ห้อกาแฟ ซึ่งในทางกลับกัน ก็ตั้งชื่อตามเกาะในอินโดนีเซีย)และในภาษา C++ สำหรับโค้ดเนทีฟ ภาษา Java ไม่ได้เก่ามาก แต่เนื่องจากยังเน้นการใช้งานที่ค่อนข้างใหม่ (หลายแพลตฟอร์ม),ค่อนข้างสูงวัย. ได้รับการพัฒนาโดยบริษัท Sun Microsystems ที่มีชื่อเสียงในปี 1995 เดิมภาษานี้เรียกว่าโอ๊ค ("โอ๊ค")และได้รับการพัฒนาสำหรับการเขียนโปรแกรมอุปกรณ์อิเล็กทรอนิกส์สำหรับผู้บริโภค จากนั้นจึงเปลี่ยนชื่อเป็น Java และใช้เพื่อเขียนแอปพลิเคชันไคลเอ็นต์และซอฟต์แวร์เซิร์ฟเวอร์ ต่อมามีการใช้งานอื่นปรากฏขึ้น

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

และเมื่อไม่นานมานี้ เมื่อปลายปี 2560 Android Studio 3.0 ได้เปิดตัว ซึ่งเมื่อรวมกับภาษา Java และ C++ ก็เริ่มรองรับภาษา Kotlin แล้ว (คอตลิน)ซึ่งเช่นเดียวกับ Java ได้รับการออกแบบเพื่อสร้างไบต์โค้ดเดียวกันสำหรับเครื่องเสมือนเดียวกัน แต่มีไวยากรณ์ที่แตกต่างกันซึ่งช่วยให้คุณสามารถเขียนซอร์สโค้ดที่มีขนาดกะทัดรัดมากขึ้น ในเวลาเดียวกัน ไฟล์ต้นฉบับในทั้งสองภาษาสามารถผสมกันได้โดยไม่มีข้อจำกัดในโปรเจ็กต์เดียว ซึ่งทำให้สามารถค่อยๆ ถ่ายโอนทั้งโปรเจ็กต์ไปยัง Kotlin ได้

ภาษามีความสดใหม่อย่างสมบูรณ์ เริ่มการพัฒนาในปี 2010 นำเสนอต่อสาธารณะในปี 2554 การเขียนโปรแกรมบน Android เป็นไปได้ในปี 2555 และการเปิดตัวอย่างเป็นทางการได้เปิดตัวเมื่อไม่นานมานี้ในปี 2559 โดยวิธีการตามประเพณี (เช่นจาวา)ภาษานี้ตั้งชื่อตามเกาะ คราวนี้เป็นเกาะ Kotlin ของรัสเซียในอ่าวฟินแลนด์ซึ่งเป็นที่ตั้งของเมือง Kronstadt และภาษานี้ได้รับการพัฒนาโดยโปรแกรมเมอร์ในเซนต์ปีเตอร์สเบิร์ก ทั้งหมดอยู่ในบริษัทเดียวกัน JetBrains! โอ้เป็นภาษาโปรแกรมรัสเซียจริงๆ! [ผู้รักชาติควรโบกธง และผู้เขียนโพสต์นี้ก็เดินเป็นวงกลมไปรอบห้องแล้ว โบกมืออย่างน่ากลัว...]

ฉันได้ลองเขียนในภาษานี้สำหรับ Android แล้วและฉันสามารถพูดได้อย่างมั่นใจว่าภาษานี้ค่อนข้างเหมาะสม ก่อนหน้านี้ ฉันหลงทางในโค้ด Java เพราะใน Android คุณต้องเขียนทุกอย่างและทุกคน และสุดท้ายคุณก็จะได้ซอร์สโค้ดที่ยาวมาก เป็นผลให้ซอร์สโค้ดมีขนาดใหญ่ขึ้นและต้องแบ่งออกเป็นคลาสต่างๆ ยัดลงในไฟล์ต่างๆ จากนั้นฉันก็หลงเข้าไปในไฟล์นั้นแล้ว Kotlin ใช้ปรัชญาที่ว่า “ทุกสิ่งที่สามารถสร้างขึ้นได้โดยอัตโนมัติควรถูกสร้างขึ้นโดยอัตโนมัติ” ในด้านหนึ่ง โค้ดมีความโปร่งใสน้อยลง (ลบ แต่อาจสำหรับผู้เริ่มต้นเท่านั้น)แต่เรียบง่ายกว่าและกะทัดรัดกว่า (ข้อดีอย่างมากสำหรับทุกคน)

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

ส่วนประกอบทางสถาปัตยกรรมสำหรับ Android จาก Google

นอกจากนี้ ยังมีขนาดกะทัดรัดมากในการสร้างและใช้ฐานข้อมูล SQLite โดยใช้ไลบรารี Room ซึ่งเป็นส่วนเสริมของคลาส SQLiteOpenHelper ที่รู้จักกันดี ในการใช้ Room ก็เพียงพอแล้วที่จะอธิบายคลาสขนาดเล็กสองคลาสที่อธิบายตารางและฐานข้อมูล และอินเทอร์เฟซขนาดเล็กหนึ่งอินเตอร์เฟสที่อธิบายฟังก์ชันสำหรับการโต้ตอบกับฐานข้อมูลนี้ ใน Kotlin ไม่จำเป็นต้องใส่ทั้งหมดนี้ลงในไฟล์ต่างๆ จากข้อมูลที่ไม่เพียงพอนี้ Room จะสร้างการดำเนินการทั้งหมดที่ก่อนหน้านี้ต้องเขียนเป็นไฟล์ขนาดใหญ่โดยอัตโนมัติและภายใน ปาฏิหาริย์!

ในแอปพลิเคชันจริง คุณต้องติดตามการเปลี่ยนแปลงข้อมูลในฐานข้อมูลและอัปเดตข้อมูลในส่วนประกอบภาพโดยอัตโนมัติ ดังนั้น คอมโพเนนต์ Room จึงมักไม่ได้ใช้โดยตัวมันเอง แต่ใช้ร่วมกับคอมโพเนนต์ LiveData จากไลบรารี android.arch.lifecycle ส่วนประกอบนี้ยังใช้งานง่าย ข้อมูลที่ต้องติดตามจะถูกถ่ายโอนจากฐานข้อมูลไปยังตัวแปรไม่ใช่โดยตรง แต่อยู่ในรูปแบบของคลาส LiveData ซึ่งรับข้อมูลนี้เป็นพารามิเตอร์ภายในห้อง หลังจากนี้ในโค้ดหลัก Kotlin หนึ่งบรรทัดจะตั้งค่าการตรวจสอบและฟังก์ชันการอัปเดตขององค์ประกอบภาพซึ่งจะเปิดตัวเมื่อข้อมูลเปลี่ยนแปลง ทุกอย่างเป็นประถม!

องค์ประกอบที่มีประโยชน์อีกประการหนึ่งจากไลบรารี android.arch.lifecycle ที่ช่วยแก้ปัญหาเรื่องปวดหัวในการบันทึกข้อมูลกิจกรรมเมื่อหมุนหน้าจอคือ ViewModel ก่อนหน้านี้จำเป็นต้องเขียนไม้ค้ำอันชาญฉลาดทุกประเภทเพื่อไม่ให้ข้อมูลสูญหายและการคำนวณไม่ถูกรบกวน ขณะนี้มีองค์ประกอบอย่างเป็นทางการสำหรับสิ่งนี้แล้ว! หากก่อนหน้านี้เราแยกอินเทอร์เฟซออกจากโค้ด (มาร์กอัปและกิจกรรม)ตอนนี้ก็ถึงเวลาที่จะแยกโค้ดที่ควรรันเฉพาะในช่วงวงจรชีวิตของกิจกรรมออก (เช่น การตรวจสอบการทำงานของส่วนติดต่อผู้ใช้)จากโค้ดที่ต้องทำงานนอกวงจรกิจกรรมเฉพาะ (เช่น การรับ การประมวลผล และการส่งข้อมูล)- ในกรณีนี้ เราสามารถอ่านผลลัพธ์ของส่วนที่สองของโค้ดในกิจกรรมที่สร้างขึ้นใหม่หลังจากหมุนหน้าจอได้โดยอัตโนมัติ

หากต้องการนำโครงร่างทั้งหมดนี้ไปใช้ ViewModel จำเป็นต้องมีการดำเนินการขั้นต่ำด้วย ชั้นเรียนแยกต่างหากเขียนด้วยโค้ดที่ไม่ควรถูกขัดจังหวะ (ที่เรียกว่า view model ฉันไม่รู้ว่าทำไม "model" บางทีฉันอาจจะแปลผิด)และในโค้ดหลักในบรรทัดเดียว จะมีการเรียกผู้ให้บริการโมเดล ซึ่งคลาสนี้จะถูกส่งผ่านเป็นพารามิเตอร์ ผู้ให้บริการส่งคืนวัตถุคลาสโมเดลที่มีอยู่ (หลังจากหมุนหน้าจอ)หรือสร้างวัตถุดังกล่าวโดยใช้คลาสที่ส่งผ่าน หากยังไม่มี และส่งคืนด้วย (เมื่อเปิดกิจกรรมเป็นครั้งแรก)- กิจกรรมสามารถเข้าถึงฟังก์ชันและตัวแปรของวัตถุนี้ได้เสมอ

ส่วนประกอบทั้งสามนั้นรวมกันภายใต้ชื่ออย่างเป็นทางการว่า Android Architecture Components จริงอยู่ มันมีส่วนประกอบ LifeCycle อยู่ในไลบรารี android.arch.lifecycle ด้วย แต่จะใช้ร่วมกับ LiveData อย่างใกล้ชิด และฉันจะไม่เน้นเลย การเปิดตัวส่วนประกอบระดับสูงดังกล่าวถือเป็นก้าวย่างที่น่ายินดีในทิศทางที่ถูกต้องสำหรับ Google ฉันบ่นมานานแล้วเกี่ยวกับจำนวนชั้นเรียนที่แตกต่างกันที่คุณต้องขยายตัวเองและเชื่อมโยงพวกเขาทั้งหมดเข้าด้วยกันเพื่อสร้างอะไรที่มากกว่าตัวอย่างดั้งเดิมจากงานหนังสือเรียนสำหรับผู้เริ่มต้น และในที่สุด ส่วนประกอบที่ถูกต้องก็เริ่มปรากฏให้เห็นในห้องสมุด ฉันหวังว่าแนวโน้มนี้จะดำเนินต่อไป

ตัวแก้ไขส่วนต่อประสานภาพ

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

โชคดีที่ใน Android Studio เริ่มต้นจากเวอร์ชัน 2.2 แทนที่จะสร้างอินเทอร์เฟซ gimor ผ่านเลย์เอาต์ของการจัดเรียงองค์ประกอบเชิงเส้น (เค้าโครงเชิงเส้น)ขอเสนอให้ใช้เค้าโครงบังคับใหม่ (เค้าโครงข้อจำกัด)- นอกจากนี้ โปรแกรมแก้ไขภาพก็ได้รับการสรุปในที่สุด ทั้งหมดนี้มีผลในเชิงบวกมาก ตอนนี้การวางตำแหน่งองค์ประกอบอย่างถูกต้องไม่ใช่เรื่องยากและพวกมันก็ทำงานได้ค่อนข้างคาดเดาได้ ตอนนี้คุณไม่สามารถแตะมาร์กอัป xml ได้ แต่ดำเนินการทั้งหมดในโปรแกรมแก้ไขภาพ