Kotlin ծրագրավորման լեզուն, որը մշակվել է Սանկտ Պետերբուրգի JetBrains ընկերության կողմից, դարձել է Android-ի զարգացման պաշտոնական լեզուն։ Այս մասին պաշտոնապես հայտարարվել է Google I/O կոնֆերանսում։ Կոտլինի թիմը ղեկավարում է ITMO համալսարանի շրջանավարտ Անդրեյ Բրեսլավը: Ինչու է Կոտլինն այդքան սիրելի ՏՏ հսկայի կողմից շատ այլ «երիտասարդ» լեզուների մեջ, ինչպես և ինչու են ծրագրավորման նոր լեզուներ ընդհանրապես հայտնվում, կարդացեք փորձագետների մեկնաբանություններում և ITMO.NEWS տեղեկատվական հավաքածուում:

Ինչպես են մշակվում ծրագրավորման լեզուները

Ըստ տարբեր գնահատականների՝ աշխարհում արդեն կա ավելի քան երկու հազար տարբեր ծրագրավորման լեզու։ Անընդհատ թարմացումներ են թողարկվում հին լեզուների համար, և հայտնվում են նաև նոր լեզուներ։ Երբ լեզվի շարահյուսությունը չի փոխվում, այլ միայն դառնում է ավելի բարդ և ընդլայնված, մշակողին անհրաժեշտ է միայն մի փոքր պրակտիկա՝ շարունակելու գրել իր սիրելի լեզվով: Երբեմն լեզվի կառուցվածքն ինքնին փոխվում է, իսկ հետո ծրագրավորողը երբեմն ստիպված է լինում նորից սովորել՝ հարմարվելով թարմացված լեզվին։ Սովորաբար, նոր կառուցվածքի անցումը տեղի է ունենում աստիճանաբար և մաս-մաս, այսինքն՝ ծրագրի կոդի միայն 10-20%-ն է սկսում գրել նոր լեզվով։

« Ծրագրավորողները լիովին գոհ չէին C++ և Java լեզուներից, քանի որ դրանք բավականին բարդ լեզուներ են, և առաջինն ավելի բարդ է, քան երկրորդը: Հետևաբար, հայտնվեց Scala լեզուն, որը շատ ծրագրավորողների հավանում է, բայց այն նաև շատ բարդ է։ JetBrains-ի հսկայական փորձը ծրագրավորման տարբեր լեզուների համար ծրագրերի մշակման գործիքներ ստեղծելու համար նրան թույլ տվեց յոթ տարվա ընթացքում ստեղծել Kotlin լեզուն, որը լիովին համատեղելի է Java-ի հետ, բայց ավելի պարզ և հարմար, քան դա: Ծրագրավորման լեզուներ անընդհատ զարգանում են, այլևս ոչ ոք իր առջեւ խնդիր չի դնում համընդհանուր լեզու ստեղծել։ Չնայած դրան, յուրաքանչյուր լեզու ավելի արդյունավետ է որոշակի ոլորտում, որտեղ այն առավել հաճախ օգտագործվում է: Նույնիսկ լեզուների ստեղծման ուղղություն կա, երբ դրանք մշակվում են կոնկրետ առարկայի համար», - մեկնաբանել է ITMO համալսարանի ծրագրավորման տեխնոլոգիաների ամբիոնի վարիչը։

Այսօր որոշ ընկերություններ նույնիսկ կազմում են իրենց լեզվական վարկանիշները: Օրինակ, TIOBE ընկերությունը, որը մասնագիտացած է ծրագրային ապահովման որակի գնահատման մեջ, 2001 թվականից ամենամսյա հաշվարկում է որոշակի լեզուների ժողովրդականության ինդեքսը: Ստեղծված ցանկը պարունակում է 50 տող, և որպեսզի ծրագրավորման լեզու ներառվի ինդեքսում, մշակողները պետք է համապատասխան նամակ գրեն ընկերությանը։ Հաշվարկը հիմնված է 25 ինտերնետ որոնողական համակարգերի տվյալների վրա։ Առայժմ վարկանիշային աղյուսակը մեծ տարբերությամբ գլխավորում է Java-ն, որին հաջորդում է C-ն։ Միևնույն ժամանակ, ցուցակը կազմողները շեշտում են, որ վերջին մեկ տարվա ընթացքում ծրագրավորման երկու լեզուներն էլ ավելի քիչ տարածված են դարձել՝ մոտ 6%-ով։ Միևնույն ժամանակ, TIOBE-ն ցույց է տալիս, որ C-ն թիվ 1 լեզուն էր մինչև 2002 թվականը, իսկ Java-ն 1997 թվականին 14-րդ տեղում էր, սակայն հինգ տարի անց այն փոխարինեց C-ին առաջին հորիզոնականում։

Դուք կարող եք հիանալի դասախոսություն կարդալ լեզուների զարգացման պատմության վերաբերյալ. Yandex-ի ակադեմիական ծրագրերի համադրողը, Տնտեսագիտության բարձրագույն դպրոցի համակարգչային գիտությունների ֆակուլտետի ուսանողական մրցույթների կենտրոնի տնօրենը խոսում է այն մասին, թե ինչպես են լեզուները C հայտնվեցին PHP, Ruby և Java: Միխայիլ Գուստոկաշին. Դասախոսը շեշտում է, որ յուրաքանչյուր առաջադրանքի համար պետք է ընտրել ծրագրավորման տարբեր լեզու. Օրինակ, նա ասում է, որ ռազմական արդյունաբերության համար ավելի լավ է գրել հին լավ Պասկալ լեզվով, որը ծնվել է դեռևս 1970 թվականին: Ինչո՞ւ։ Քանի որ դա ավելի հուսալի է: Բիզնես հավելվածները կարող են գրվել Java-ով, քանի որ այս լեզուն նույնպես բավականին հուսալի է, բայց շատ ավելի հեշտ է օգտագործել: Փորձագետը նաև ընդգծում է, որ կարևոր է պահպանել լեզվի նկատմամբ հետաքրքրությունը ծրագրավորողների շրջանում՝ ստեղծելով այս լեզվով գրող ծրագրավորողների համայնք։ Եթե ​​նոր լեզվի շուրջ ենթակառուցվածք ստեղծվի, և մարդիկ հավաքվեն այն օգտագործելու, միայն այդ դեպքում լեզուն կդառնա հանրաճանաչ: Ի դեպ, Kotlin-ի մշակողները նույնպես որդեգրել են այս ռազմավարությունը։

Մի փոքր Կոտլինի մասին

Kotlin ծրագրավորման լեզուն սկսել է մշակվել Սանկտ Պետերբուրգի JetBrains ընկերությունում 2010 թվականին։ Ապրանքի պաշտոնական թողարկումը թողարկվել է 2016թ. Լեզուն ստացել է այս անվանումը՝ ի պատիվ Ֆիննական ծոցի կղզու, որի վրա գտնվում է Կրոնշտադտը։ Հետաքրքիր զուգադիպությամբ հայտնի Java լեզվի անվանումը նաև Ինդոնեզիայի կղզու անունն է։ Պատահականությունը հավանաբար պատահական չէ. Ինչպես ասվում է մամուլի հաղորդագրության մեջ, Կոտլինը պետք է աշխատի այնտեղ, որտեղ աշխատում է Java-ն, և նպատակներից մեկն այն էր, որ արտադրվի արտադրանք, որը կարող է օգտագործվել մի քանի լեզուներով ստեղծված խառը նախագծերում:

Ինչպես նշում են Կոտլինի հեղինակները, նրանց համար ամենակարևորը «պրագմատիկ» արտադրանքի ստեղծումն էր։ Սա նշանակում է, որ նրանք ոչ միայն կենտրոնացած էին սխալների շտկման և արտադրանքի բարելավման վրա, ինչը կաներ ցանկացած ծրագրավորող, այլ ցանկանում էին օգտակար գործիք պատրաստել:

« Զարգացման գործիքները, ներառյալ ծրագրավորման լեզուները, անընդհատ զարգանում են: Լեզուները տարբերվում են այլ գործիքներից նրանով, որ դրանք բավականին դժվար է զարգացնել էվոլյուցիոն ճանապարհով: Լեզվի նոր տարբերակը պետք է աջակցի բոլոր առկա ծրագրերին: Սա սահմանափակում է գոյություն ունեցող լեզուների զարգացման հնարավորությունները և ստեղծում նորերի առաջացման անհրաժեշտություն: Նոր ծրագրավորման լեզվի հաջողությունը պայմանավորող գործոնն առաջին հերթին ծրագրավորողների համար հարմարավետությունն է։ Բացի հակիրճ և արտահայտիչ լինելուց, Kotlin-ը շատ համատեղելի է Java կոդի հետ. դուք կարող եք օգտագործել բոլոր գոյություն ունեցող գրադարանները և նույնիսկ խառնել կոդը երկու լեզվով մեկ նախագծում, այնպես որ հատուկ անցումային դժվարություններ չկան:», - մեկնաբանեց Kotlin ծրագրի ղեկավարը JetBrains-ում, ITMO համալսարանի շրջանավարտ:

Ինչու Google-ը սիրում էր Կոտլինը

Պաշտոնական կայքում Android-ի մշակողները գրում են, որ վերջին տարիներին նկատել են Կոտլինի «վերելքը»։ Google-ի աշխատակիցները չեն ամաչում լեզուն նկարագրել որպես տպավորիչ, հակիրճ, զորացնող և հաճելի աշխատելու համար: Այն բարձրացրել է արտադրողականությունը. դրա մեջ պարունակվող ծրագրային կոդը միջինը 40%-ով ավելի կարճ է, քան այլ լեզուներում, և Կոտլինը նաև թույլ է տալիս խուսափել կոդի որոշ սխալներից։ Google-ում Կոտլինի հանրաճանաչության որոշիչ գործոններից մեկն այն էր, որ այն համատեղելի է Java-ի հետ, որն արդեն օգտագործվում է Android-ի համար հավելվածներ մշակելիս:

Այժմ, երբ ծրագրավորողները սկսում են ստեղծել նոր հավելված Android Studio-ի մշակման պաշտոնական միջավայրում, նրանք կարող են անմիջապես միացնել «Kotlin support» հավելվածը։ Կարող եք նաև այլ լեզուներով արդեն ստեղծված կոդերի տողերը վերածել Կոտլինի լեզվի, այլ լեզուներով բլոկներ տեղադրել Կոտլինի կոդերի տողերի: Հետագայում լեզվի համար ավելի շատ գրադարաններ և գործիքներ կմշակվեն, ավելի շատ ուսումնական նյութեր կմշակվեն, և հնարավոր խնդիրների լուծումները ավելի հեշտ կլինի գտնել:

« Google-ի կողմից լեզվական աջակցության երաշխիքների բացակայությունը շատ ծրագրավորողների հետ կանգնեցրեց Կոտլինին անցնելուց: Նույնիսկ եթե դուք իսկապես սիրում եք լեզուն,Ծրագրավորողը միշտ մտածում է այն ռիսկի մասին, որ ինչ-որ պահի այս լեզուն պարզապես կդադարի աշխատել: Այժմ կա երաշխիք, որ Կոտլինը չի դադարի աշխատել, և մենք ակնկալում ենք, որ լեզվից օգտվողների թիվը կտրուկ կավելանա։ Բնական կլիներ ենթադրել, որ շատ ընկերություններ, ի վերջո, ամբողջությամբ կանցնեն Կոտլինին, թեև տեխնիկապես նրանց ոչինչ չի ստիպում դա անել, դա ուղղակի նախապատվության հարց է։- ընդգծել է Անդրեյ Բրեսլավը:

Նա հավելել է, որ Կոտլինը շատ ակտիվ է մշակվում։ Մշակող թիմը ներկայումս աշխատում է կառուցման համակարգի, կոմպիլյացիայի արագության, IDE-ի կատարողականի բարելավման, գործիքակազմում նոր գործառույթների ավելացման վրա, այդ թվում՝ Android Studio-ին ինտեգրվելու հետ կապված: Աշխատանքներ են տարվում նաև բազմահարթակ նախագծերի վրա (միևնույն կոդը մի քանի հարթակների համար կազմելու հնարավորություն), և մի շարք լեզվական բարելավումներ նախագծման փուլում են։

Google-ը նաև ընդգծել է, որ իրենք ոգեշնչված են Կոտլին լեզվի հայեցակարգից, ըստ որի այն միշտ եղել է և կմնա անվճար ծրագրավորողների համար, այսինքն՝ բաց կոդով նախագիծ։ Սա նշանակում է, որ լեզուն կապված չէ որևէ կոնկրետ ընկերության հետ, և սկզբնական կոդը տարածվում է անվճար լիցենզիայի ներքո: Դուք կարող եք ներբեռնել արտադրանքը: Kotlin-ի զարգացմանն աջակցելու համար Google-ը և JetBrains-ը կստեղծեն շահույթ չհետապնդող գործընկերություն: Բացի այդ, որպես Android-ի «առաքելության» մաս, շատ կարևոր է, որ Կոտլինի հեղինակներն իրենց արտադրանքի շուրջ ստեղծեն մարդկանց համայնք, ովքեր մասնագիտորեն ներգրավված են այս լեզվի մշակման մեջ և սիրում են կիսվել իրենց փորձով: Օրինակ՝ նոյեմբերին Կոտլինի համաժողովը կանցկացվի Միացյալ Նահանգներում, և ծրագրավորողները կարող են նաև ստանալ ամենօրյա նորություններ և խորհուրդներ ծրագրային ապահովման արտադրանքի մասին և հանդիպել տեղում։

Ի դեպ, Android Studio նախագիծն ինքնին մշակվել է IntelliJ IDEA ծրագրային ապահովման մշակման միջավայրի հիման վրա, որը նույնպես ստեղծվել է JetBrains-ի կողմից։ Բայց չնայած սերտ համագործակցությանը, պետերբուրգյան ընկերությունն ընդգծում է, որ ամերիկյան ՏՏ հսկային JetBrains-ի վաճառքի մասին խոսք չկա։ Միեւնույն ժամանակ, Koltin-ը նախատեսված չի լինի միայն Android-ի համար։ Ընկերության նպատակն է ծրագրավորման լեզուն հարմարեցնել զարգացման տարբեր հարթակների համար։

2017-ին YP-ի շուրջ նոր աղմուկ բարձրացավ (ծրագրավորման լեզու)Կոտլին, և այս ֆոնին ես ուզում եմ ձեզ պատմել նաև Android օպերացիոն համակարգի վրա հիմնված սմարթֆոնների ծրագրերի մշակման այլ նորամուծությունների մասին։ Բայց սա իմ անձնական բլոգն է, և ոչ թե ինչ-որ ակադեմիական ռեսուրս, և, հետևաբար, նախ, ես ինձ թույլ կտամ որոշ լիրիկական շեղումներ դեպի կողմը, հայացքս ուղղելով դեպի անցյալ:

Պատմական էքսկուրսիա

Անդրոիդ օպերացիոն համակարգով աշխատող սմարթֆոնների ծրագրավորման հետ իմ առաջին ծանոթությունը եղել է սկզբին 2012 թ, այսինքն՝ ուղիղ 6 տարի առաջ։ Այդ հեռավոր ժամանակներում Google-ը դեռ չէր ստեղծել իր հոյակապ IDE-ը (Integrated Development Environment, Integrated Development Environment) Android Studio-ն և ես Eclipse IDE-ում ենք՝ տեղադրված ADT հավելվածով (Android-ի զարգացման գործիքներ, Android-ի մշակողների գործիքներ). Մեր ծանոթության պատճառն իմ առաջին սմարթֆոնի՝ HTC Desire HD-ի գնումն էր մեկ տարի առաջ՝ 2011 թվականի ամռան սկզբին։

Java-ն համարվում էր Android-ի մայրենի ծրագրավորման լեզուն։ Դա ինձ համար նոր լեզու էր, ուստի ես եռակի մարտահրավեր ունեի՝ նոր IDE, նոր լեզու և նոր ՕՀ։ (Օպերացիոն համակարգ), և այս ամենը միաժամանակ։ Այնուամենայնիվ, ես ինչ-որ կերպ սովորեցի, թե ինչպես գրել ծրագրեր Android-ի համար, և նույնիսկ գրեցի մեկ կոմերցիոն արտադրանք, որի համար հաճույքով ստացա 1000 եվրո պարգև։

Այնուամենայնիվ, Android-ի համար ծրագրավորումը չափազանց անհարմար էր, ինչը ես նույնիսկ պարբերաբար նշում եմ: Ահա IDE-ի անկատարությունը, և Android-ի ուղղությամբ ստանդարտ գրադարանների թերզարգացումը, և դրանք, և այս ամենի թերությունները առանձին-առանձին:

Եվս մեկ տարի անց սկզբին 2013 թԵս նույնիսկ սկսեցի գրել հատուկ բլոգ, որը կոչվում է «Android, հնարքներ ձեր ականջներով» բնորոշ էպիգրաֆով: Ոզնիները լաց եղան, սրսկեցին իրենց, բայց շարունակեցին կրծել կակտուսը...», որում ես պարբերաբար տեղադրում էի որոշ խնդիրների լուծումներ, որոնց բախվել եմ, ինչպես նաև հրապարակում էի որոշ լրացուցիչ ֆոնային տեղեկություններ՝ իբր իմ հիշողության համար։

2014թՀայտնվել է Google-ի IDE-ի առաջին կայուն տարբերակը (թեև հիմնված է IntelliJ IDEA IDE-ի վրա, որը գրված է օրինական չեխական JetBrains ընկերությունում, որը հիմնադրվել է Պրահայում երեք ռուս ծրագրավորողների կողմից).

Ընդհանուր առմամբ, ամեն ինչ սկսվեց ռուսական StarSoft ընկերությունից, որն իր գործունեությունը սկսեց 1991 թվականի օգոստոսի հեղաշրջումից անմիջապես հետո՝ Սանկտ Պետերբուրգի Անկախ մարդասիրական ակադեմիայի ծրագրային լաբորատորիայի հիման վրա, այնուհետև բաղկացած էր երեք հոգուց։ 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 տարեկան, իսկ հետո ընտանիքը 1979 թվականին գաղթել է Ամերիկա, ինչպես այն ժամանակ հրեաների մոտ ընդունված էր։ Հակասեմիտիզմի պատճառով, մասնավորապես, հրեաների բուհ ընդունվելու քվոտաների առկայությունը։ Հրեաները, որպես ժողովուրդ, սկզբում մեկուսանում են, ամեն կերպ ընդգծում իրենց Աստծո ընտրյալությունը և չեն թաքցնում իրենց ոչ միշտ ընդունելի մտածելակերպը այլ գերիշխող կրոն և այլ մտածելակերպ ունեցող տարածաշրջաններում, իսկ հետո զարմանում են արդյունքի վրա. . Սակայն սա այլ թեմա է։ Չնայած նախկին հայրենիքի նկատմամբ նրա, մեղմ ասած, թերահավատ վերաբերմունքին (ուրիշ ի՞նչ կարելի է սպասել խորհրդային էմիգրանտների կողմից դաստիարակված մարդուց), ես լիովին կիսում եմ նրա տեսակետները, մասնավորապես համացանցում։ Իսկ Ռուսաստանի մասին շատ քննադատական ​​հայտարարություններ միանգամայն արդարացի են, թեև տհաճ, երբ լսվում են օտարերկրացու շուրթերից: Այնուամենայնիվ, ես նորից շեղվեցի...

Այսպիսով, երբ հայտնվեց Android Studio-ն, ես անմիջապես անցա դրան՝ որպես պոտենցիալ ավելի խոստումնալից IDE՝ Android-ի համար մշակելու համար: Ասեմ, որ սկզբում նկատելի էին և՛ դրական, և՛ բացասական կողմերը՝ համեմատած Eclipse-ի հետ։ Այնուամենայնիվ, շատ ավելի շատ առավելություններ կային, և ես ամուր կառչեցի դրա վրա:

Որպես սիրողական, ես կանոնավոր ծրագրավորում չեմ անում, իսկ վերջին 2017-ը ամբողջովին բաց եմ թողել Android-ի առումով։ Եվ հիմա ես որոշեցի թարմացնել IDE-ն և տեսնել, թե ինչ նոր բաներ են այնտեղ հայտնվել այդ ընթացքում։ Եվ պարզվեց, որ այնտեղ շատ նշանակալից բաներ են հայտնվել։ Ստորև ես կթվարկեմ մի քանի հատկապես ուշագրավ նորամուծություններ, որոնք ես շատ դրական եմ գնահատում։

Նոր ծրագրավորման լեզու Kotlin

Մինչև վերջերս Android Studio-ն աջակցում էր միայն Java-ում ծրագրավորումը (Ջավա, նախկինում ավելի հաճախ ասում էին Java: Լեզուն կոչվում է սուրճի ապրանքանիշի անունով, որն, իր հերթին, անվանվել է Ինդոնեզիայում գտնվող կղզու պատվին)իսկ C++-ում՝ հայրենի կոդի համար: Java լեզուն շատ հին չէ, բայց հաշվի առնելով դրա օգտագործման համեմատաբար երիտասարդ ուշադրությունը (բազմ հարթակ), բավականին տարեց. Այն մշակվել է հայտնի Sun Microsystems ընկերության կողմից 1995 թվականին։ Լեզուն սկզբում կոչվել է կաղնու («Կաղնու»)և մշակվել է սպառողական էլեկտրոնային սարքերի ծրագրավորման համար։ Այնուհետև այն վերանվանվեց Java և օգտագործվում էր հաճախորդի հավելվածներ և սերվերային ծրագրեր գրելու համար: Հետագայում հայտնվեցին այլ կիրառություններ։

Ես նշում եմ, որ Java-ն աշխատում է կոմպիլյատորի հետ տանդեմում, որը օպերացիոն համակարգում դրա կատարման համար ամբողջական կոդ չի արտադրում: Այս լեզվով գրված սկզբնաղբյուր տեքստերը կազմվում են հատուկ բայթկոդի մեջ, որը կատարվում է հատուկ վիրտուալ մեքենայի վրա, որը լրացուցիչ տեղադրված է համակարգում, որն այս կոդը թարգմանում է օպերացիոն համակարգի և պրոցեսորի համար հասկանալի հրամանների: Այսպիսով, այս լեզվով գրված ծրագրերը կարող են իրականացվել ցանկացած սարքի վրա, որի վրա տեղադրված է նման վիրտուալ մեքենա: Իսկ Java վիրտուալ մեքենաներն արդեն գրվել են տարբեր ճարտարապետությունների համար: Ահա թե ինչպես են ձեռք բերվում բազմահարթակ ծրագրերը: Այս մոտեցման թերությունը կատարման ժամանակի ավելացումն է կոդի և պրոցեսորի միջև վիրտուալ մեքենայի տեսքով լրացուցիչ շերտի պատճառով: Բացի այդ, Java ծրագրերը հաճախ ավելի դանդաղ են աշխատում Java գրադարանների անկատարության պատճառով, օրինակ՝ GUI գրադարանների: Բայց այս ամենը մուլտիպլատֆորմի գինն է:

Եվ հենց վերջերս՝ 2017 թվականի վերջին, թողարկվեց Android Studio 3.0-ը, որը Java և C++ լեզուների հետ միասին սկսեց աջակցել Kotlin լեզվին։ (Կոտլին), որը, ինչպես Java-ն, նախատեսված է նույն բայթկոդը նույն վիրտուալ մեքենայի համար ստեղծելու համար, բայց ունի այլ շարահյուսություն, որը թույլ է տալիս գրել շատ ավելի կոմպակտ կոդ: Միևնույն ժամանակ, երկու լեզուներով աղբյուրի ֆայլերը կարող են առանց սահմանափակումների խառնվել մեկ նախագծում, ինչը հնարավորություն է տալիս աստիճանաբար ամբողջ նախագիծը տեղափոխել Կոտլին:

Լեզուն բոլորովին թարմ է։ Այն սկսել է զարգացնել 2010 թվականին, հանրությանը ներկայացվել է 2011 թվականին, Android-ի վրա ծրագրավորումը հնարավոր է դարձել 2012 թվականին, իսկ պաշտոնական թողարկումը թողարկվել է բոլորովին վերջերս՝ 2016 թվականին։ Ի դեպ, ավանդույթի համաձայն (ինչպես Java)լեզուն անվանվել է կղզու անունով: Այս անգամ դա Ֆիննական ծոցում գտնվող ռուսական Կոտլին կղզին է, որի վրա գտնվում է Կրոնշտադտ քաղաքը։ Եվ լեզուն մշակվել է Սանկտ Պետերբուրգի ծրագրավորողների կողմից, բոլորը նույն JetBrains ընկերությունում: Օ՜, ինչպես, իսկական ռուսերեն ծրագրավորման լեզու: [Հայրենասերները պետք է դրոշներ ծածանեն, իսկ այս գրառման հեղինակն արդեն շրջանաձև շրջում է սենյակում՝ սպառնալից թափահարելով անձնակազմը...]

Ես արդեն փորձել եմ գրել այս լեզվով Android-ի համար, և կարող եմ վստահորեն ասել, որ լեզուն բավականին հարմար է։ Նախկինում ես կորել էի Java կոդում, քանի որ Android-ում դուք պետք է գրեք ամեն ինչ և բոլորին, և դուք ստացաք ելակետային կոդի շատ երկար թերթեր: Արդյունքում, սկզբնական կոդը հասավ անպարկեշտ չափերի, և դրանք պետք է մանրակրկիտ բաժանվեին դասերի, լցնեին տարբեր ֆայլերի մեջ, իսկ հետո ես արդեն կորել էի ֆայլերի մեջ։ Կոտլինը օգտագործում է փիլիսոփայությունը «այն ամենն, ինչ կարող է ստեղծվել ավտոմատ կերպով, պետք է ստեղծվի ավտոմատ կերպով»: Մի կողմից՝ կոդը դառնում է ավելի քիչ թափանցիկ (մինուս, բայց գուցե միայն սկսնակների համար), բայց ավելի պարզ և կոմպակտ (մեծ պլյուս բոլորի համար):

Կոդի կոմպակտությունը ձեռք է բերվում ոչ միայն կրճատ շարահյուսական կառուցվածքների, այլև ստանդարտ գրադարանների շնորհիվ, որոնց կիրառման մեթոդը հատուկ հարմարեցված է կոմպակտության և էրգոնոմիկ օգտագործման համար: Դրա օրինակ կարող են լինել կորուտինները (կամ, որպես հետագծող թուղթ անգլերենից, կորուտիններ). Coroutine-ները կոդի ձևաչափման շատ պարզ, կոմպակտ եղանակ են, որը պետք է ասինխրոն գործարկվի հիմնական շղթայի կողմից: Կարիք չկա առանձին-առանձին մեթոդներով որևէ լրացուցիչ դաս գրել, ամեն ինչ արված է հենց հիմնական կոդում, և դա հիանալի է: Բացի այդ, ծրագրային ծրագրերն իրականացվում են հենց գրադարանի մակարդակով և չեն ստեղծում ծանր համակարգային թելեր: Դրանք նույնիսկ կոչվում են թեթև թելեր։ Հետևաբար, միաժամանակ գործարկվող դրանց քանակի սահմանափակումներ գործնականում չկան։ Կորուտիններն անհավանական են:

Ճարտարապետական ​​բաղադրիչներ Android-ի համար Google-ից

Պարզվեց նաև, որ շատ կոմպակտ է ստեղծել և օգտագործել SQLite տվյալների բազա՝ օգտագործելով Room գրադարանը, որը փաթաթված է հայտնի SQLiteOpenHelper դասի վրա: Room-ն օգտագործելու համար բավական է նկարագրել երկու փոքր դասեր, որոնք նկարագրում են աղյուսակը և տվյալների բազան, և մեկ փոքր ինտերֆեյս, որը նկարագրում է այս տվյալների բազայի հետ փոխազդելու գործառույթները: Կոտլինում այս ամենը տարբեր ֆայլերի մեջ դնելու կարիք չկա: Այս սակավ տեղեկատվության հիման վրա Room-ը կվերարտադրի բոլոր գործողությունները, որոնք նախկինում պետք է գրվեին հսկայական ֆայլերում՝ ավտոմատ և ներքին: Հրաշքներ։

Իրական հավելվածներում դուք պետք է հետևեք տվյալների բազայի փոփոխություններին և ավտոմատ կերպով թարմացնեք տեղեկատվությունը տեսողական բաղադրիչներում: Հետևաբար, Room բաղադրիչն ամենից հաճախ օգտագործվում է ոչ թե ինքնուրույն, այլ LiveData բաղադրիչի հետ միասին android.arch.lifecycle գրադարանից։ Այս բաղադրիչը նույնպես հեշտ է օգտագործել: Տվյալները, որոնք պետք է հետևվեն, տվյալների բազայից փոխանցվում են փոփոխականին ոչ ուղղակիորեն, այլ LiveData դասի տեսքով, որն այս տվյալները ստացել է որպես պարամետր Room-ի ներսում։ Դրանից հետո հիմնական կոդի մեջ Kotlin-ի մեկ տողը սահմանում է դրանց մոնիտորինգը և վիզուալ բաղադրիչի թարմացման գործառույթը, որը գործարկվում է, երբ տվյալները փոխվում են: Ամեն ինչ տարրական է!

Մեկ այլ օգտակար բաղադրիչ android.arch.lifecycle գրադարանից, որը լուծում է էկրանը պտտելիս գործունեության տվյալների պահպանման գլխացավանքը, ViewModel-ն է: Նախկինում անհրաժեշտ էր գրել ամեն տեսակ հնարամիտ հենակներ, որպեսզի տվյալները չկորչեն ու հաշվարկները չընդհատվեն։ Այժմ դրա համար կա պաշտոնական բաղադրիչ: Եթե ​​ավելի վաղ մենք առանձնացրել էինք ինտերֆեյսը կոդից (նշում և գործունեություն), ապա այժմ ժամանակն է առանձնացնել կոդը, որը պետք է գործարկվի միայն գործունեության կյանքի ցիկլի ընթացքում (օրինակ՝ օգտատիրոջ ինտերֆեյսի գործունեության ապահովում), կոդից, որը պետք է գործի որոշակի գործունեության կյանքի ցիկլից դուրս (օրինակ՝ տվյալների ստացում, մշակում և փոխանցում). Այս դեպքում մենք կարող ենք ավտոմատ կերպով կարդալ կոդի երկրորդ մասի արդյունքը էկրանը պտտելուց հետո վերստեղծված գործունեության մեջ։

Այս ամբողջ սխեման ViewModel-ով իրականացնելու համար անհրաժեշտ է նաև նվազագույն գործողություններ: Առանձին դաս է գրված կոդով, որը չպետք է ընդհատվի (այսպես կոչված դիտման մոդելը, չգիտեմ ինչու «մոդել», գուցե սխալ եմ թարգմանում), իսկ հիմնական կոդում մեկ տողում կանչվում է մոդելի մատակարարը, որին այս դասը փոխանցվում է որպես պարամետր։ Մատակարարը կամ վերադարձնում է գոյություն ունեցող մոդելի դասի օբյեկտ (էկրանը պտտելուց հետո), կամ ստեղծում է այդպիսի օբյեկտ՝ օգտագործելով անցած դասը, եթե այն դեռ գոյություն չունի, և նաև վերադարձնում է այն (երբ գործունեությունը մեկնարկում է առաջին անգամ). Գործունեությունը միշտ կարող է մուտք գործել այս օբյեկտի գործառույթները և փոփոխականները:

Բոլոր երեք բաղադրիչները համակցված են Android Architecture Components պաշտոնական անվան տակ: Ճիշտ է, այն ներառում է նաև LifeCycle բաղադրիչը, որը նույնպես գտնվում է android.arch.lifecycle գրադարանում, բայց այն օգտագործվում է LiveData-ի հետ սերտ համագործակցությամբ, և ես դա ընդհանրապես չէի ընդգծի: Նման բարձր մակարդակի բաղադրիչների ներդրումը ողջունելի քայլ է ճիշտ ուղղությամբ Google-ի համար: Ես երկար ժամանակ բողոքում էի, թե քանի տարբեր դասարաններ պետք է երկարացնեմ և բոլորը միացնեմ միմյանց, որպեսզի աշխատեն ոչ ավելի, քան պարզունակ դասագրքերի օրինակները: Եվ վերջապես գրադարանների մեջ սկսեցին հայտնվել ճիշտ բաղադրիչները։ Հուսով եմ, որ այս միտումը կշարունակվի:

Տեսողական ինտերֆեյսի խմբագիր

Սմարթֆոնների ծրագրավորման մեջ իմ հայտնաբերած նորամուծությունները դրանով չեն ավարտվում: Իր ծնունդից ի վեր, Android Studio-ն շատ դժվար ժամանակ ուներ վիզուալ ինտերֆեյսի խմբագրիչի կայունության և կանխատեսելիության հետ, թեև այն ավելի կայուն էր, քան Eclipse-ում: Նույնիսկ ուղղակիորեն խմբագրելով ինտերֆեյսի xml նշագրումը, շատ դժվար էր կարգավորել այս բոլոր դասավորությունները և այլ տեսողական բաղադրիչները, որպեսզի դրանք ցուցադրվեն ճիշտ տեղերում և ճիշտ ձևով:

Բարեբախտաբար, Android Studio-ում, սկսած 2.2 տարբերակից, տարրերի գծային դասավորության դասավորությունների միջոցով gimor ինտերֆեյս կառուցելու փոխարեն: (LinearLayout)առաջարկվում է կիրառել նոր հարկադիր դասավորությունը (ConstraintLayout). Բացի այդ, վերջապես վերջնական տեսքի բերվեց վիզուալ խմբագրիչը: Այս ամենը միասին շատ դրական ազդեցություն ունեցավ։ Այժմ տարրերը ճիշտ տեղավորելը այնքան էլ դժվար չէ, և նրանք իրենց բավականին կանխատեսելի են պահում: Այժմ դուք չեք կարող նույնիսկ դիպչել xml նշագրմանը, այլ կատարել բոլոր գործողությունները տեսողական խմբագրիչում:

18.05.2017, հինգշաբթի, 14:39, Մոսկվայի ժամանակով , Տեքստը՝ Ալեքսանդր Կորնև

Google-ի մշակողները Kotlin-ը դարձրել են Android OS-ի առաջին կարգի լեզու՝ նշելով, որ այն դեռ չի դառնա հիմնական «առաջին կարգի» Java լեզվի փոխարինումը։

Kotlin-ը որպես առաջին կարգի լեզու Android-ի համար

Հինգշաբթի օրը Google I/O ամենամյա կոնֆերանսի ժամանակ մշակողները հայտարարեցին, որ ռուս ծրագրավորողների կողմից ստեղծված Kotlin լեզուն կդառնա «առաջին կարգի լեզու»՝ Android-ի համար հավելվածներ գրելու համար։ Ինչպես գրում է TechCrunch-ը, Google-ը խոսել է նաև լեզուն ստեղծողների՝ JetBrains-ի հետ համատեղ Kotlin-ի զարգացման համար հատուկ հիմնադրամ կազմակերպելու մասին։

Google-ն ընդգծել է, որ Kotlin-ը լրացուցիչ լեզու է լինելու և ոչ մի կերպ չի փոխարինի Java-ին և C++-ին (այսօր Java-ն Android-ի համար առաջին կարգի լեզուն է)։ JetBrains IDE-ի վրա հիմնված Kotlin գործիքները նախատեսվում է որպես ստանդարտ ներառել Android Studio 3.0-ում՝ Android OS-ի մշակման պաշտոնական գործիքում:

«Քանի որ Kotlin-ն ամբողջությամբ աջակցվում է Java-ի կողմից, նախկինում կարող էիր հավելվածներ գրել դրանում, սակայն այժմ այն ​​կաջակցի Google-ի հեղինակությունն ու հեղինակությունը»,- նշում են լրագրողները։

Google-ը Android-ը թարգմանում է Ռուսաստանում ստեղծված լեզվի՝ Kotlin-ի

Սակայն Google-ը չի դառնում Kotlin-ի սեփականատերը։ Իրավունքները կշարունակեն պատկանել JetBrains-ին։ Լեզուն կշարունակի աշխատել այլ հարթակների հետ, օրինակ՝ որպես բնօրինակ կոդ iOS-ի և Mac-ի համար կամ վեբ հավելվածների համար JavaScript կոդ կազմելու համար:

Swift-ի հետ մրցակցության մեջ

Kotlin-ը ստատիկ տպագրված ծրագրավորման լեզու է, որն աշխատում է JVM-ի վերևում և կոմպիլյացիա է անում JavaScript-ում: Լեզուն մշակվել է 2010 թվականից, դրա սկզբնական կոդը բացվել է 2012 թվականին։ Կոտլինն իր անունը ստացել է ի պատիվ Ֆինլանդական ծոցում գտնվող Կոտլին կղզու, որի վրա գտնվում է Կրոնշտադտը։

Հիշեցնենք, որ 2016 թվականի գարնանը Google-ը հայտարարեց Swift-ում՝ iPhone-ի և iPad-ի ծրագրավորման լեզու, Android-ի համար հավելվածներ մշակելու հեռանկարի մասին։ Եվ հետո Կոտլինը անվանվեց որպես հնարավոր այլընտրանքային լեզու։ Սկզբում Swift-ը ներքին նախագիծ էր Apple-ում, սակայն հետագայում դրա սկզբնական կոդը բաց էր ծրագրավորողների համար:

Հաղորդվել է, որ Java-ի փոխարինման որոնման հնարավոր պատճառ կարող են լինել Oracle Corporation-ի հետ կապված իրավական խնդիրները, որը պնդում է, որ Google-ը խախտել է իր հեղինակային իրավունքը և արտոնագրերը։ Փորձագետները նշել են, որ Swift-ը Android-ին հարմարեցնելը կպահանջի բջջային ՕՀ-ի համար նոր աշխատաժամանակի միջավայր մշակել, ստանդարտ գրադարանի հարմարեցում, ծրագրավորման ինտերֆեյսներում (API) և մշակողների գործիքներում լեզվական աջակցություն և այլն:

Փորձագետների կարծիքով, Swift լեզուն տարբերվում է Kotlin-ից իր ավելի բարձր կատարողականությամբ։ Kotlin-ի առավելությունների թվում է արդեն նշված ամբողջական համատեղելիությունը JavaScript-ի հետ։

2010 թվականին JetBrains-ի ռուսական մասնաճյուղի ծրագրավորողների խումբը ձեռնամուխ եղավ մշակելու այնպիսի լեզու, որն ավելի հարմար և անվտանգ կլինի, քան Java-ն, բայց ոչ այնքան բարդ, որքան Scala-ն: Այս լեզվի անվանումը տրվել է ի պատիվ Կոտլին կղզու, որը գտնվում է Ֆինլանդիայի ծոցում (ի անալոգիա Java-ի հետ, որը նույնպես կոչվում է կղզու անունով):

Եթե ​​նայեք ծրագրավորման ամենախոստումնալից լեզուների ցանկացած ժամանակակից ակնարկ, այդ թվում, այնտեղ անպայման կգտնեք Կոտլին: Ո՞րն է այս լեզվի էությունը, ինչու է այն բոլորին այդքան դուր գալիս, ինչ հեռանկարներ ունի՝ դրա մասին ավելի ուշ:

Շարահյուսություն

Լեզու ստեղծելու գաղափարը, որը հավասարապես հարմար է ինչպես սկսնակների, այնպես էլ փորձառու մշակողների համար, ուղղակիորեն արտահայտված է դրա շարահյուսության մեջ: Ինչպես ցանկացած ժամանակակից անալոգային, Կոտլինը չափազանց հակիրճ է, կոմպակտ և հասկանալի: Հսկայական քանակությամբ կոդ, որը նախկինում պետք է գրվեր Java-ով, այժմ կարող է պարզապես անտեսվել: Պարզ օրինակ. ստորակետի օգտագործումը հայտարարությունները առանձնացնելու համար պարտադիր չէ. կոմպիլյատորն այժմ ամեն ինչ հասկանում է ինքնուրույն, եթե պարզապես անցնեք նոր տող: Փոփոխականներ հայտարարելիս շատ դեպքերում անհրաժեշտ չէ նշել տեսակը՝ այն կորոշվի ավտոմատ կերպով:

Միաժամանակ պետք է ասել, որ Կոտլինը ձայնագրության առումով մի փոքր վերադարձել է պասկալի ոճին - այստեղ էլ հստակությունը գերակշռում է կառուցվածքների պարզությանը։ Այս մասին մի փոքր ավելին կարող եք կարդալ այս կարճ հոդվածում: Այն ընդգրկում է միայն Java և Kotlin լեզուների կառուցման հիմնական սկզբունքները, ուստի այն հասկանալի կլինի բացարձակապես բոլորի համար:

Այնուամենայնիվ, մենք դեռ կթողնենք կոդի մի փոքր կտոր.

զվարճալի հիմնական (արգս. զանգված ) {
val scope = «աշխարհ»
println («Բարև, $scope!»)
}

Չափազանց պարզ գրառում, որը պետք է հասկանալի լինի յուրաքանչյուրի համար, ով առնվազն մեկ տարի սովորել է ծրագրավորում դպրոցում կամ համալսարանում:

Կարևոր է նշել, որ Կոտլինը լիովին համատեղելի է Java-ի հետ։ Այդ իսկ պատճառով սկզբում այն ​​համարվում էր պարզ շարահյուսական շաքար, որն օգտագործվում էր բարդ առաջադրանքների համար, որտեղ պարզապես ցանկանում էին խնայել ժամանակ և ջանք։

Առավելությունները

Ընդհանուր առմամբ, Java-ի համեմատ բոլոր առավելություններն արդեն նշվել են, ուստի մենք դրանք պարզապես կհավաքենք մեկ տեղում.

Կոդի ծավալը. Կոդերի անհարկի հնացած կտորներ չօգտագործելը արագացնում է մշակման գործընթացը և մեծացնում ընթերցելիությունը.

Անվտանգություն. Լեզվի շարահյուսության մեջ ներկառուցված կոդի ստեղծման կանոնները թույլ են տալիս խուսափել փոքր, դժվարին հետևելու սխալներից, որոնք առաջանում են միայն ծրագրի կատարման ժամանակ.

Համատեղելիություն Java-ում. Սա հարմար է ինչպես նոր լեզու սովորելու, այնպես էլ ձեր ծրագրային արտադրանքը Java-ից Կոտլին աստիճանաբար տեղափոխելու տեսանկյունից։ Օրինակ, սա հենց այն է, ինչ տեղի ունեցավ Basecamp հավելվածի հետ:

Թերություններ

Որպես լեզու, որը մշակվել է Java-ի հիման վրա, Kotlin-ը համեմատած երկու ակնհայտ թերություն ունի՝ արագություն և մշակում: Առաջին դեպքում ամեն ինչ պարզ է. JVM-ի վրա աշխատելը արդյունավետության առումով դժվար է հաղթել Java-ին: Երկրորդ խնդիրը նման երիտասարդ լեզվի համար մի փոքր հեռու է, քանի որ այն պաշտոնական շրջանառության մեջ է արդեն մեկ տարուց քիչ ավելի: Այո, այստեղ զգալիորեն ավելի քիչ գործիքներ և գրադարաններ կան, քան Java-ում: Բայց, նախ, սա դեռ կարևոր չէ, և երկրորդը, Java աշխարհում քանակությունը միշտ չէ, որ վերածվել է որակի:

Կոտլինը, առայժմ, հաղթահարում է իր հիմնական խնդիրները, և Java-ի հետ լիարժեք համատեղելիությունը օգնում է մեր աչքերը փակել այս բացերի վրա:

հեռանկարներ

Չնայած այն հանգամանքին, որ Kotlin-ի զարգացումը սկսվել է 2010 թվականին, առաջին պաշտոնական տարբերակը թողարկվել է միայն 2016 թվականի փետրվարին: Այդ ժամանակից ի վեր լեզվի պահանջարկը արագորեն աճում է, TIOBE վարկանիշում այն ​​մեկ տարվա ընթացքում ներխուժել է TOP-50: , իսկ անցյալ ամիս Google I կոնֆերանսում /O-ն հայտարարեց Kotlin-ի պաշտոնական աջակցության մասին Android հավելվածների մշակման համակարգում։

Հաշվի առնելով IntelliJ IDEA-ի բարձր ժողովրդականությունը ծրագրավորողների շրջանում և ընկերության ռազմավարական կենտրոնացումը Kotlin-ի վրա, կարող ենք վստահորեն ասել, որ 3-4 տարի հետո մենք նրան կտեսնենք Java-ի և Swift-ի լիիրավ մրցակիցների շարքում բջջային զարգացման ոլորտում: Բացի այդ, եթե լեզուն ստեղծողները չհիասթափվեն իրենց արտադրանքից, Կոտլինը, անշուշտ, կշարունակի լրջորեն գրավել այլ հորիզոններ՝ վեբ, AI, իրերի ինտերնետ, մեծ տվյալներ, աշխատասեղանի հավելվածներ:

Եթե ​​դուք լրջորեն հետաքրքրված եք այս լեզվով, ապա անպայման դիտեք նրա պաշտոնական կայքը (ռուսերեն տարբերակ) և փորձեք դրա բոլոր առավելությունները անձնական փորձից: Շտապե՛ք, քանի դեռ այն չի անցել հիմնական:

Վերջին թարմացումը՝ 12/02/2017

Kotlin-ը ստատիկ տպագրված ծրագրավորման լեզու է JetBrains-ից: Kotlin-ը կարող է օգտագործվել բջջային և վեբ հավելվածներ ստեղծելու համար:

Kotlin-ն աշխատում է Java վիրտուալ մեքենայի (JVM) վերևում և կոմպիլյացիայի ժամանակ կազմվում է բայթկոդի: Այսինքն, ինչպես Java-ի դեպքում, մենք կարող ենք գործարկել Kotlin հավելվածը, որտեղ JVM-ն տեղադրված է: Չնայած հնարավոր է նաև կոդը կազմել JavaScript-ով և գործարկել այն բրաուզերում: Եվ, ի լրումն, դուք կարող եք կազմել Kotlin կոդը բնիկ երկուականների մեջ, որոնք կաշխատեն առանց որևէ վիրտուալ մեքենայի: Այսպիսով, հարթակների շրջանակը, որոնց համար կարող եք հավելվածներ ստեղծել Կոտլինում, չափազանց լայն է՝ Windows, Linux, Mac OS, iOS, Android:

Լեզվի առաջին տարբերակը թողարկվել է 2016 թվականի փետրվարի 15-ին։ Թեպետ լեզվի մշակումն ինքնին իրականացվում է 2010 թվականից։ Լեզվի ընթացիկ տարբերակը այս պահին 1.2 տարբերակն է, որը թողարկվել է 2017 թվականի նոյեմբերի 28-ին։

Kotlin-ը կրել է բազմաթիվ լեզուների ազդեցությունը՝ Java, Scala, Groovy, C#, JavaScript, Swift և թույլ է տալիս ծրագրեր գրել ինչպես օբյեկտի վրա, այնպես էլ ֆունկցիոնալ ոճերում: Այն ունի հստակ և հասկանալի շարահյուսություն և բավականին հեշտ է սովորել:

Ամենահայտնի տարածքը, որտեղ օգտագործվում է Kotlin-ը, հիմնականում Android OS-ի մշակումն է: Ավելին, այնքան տարածված է, որ Google-ը Google I/O 2017 կոնֆերանսում Kotlin-ը հայտարարեց Android-ի մշակման պաշտոնական լեզուներից մեկը (Java-ի և C++-ի հետ միասին), և այս լեզվով աշխատելու գործիքները լռելյայն ներառվեցին ֆունկցիոնալության մեջ: Android Strudio-ի մշակման միջավայրը՝ սկսած 3.0 տարբերակից:

Կոմպիլյատորը կարող եք ներբեռնել անմիջապես հենց Կոտլին լեզվի համար՝ այստեղից:

Արխիվը կարելի է գտնել վերը նշված հասցեում։ Ներբեռնեք և բացեք kotlinc թղթապանակը արխիվից: bin թղթապանակի չփաթեթավորված արխիվում մենք կարող ենք գտնել kotlinc կոմունալ ծրագիրը, որը կօգտագործվի կազմելու համար.

Այժմ եկեք սահմանենք տեղեկատու կոշտ սկավառակի վրա սկզբնական կոդի ֆայլերի համար: Օրինակ, իմ դեպքում գրացուցակը կգտնվի c:/kotlin ճանապարհի երկայնքով: Եկեք այս գրացուցակում ստեղծենք տեքստային ֆայլ և վերանվանենք այն app.kt: kt ընդլայնումը Kotlin լեզվով ֆայլերի ընդլայնումն է:

Զվարճալի հիմնական (args: Array )( println(«Բարև Կոտլին») )

Այս դեպքում սահմանում ենք հիմնական ֆունկցիան, որը կներկայացնի ծրագրի կատարած գործողությունները։ Գործառույթ սահմանելու համար օգտագործեք զվարճալի բանալի բառը:

Այս ֆունկցիան վերցնում է args պարամետրը, որը ներկայացնում է տողերի զանգված։

Հիմնական ֆունկցիայի ներսում կատարվում է մեկ այլ ֆունկցիա՝ println(), որը տպում է որոշակի հաղորդագրություն կոնսոլին։

Եկեք բացենք հրամանի տողը: Նախ, օգտագործեք cd հրամանը՝ նավարկելու այն թղթապանակը, որտեղ գտնվում է app.kt ֆայլը: Այնուհետև ծրագիրը կազմելու համար մուտքագրեք հետևյալ հրամանը.

C:\kotlin\bin\kotlinc app.kt -include-runtime -d app.jar

Այս դեպքում մենք app.kt ֆայլը փոխանցում ենք c:\kotlin\bin\kotlinc կոմպիլյատորին կոմպիլացիայի համար։ (Կոմպիլյատորին ամբողջական ուղին գրելուց խուսափելու համար կարող եք դրա ուղին ավելացնել շրջակա միջավայրի փոփոխականների PATH փոփոխականին): Հաջորդը, օգտագործելով -include-runtime պարամետրը, դուք նշում եք, որ ստեղծված ֆայլը կներառի Kotlin միջավայրը: Իսկ -d պարամետրը նշում է, թե ինչպես է կոչվելու ստեղծված հավելվածի ֆայլը, այսինքն՝ այս դեպքում այն ​​կլինի app.jar ։

Այս հրամանը գործարկելուց հետո կստեղծվի app.jar ֆայլը: Հիմա եկեք գործարկենք այն: Դա անելու համար մուտքագրեք հրամանը

Java -jar app.jar

Այս դեպքում ենթադրվում է, որ համակարգչի վրա տեղադրված JDK-ի ուղին նշված է միջավայրի փոփոխականների PATH փոփոխականում: Հակառակ դեպքում, «java»-ի փոխարեն դուք ստիպված կլինեք գրել java կոմունալ ծրագրի ամբողջական ուղին:

Արդյունքում, երբ մենք գործարկում ենք ֆայլը, մենք կտեսնենք «Hello Kotlin» տողը վահանակի վրա: