Գնահատել նախագիծը
← Բոլոր հրապարակումները

Kotlin. Բացթողումները և դրանք շրջանցելու ուղիները

Բացահայտեք Kotlin-ում բացակայող 5 ամենաէական հնարավորությունները և դրանք շրջանցելու գործնական եղանակները։

10 րոպե
KotlinԾրագրավորման լեզուներKotlinServerSide

Kotlin-ը ժամանակակից, մտածված նախագծված, ընդհանուր նշանակության ծրագրավորման լեզու է, որը դառնում է վեբ մշակման համար գրավիչ տարբերակ։ Այն լավ աջակցում է ֆունկցիոնալ ծրագրավորմանը, ունի լիարժեք կորուտիններ, դոմենային լեզուներ ստեղծելու հնարավորություն, տիպերի խելացի բերում և շատ այլ առավելություններ, որոնք հազվադեպ են հանդիպում մյուս տարածված ծրագրավորման լեզուներում։ Ցավոք, կատարյալ ոչինչ չկա, և Kotlin-ն էլ ունի մի քանի թերություն, որոնք առավել փորձառու ծրագրավորողներին կարող են անհարմար թվալ։

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

Package-private մուտքի մոդիֆիկատորի բացակայություն

Java կոդը կառուցելու տիպական եղանակը փաթեթների բաժանելն է, ընդ որում յուրաքանչյուր փաթեթ կենտրոնացած է դոմենի մեկ մասի վրա։ Լռելյայն մուտքի մոդիֆիկատորը package-private-ն է, ուստի եթե մոդիֆիկատոր չնշես, դասը կամ անդամը հասանելի կլինի միայն նույն փաթեթի ներսից։ Փաթեթին կարելի է դիմել միայն այն դասերի ու անդամների միջոցով, որոնք ծրագրավորողը գիտակցաբար հրապարակային (public) է դարձրել, և դրանք փաթեթի ֆասադի դերն են կատարում։ Այս մոտեցումը համապատասխանում է օբյեկտ-կողմնորոշված ծրագրավորման հիմնարար գաղափարներից մեկին՝ ինկապսուլյացիային։ Ցավոք, Kotlin-ում այս մոդիֆիկատորը չկա, ուստի փաթեթները շարահյուսության մակարդակով ինկապսուլացնել հնարավոր չէ։

Ստորև բերված է Java նախագծի դասական կառուցվածքի օրինակ և այն, թե ինչպես է այն հենվում package-private մոդիֆիկատորի վրա։

com/example/project/
├── api/
│   ├── PizzaEndpoints.java          (public/package-private)
│
├── domain/
│   ├── pizza/
│   │   ├── PizzaFactory.java        (public) // can be used in kitchen
│   │   ├── Pizza.java               (public) // can be used in kitchen
│   │   ├── DefaultPizzaFactory.java (package-private)
│   │   ├── DoughFactory.java        (package-private)
│   │
│   ├── kitchen/
│   │   ├── KitchenService.java      (package-private)
│
├── infrastructure/
│   ├── DatabaseConfig.java          (package-private)

Kotlin-ը հավանաբար package-private-ը չի ներառել, որպեսզի անվտանգության կեղծ զգացողություն չստեղծի։ Մոդիֆիկատորը լիովին չի արգելափակում այլ մոդուլներից մուտքը, քանի որ անդամներին դեռ կարելի է դիմել, եթե մեկ այլ մոդուլ օգտագործում է նույն փաթեթի անունը։ Այդուհանդերձ, չեմ կարող շատ իրավիճակներ պատկերացնել, որտեղ դա իրական խնդիր կառաջացնի։ Ինկապսուլյացիան շրջանցելու ինչ-որ «հաքերային» եղանակ միշտ կա, բայց դա չի նշանակում, որ պետք է այն օգտագործել։ Իմ կարծիքով՝ package-private-ը, չնայած այս թուլությանը, դեռ շատ առավելություններ է տալիս։ Այն նույնիսկ կարելի է Java-ի տարբերակից ավելի լավը դարձնել՝ ավելացնելով պաշտպանություն նման շրջանցումներից։ Լրացուցիչ տեղեկության համար տե՛ս package-private տեսանելիության մոդիֆիկատոր տրամադրելու մասին խնդիրը և դրա շուրջ ծավալված քննարկումը։

Ցավոք, դրա համար պարզ շրջանցում չկա, գոնե շարահյուսության մակարդակով։ Kotlin-ն ունի internal մուտքի մոդիֆիկատոր, բայց այն սահմանափակում է մուտքը մոդուլի մակարդակով։ Մոդուլներ ստեղծել միայն առանձին դասերի կամ ֆունկցիաների տեսանելիությունը կառավարելու համար չափազանցություն կլիներ, հատկապես երբ դա պետք է միայն մի քանիսին։ Դա չի նշանակում, որ պետք է խուսափել նախագիծը մոդուլների բաժանելուց. ընդհակառակը, դա հաճախ լավ գաղափար է։ Այնուամենայնիվ, մոդուլի ներսում հայտարարությունների տեսանելիության ավելի նուրբ վերահսկողությունն ավելի նախընտրելի կլիներ։ Եթե միևնույնն է ուզում եք package-private մուտքը պարտադրել, կարող եք փորձել Konsist-ը (Kotlin-ի համարժեքը ArchUnit-ին)՝ ճարտարապետական թեստեր գրելու համար, որոնք արգելում են ֆասադի մաս չհանդիսացող անդամներին դիմել այլ փաթեթներից։ Այս մոտեցումը, սակայն, վիճելի է և հստակորեն ավելի քիչ արդյունավետ է, քան շարահյուսության մեջ ներկառուցված աջակցությունը։

Union տիպերի բացակայություն

Union տիպերը թույլ են տալիս հայտարարել տիպ, որը ներկայացնում է մի քանի լիովին անկապ տիպերից մեկը, առանց ժառանգման կամ դրանց միջև որևէ այլ կապի։ Օրինակ՝ ստորև բերված ֆունկցիան կարող է վերադարձնել կամ Error, կամ String։

fun doSomething(): String | Error =  // syntax not supported yet
    if(...) "string" else Error("message")

// this is exhaustive - no `else` required 
val finalResult = when(val result = doSomething()) { 
    is String -> result.doSomething()
    is Error -> handleError(result)
}

Ինչպես կարելի է կռահել, այս հնարավորությունը հարմար է բացահայտ սխալների մշակման համար. սա ֆունկցիոնալ ծրագրավորման պարադիգմում տարածված մեթոդ է, որը խուսափում է բացառություններից, քանի որ դրանք խախտում են ֆունկցիայի մաքրությունը և կոդը դարձնում են ավելի քիչ կանխատեսելի։

Ցավոք, Kotlin-ը դեռ չի աջակցում union տիպերը, թեև sealed դասերի միջոցով կարելի է նման արդյունքի հասնել, ինչպես ցույց է տրված ստորև։

sealed interface Result {
    data class Success(val value: String) : Result
    data class Error(val message: String) : Result
}

fun doSomething(): Result = 
    if(...) Result.Success("string") else Result.Error("message")

// this is exhaustive - no `else` required 
val finalResult = when(val result = doSomething()) { 
    is String -> result.doSomething()
    is Error -> handleError(result)
}

Այստեղ լավ է աշխատում sealed interface-ը, քանի որ այն երաշխավորում է, որ ուրիշ դասեր չեն կարող ժառանգել Result-ից։ Այս սահմանափակումը հետո կարելի է օգտագործել when արտահայտության մեջ՝ բոլոր հնարավոր դեպքերը սպառիչ կերպով ծածկելու համար։

Sealed դասերի ամենամեծ թերությունը դրանց պահանջած կոդի քանակն է։ Սխալների մշակման համար Result տիպի ինտերֆեյսն ու դրա ենթադասերը պետք է զրոյից գրել ամեն անգամ, երբ ֆունկցիայի այլընտրանքային արդյունքների նոր հավաքածու պետք է մոդելավորել։ Սա նաև զգալիորեն դժվարացնում է կոդի վերօգտագործումը։ Պատկերացրեք՝ ուզում եք Result տիպին ավելացնել ևս մեկ հնարավոր վիճակ (ասենք՝ NetworkError FileError-ի կողքին) միայն մեկ դեպքի համար։ Այդ ժամանակ ստիպված եք ըստ էության պատճենել ամբողջ Result դասը իր բոլոր ենթադասերով և ավելացնել ևս մեկ ենթադաս նոր վիճակի համար։ Union տիպերը դա շատ ավելի հեշտ կդարձնեին։

class ParsingError
class FileError
class Success;

fun doSomething(): ParsingError | Success // syntax error: union types
fun doSomethingElse(): ParsingError | FileError | Success

Մեկ այլ հնարավոր շրջանցում է Arrow գրադարանի Either դասը։

fun doSomething(): Either<Success, ParsingError>

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

Union տիպերի առաջարկի և քննարկման մասին ավելին կարելի է գտնել այստեղ։ Այնտեղ առաջարկվում է նաև տիպերի հատման ավելի լիարժեք իրականացում, որը Kotlin-ն այժմ աջակցում է միայն շատ սահմանափակ չափով։

Multi-catch բլոկի բացակայություն

Union տիպերի թեմայի առիթով… գիտե՞ք, որ Java-ն իրականում ունի դրանց սահմանափակ տարբերակ։ Դրանք կարող են օգտագործվել միայն որպես catch պարամետրեր՝ բացառությունները մշակելիս։ Մի քանի catch բլոկ գրելու փոխարեն, ինչպես այստեղ.

try {
    // ... throw ...
}
catch (final ClassNotFoundException ex1) {
    // ... body ...
}
catch (final IllegalAccessException ex2) {
    // ... body ...
}

կարող եք գրել այսպես.

try {
    // ... throw ...
} catch (ClassNotFoundException | IllegalAccessException ex) {
    // ...body ...
}

Ցավոք, Kotlin-ը union տիպերի աջակցություն չունի որևէ տեսքով, նույնիսկ catch բլոկում։

Kotlin-ը մի քանի եղանակ է տալիս սա շրջանցելու համար։ Նախ, հնարավորության դեպքում հավանաբար պետք է ընդհանրապես խուսափել բացառություններից։ Եթե դա տարբերակ չէ, կարող եք օգտագործել այսպիսի կառուցվածք.

try {
    // ...
} catch (e: Exception) {
    when(e) {
        is ClassNotFoundException, is IllegalAccessException -> { /* ... */ }
        else -> throw e
    }
}

Պարզապես մի՛ մոռացեք նորից նետել չհամընկնող բացառությունները (else -> throw e), որպեսզի ոչինչ լուռ չկուլ գնա։ Այդ նորից նետումը մոտեցումը կատարյալ չի դարձնում, բայց դա բավարար է շատ իրավիճակների համար։

Multi-catch բլոկներ ավելացնելու մասին քննարկումը հասանելի է Kotlin YouTrack-ի այս խնդրում։

Բարդ pattern matching-ի բացակայություն

Pattern matching-ը այսօր ժամանակակից ծրագրավորման լեզուների ստանդարտ մասն է։ Նույնիսկ Java-ն այն ավելացրեց JDK 21-ում՝ ընդլայնելով switch արտահայտությունների հնարավորությունները։ Pattern matching-ը կոդը դարձնում է առավել կոմպակտ և դեկլարատիվ, ինչը լավ համապատասխանում է ֆունկցիոնալ ծրագրավորման սկզբունքներին։ Kotlin-ն առաջարկում է հզոր when արտահայտություն՝ հսկողության հոսքի և տիպերի ստուգման համար, բայց չի տալիս լիարժեք pattern matching, ինչպես, օրինակ, Scala-ի նման լեզուները։ Արտահայտությունը աջակցում է տիպերի ստուգում և արժեքների համեմատում, ինչը այն դարձնում է if-else if շղթաների պարզապես ավելի կոմպակտ այլընտրանք։

Kotlin-ը վերջերս ստացավ փոքր բարելավում՝ Kotlin 2.1.0-ում փորձնական guard պայմանների հայտնվելով, որոնք թույլ են տալիս when-ի ճյուղերին կցել լրացուցիչ պայմաններ։

sealed interface Ingredient {
    data class Tomato(val ripe: Boolean) : Ingredient {
        fun makeSauce() {}
    }

    data class Cheese(val type: String) : Ingredient {
        fun meltCheese() {}
    }
}

fun preparePizza(ingredient: Ingredient) {
    when (ingredient) {
        is Ingredient.Cheese -> ingredient.meltCheese()
        is Ingredient.Tomato if ingredient.ripe -> ingredient.makeSauce()
        else -> println("Unknown ingredient")
    }
}

Սա իրականում շատ մոտ է այն guard pattern-ներին, որ տալիս է Java 21-ը, բայց Kotlin-ում այն դեռ փորձնական է, ուստի հավանաբար չպետք է հենվել դրա վրա արտադրական կոդում։ Java-ից այն կողմ նայելիս՝ Scala-ի կամ նույնիսկ Python-ի նման լեզուները տալիս են Kotlin-ից շատ ավելի զարգացած pattern matching, հիմնականում այն պատճառով, որ Kotlin-ի when արտահայտությունը չի աջակցում դեստրուկտուրիզացիա։

Pattern matching-ի առաջարկը և քննարկումը Kotlin-ում գտնվում են Kotlin YouTrack-ի այս խնդրում։

Ռեկուրսիվ դեստրուկտուրիզացիայի հայտարարությունների բացակայություն

Շարունակելով դեստրուկտուրիզացիայի թեման՝ Kotlin-ը դեստրուկտուրիզացիայի հայտարարությունները շատ լավ է աջակցում, ինչպես ցույց են տալիս հետևյալ օրինակները։

data class Result(val code: Int, val message: String)
fun doSomething() = Result(5, "OK")

// destructuring works automatically for data classes
val (statusCode, message) = doSomething()

// you can omit the variable name if you don't need it:
val (_, message) = doSomething()

// can be used in loops
val map = mapOf("key" to "value")
for ((key, value) in map) {
    // ...
}

// can be used in lambdas
map.mapValues { (key, value) -> "<$key>$value</$key>" }

Սակայն ռեկուրսիվ դեստրուկտուրիզացիան (այսինքն՝ ներդրված հատկությունների համար) Kotlin-ում չի աջակցվում։ Օրինակ, հետևյալը չի աշխատի.

data class Person(val name: String, val age: Int)
data class Company(val name: String, val ceo: Person)
fun findCompanies(): Map<String, Company>
findCompanies() // syntax error \/
    .map { (id, (companyName, ceo)) -> "$id: $companyName (CEO: $ceo)" }

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

Այս հնարավորությունը Kotlin-ում ավելացնելու առաջարկի մասին ավելին իմանալու համար տե՛ս Kotlin YouTrack-ի այս խնդիրը։ Եթե կարծում եք, որ դա արժեքավոր հավելում կլինի Kotlin-ի համար, մտածեք դրա օգտին քվեարկելու մասին։

Եզրակացություն

Kotlin-ը գերազանց ժամանակակից ընդհանուր նշանակության ծրագրավորման լեզու է, որը նկատելիորեն բարձրացնում է արտադրողականությունը և թիմերում ծրագրավորողներին ավելի երջանիկ դարձնում 😉։ Բնականաբար, ոչինչ կատարյալ չէ, և միշտ կա բարելավման տեղ։ Այս գրառման մեջ քննարկված հնարավորությունները ընտրել եմ Kotlin-ի իրական նախագծերում իմ սեփական փորձի հիման վրա։ Շատ ծրագրավորողներ, թվում է, կիսում են այս ցավոտ կետերը, ինչպես ցույց է տալիս YouTrack-ում ձայների մեծ քանակը։ Միևնույն ժամանակ չեմ զարմանա, եթե որոշ ծրագրավորողներ նախընտրեն, որ այս հնարավորությունները չավելացվեն՝ դրանք համարելով ավելորդ։ Ծրագրավորման լեզվին հնարավորություններ ավելացնելը նուրբ հարց է, և լեզվի նախագծողները չպետք է իրականացնեն այն ամենը, ինչ համայնքը խնդրում է, քանի որ դա լեզուն ավելի բարդ կդարձնի։

Պարզությունը պահպանելն ինքնին արժեքավոր հնարավորություն է։
Եթե հետաքրքրված եք, հնարավորությունների այլ խնդրանքներ թվարկված են Kotlin YouTrack-ի այս խնդրում (ես արդեն զտել և դասավորել եմ դրանք ձեզ համար)։ Եթե հանդիպեք հնարավորությունների, որոնք կուզենայիք տեսնել լեզվում, խստորեն խրախուսում եմ դրանց օգտին քվեարկել։ Հուսով եմ՝ այստեղ նկարագրված շրջանցումները կօգնեն ձեզ հաղթահարել այս սահմանափակումները ձեր նախագծերում (կամ գոնե թույլ կտան ցավը կիսել ինձ հետ)։ Չնայած այս փոքր թերություններին, Kotlin-ի հետ աշխատելը դեռ հաճույք է։

Այս գրառման մեջ քննարկված հնարավորությունների խնդրանքների հղումներ