Kotlin 2.1 մոտիկից – Ոչ լոկալ ելքերից մինչև բազմադոլար տողեր
2024 թվականի նոյեմբերին թողարկվեց Kotlin 2.1-ը։ Եկեք նայենք լեզվի այն մի քանի փոփոխություններին, որոնք եկան նոր տարբերակի հետ։
Kotlin-ի համար անցյալ տարին կարևոր էր. թողարկվեց 2.0.0 հիմնական տարբերակը մայիսին։ Այն բերեց բազմաթիվ հետաքրքիր հնարավորություններ, առաջին հերթին՝ կայուն K2 կոմպիլյատորը, բայց գրեթե չշոշափեց հենց լեզվի նախագծումը։ Այլևս այդպես չէր, երբ անցյալ նոյեմբերին թողարկվեց 2.1.0 տարբերակը։ Թեև դրանք դեռ preview փուլում են, այս թողարկումը բերեց լեզվի մի շարք փոփոխություններ, որոնք արժանի են ավելի մոտիկից նայելու։ Այս հոդվածը քննում է, թե ինչ նոր բան կա Kotlin 2.1-ում՝ կենտրոնանալով լեզվի նոր ավելացված հնարավորությունների վրա։
Նախապայմաններ
Kotlin 2.1-ում ավելացված լեզվի մի քանի հնարավորություններ (որոնք քննարկվում են հոդվածի հետագա մասում) դեռ preview փուլում են, ուստի չպետք է դրանց վրա հենվեք production կոդում, քանի որ հետագա թողարկումները կարող են դրանք փոխել կամ հեռացնել։ Այս հնարավորությունները ձեր նախագծում օգտագործելու համար պետք է դրանք միացնեք կոմպիլյատորի ընտրանքներով։ Օրինակ՝ Gradle-ի դեպքում build ֆայլում գրեք հետևյալը՝
kotlin {
compilerOptions {
freeCompilerArgs.add("-X<feature-name>")
}
jvmToolchain(21)
}
Ներքևում յուրաքանչյուր հնարավորության բաժինը նշում է հնարավորության անունը, որը պետք է դնել «-X»-ից հետո (միայն երբ հնարավորությունը դա պահանջում է)։
Բացի այդ, այս լեզվական հնարավորությունները IntelliJ IDEA-ում օգտագործելու համար պահանջվում է 2024.3.0 կամ ավելի նոր տարբերակ՝ միացված K2 ռեժիմով։ K2 ռեժիմը միացնելու համար անցեք Settings → Languages & Frameworks → Kotlin և նշեք «Enable K2 mode» վանդակը (դրանից հետո IDE-ն պետք է վերագործարկել)։
Հիմունքները պարզաբանելուց հետո եկեք նայենք այն նոր հնարավորություններին, որոնք բերում է Kotlin-ի վերջին թողարկումը։
Փոփոխություններ when արտահայտության մեջ Kotlin 2.1-ում
Kotlin-ի when արտահայտությունը ճկուն միջոց է ծրագրի հոսքը կառավարելու համար և հակիրճ մշակում է բազմաթիվ պայմաններ։ Որքան էլ հզոր է, այն չունի Scala-ի նման լեզուներից հայտնի pattern matching-ի լիարժեք հնարավորությունները։ Kotlin 2.1.0-ն բերեց բարելավումներ, որոնք վերացնում են այդ սահմանափակումներից մի քանիսը։ Այս բաժինը դիտարկում է, թե ինչ է փոխվել when արտահայտության մեջ։
Սպառիչության ստուգումներ when արտահայտությունների համար sealed դասերով
Kotlin-ի վերջին տարբերակը փոխում է, թե ինչպես են վերաբերվում սուբյեկտ ունեցող when արտահայտություններին այն տիպային պարամետրերի համար, որոնց վերին սահմանները sealed են։ Եկեք տեսնենք, թե կոնկրետ ինչով է տարբերվում։ Պատկերացնելու համար ենթադրենք՝ ունենք sealed դաս, որը նկարագրում է HTTP հարցման հնարավոր արդյունքները՝
sealed class HttpRequestResult {
data class Success(val code: Int, val body: String) : HttpRequestResult()
data class Error(val code: Int, val errorMessage: String) : HttpRequestResult()
object Timeout : HttpRequestResult()
class ConnectionError() : HttpRequestResult()
}
Երբ ստանում ենք հարցման արդյունքը, ցանկանում ենք այն ինչ-որ կերպ մշակել։ Պարզության համար ասենք՝ ուզում ենք ստանալ String ներկայացում՝ կախված արդյունքի տեսակից։ Դա անելու եղանակներից մեկը ֆունկցիան է, որի տիպային պարամետրը սահմանափակված է մեր sealed դասով՝ HttpRequestResult։ Kotlin 2.1-ից առաջ նման ֆունկցիան կարող էր ունենալ հետևյալ տեսքը՝
fun <T: HttpRequestResult> processHttpRequestResult(
response: T,
successMapper: (T) -> String,
): String =
when (response ) {
is HttpRequestResult.Success -> successMapper(response)
is HttpRequestResult.Error -> "Error returned by server ${response.code}: ${response.errorMessage}"
is HttpRequestResult.Timeout -> "Connection Timeout"
is HttpRequestResult.ConnectionError -> "Connection error"
else -> "But, why??" // compilation error if else branch is missing
}
Նկատեք, որ else ճյուղը պարտադիր է, թեև վերևի ճյուղերն արդեն ծածկում են sealed դասի բոլոր դեպքերը։ Սա Kotlin-ի տարօրինակ առանձնահատկություն էր մինչև 2.1.0-ը. այն պահանջում է else ճյուղ when արտահայտության մեջ sealed վերին սահմաններով տիպային պարամետրերի համար։ else ճյուղի բացակայության դեպքում կոմպիլյացիան ձախողվում է այս սխալով՝
«‘when’ expression must be exhaustive. Add an ‘else’ branch.»
Kotlin 2.1.0-ն սա շտկում է, այնպես որ else ճյուղն այլևս անհրաժեշտ չէ՝
fun <T: HttpRequestResult> processHttpRequestResult(
response: T,
successMapper: (T) -> String,
): String =
when (response ) {
is HttpRequestResult.Success -> successMapper(response)
is HttpRequestResult.Error -> "Error returned by server ${response.code}: ${response.errorMessage}"
is HttpRequestResult.Timeout -> "Connection Timeout"
is HttpRequestResult.ConnectionError -> "Connection error"
}
Դա մեզ խնայում է մի քանի ավելորդ նիշ. մանրուքները կարևոր են։ Այս լեզվական հնարավորությունը կայուն է, ուստի preview ռեժիմը միացնելու կարիք չկա։
Guard պայմաններ when-ում սուբյեկտով (preview հնարավորություն «when-guards»)
Հաջորդը, ենթադրենք՝ ուզում ենք սխալների մշակում, որը կախված է սխալի կոդից և 4XX և 5XX սխալների համար տալիս է տարբեր տողային ներկայացումներ։ Kotlin 2.1.0-ից առաջ դա հավանաբար կաներ ներդրված when կամ if/else հայտարարություններով՝
fun processHttpRequestResult(response: HttpRequestResult): String =
when (response) {
is HttpRequestResult.Success -> "Success with code ${response.code} and body: ${response.body}"
is HttpRequestResult.Error -> {
when (response.code) {
in 400..499 -> "Client's error ${response.code}: ${response.errorMessage}"
500 -> "Server's error ${response.code}: ${response.errorMessage}"
else -> "Other error returned by server ${response.code}: ${response.errorMessage}"
}
}
is HttpRequestResult.Timeout -> "Connection Timeout"
is HttpRequestResult.ConnectionError -> "Connection error"
}
Ընթացիկ Kotlin թողարկումը «guard պայմաններ» է բերում այն when արտահայտություններին կամ հայտարարություններին, որոնք սուբյեկտ ունեն։ Դրանք թույլ են տալիս when-ի ճյուղերին կցել լրացուցիչ պայման, ինչը հոսքը դարձնում է ավելի բացահայտ և կոդը՝ ավելի հարթ՝ ի համեմատ վերևի ներդրված տարբերակի՝
fun processHttpRequestResultWithGuard(response: HttpRequestResult): String =
when (response) {
is HttpRequestResult.Success -> "Success with code ${response.code} and body: ${response.body}"
is HttpRequestResult.Error if response.code in (400..499) -> "Client's error ${response.code}: ${response.errorMessage}"
is HttpRequestResult.Error if response.code in (500..599) -> "Server's error ${response.code}: ${response.errorMessage}"
is HttpRequestResult.Error -> "Other error returned by server ${response.code}: ${response.errorMessage}"
is HttpRequestResult.Timeout -> "Connection Timeout"
is HttpRequestResult.ConnectionError -> "Connection error"
}
Այս հնարավորության որոշ հատկություններ՝
- Ճյուղի կոդը կատարվում է միայն այն դեպքում, երբ և հիմնական պայմանը, և guard պայմանը բավարարված են։
- Մեկ ճյուղը կարող է ունենալ մի քանի պայման։
- Կարելի է օգտագործել սովորական if/else արտահայտությունում հասանելի յուրաքանչյուր տրամաբանական օպերատոր (&&, ||, ! և in)։
- Guard պայմաններով ճյուղերը կարելի է համադրել սովորական ճյուղերի հետ։
Արդյո՞ք սա մեծ փոփոխություն է։ Իրականում ոչ, բայց այն Kotlin-ը մոտեցնում է այլ լեզուներում առկա pattern matching-ին։ Հիշեք, որ հնարավորությունը դեռ preview փուլում է և պետք է բացահայտորեն միացվի (տե՛ս նախապայմանների բաժինը)։
Բազմադոլար տողային ինտերպոլյացիա (preview հնարավորություն «multi-dollar-interpolation»)
Kotlin-ը հարմար է դարձնում ինտերպոլյացիայով բազմատող տողեր գրելը։ Սակայն խնդիր է առաջանում, երբ տողը պետք է պարունակի բառացի $ նշան, որը Kotlin-ը օգտագործում է ինտերպոլյացիայի համար։ Սրան հաճախ հանդիպում եք JSON Schema-ի դեպքում, որտեղ $ նախածանցը նշում է հատուկ նշանակություն ունեցող հիմնաբառերը։ Մինչ այժմ նման դեպքերը պահանջում էին ${‘$’} նման շրջանցում, որը կարող է վնասել կոդի ընթեռնելիությանը՝
val jsonSchema_beforeKotlin2_1_0 = """
{
"${'$'}id" : "https://example/schema/json"
"items" : {
"${'$'}ref" : "#/${'$'}defs/exampleReference",
},
"${'$'}defs" : {
"fileRef" : {
"exampleReference" : "string",
}
}
}
""".trimIndent()
Բարեբախտաբար, Kotlin 2.1.0-ը թույլ է տալիս որոշել, թե քանի դոլարի նշան է սկսում ինտերպոլյացիան։ Դուք այդ քանակությամբ դոլարի նշաններ եք դնում ձեր բազմատող տողի առջև։ Ճիշտ այդքան դոլարի նշաններից բաղկացած յուրաքանչյուր հաջորդականություն դառնում է ինտերպոլյացիայի նշան, իսկ ավելի կարճ հաջորդականությունները դիտարկվում են որպես բառացի նիշեր։ Այս մոտեցմամբ մեր JSON սխեման ունենում է այսպիսի տեսք՝
val jsonSchema_multiDollarStringInterpolation = $$"""
{
"$id" : "https://example/schema/json"
"items" : {
"$ref" : "#/$defs/exampleReference",
},
"$defs" : {
"fileRef" : {
"exampleReference" : "$$fileRefType",
}
}
}
""".trimIndent()
Այս դեպքում ինտերպոլյացիայի նախածանցը երկու դոլարի նշան է, ուստի հատուկ հանգույցների անունները, ինչպես $id-ն, արտածելու համար շրջանցումներ պետք չեն։ Ինտերպոլյացիան տեղի է ունենում միայն այնտեղ, որտեղ հայտնվում են երկու դոլարի նշան, ինչպես $fileRefType-ի դեպքում։ Հիշեք, որ հնարավորությունը դեռ preview փուլում է, և «multi-dollar-interpolation» հնարավորությունը պետք է միացված լինի։
Ոչ լոկալ break և continue (preview հնարավորություն «non-local-break-continue»)
Kotlin 2.1.0-ից առաջ ոչ լոկալ return հայտարարությունները թույլ էին տալիս լամբդայի ներսից դուրս գալ պարունակող ֆունկցիայից, այլ ոչ միայն լամբդայից։ Սա պարզեցնում է հոսքի կառավարումը, քանի որ լամբդայի կանչը կարող է անմիջապես դուրս բերել արտաքին ֆունկցիայից։ Սակայն դա պահանջում է, որ լամբդան փոխանցվի inline ֆունկցիային։ Տեսնենք սա գործնականում։
Ենթադրենք՝ ստեղծում ենք event handler, որը ստուգում է՝ արդյոք իրադարձությունը պետք է մշակվի, նախքան իրականում այն մշակելը։ Պարզության համար վերցնենք electronic commerce-ի պատվերների մշակումից մի քանի ծանոթ իրադարձություն և մեր կամայականորեն թույլատրած իրադարձությունների ցանկը՝
enum class EventType {
ORDER_CREATED,
ORDER_CANCELLED,
ORDER_COMPLETED,
ORDER_PAID,
ORDER_DELIVERED,
}
val allowedEvents = setOf(
EventType.ORDER_CREATED,
EventType.ORDER_CANCELLED,
EventType.ORDER_COMPLETED,
)
Իրադարձությունները վավերացնող և մշակող կոդի պարզեցված տարբերակը ոչ լոկալ return հայտարարությամբ կարող է ունենալ այսպիսի տեսք՝
fun handleEvents(events: Set<Event>) {
for (event in events) {
validateEvent(event) { invalidEvent ->
println("Invalid event $invalidEvent")
return
}
println("Event $event is valid")
// processing the event...
}
}
private inline fun validateEvent(event: Event, onValidationError: (Event) -> Unit) {
if (event.eventType !in allowedEvents) {
onValidationError(event)
}
}
Այստեղ handleEvents ֆունկցիան միայն ձևացնում է, թե մշակում է իրադարձությունները։ Կամայական վավերացման տրամաբանությունը գտնվում է validateEvent ֆունկցիայում, որն ընդունում է իրադարձություն և լամբդա (Event) -> Unit, որը կանչվում է, երբ իրադարձությունը թույլատրելի չէ։ Պարզության համար լամբդան պարզապես տպում է հաղորդագրություն և վերադառնում պարունակող ֆունկցիայից։
Այս իրականացումը հեռու է իդեալականից, քանի որ դադարեցնում է իրադարձությունների մշակումը առաջին իսկ անվավեր իրադարձությանը հանդիպելիս, ինչը ցանկալի վարքագիծը չէ։ Սակայն դրա միակ նպատակն է ցույց տալ, որ ոչ լոկալ return հայտարարությունը թույլ է տալիս լամբդայի ներսից դուրս գալ handleEvents ֆունկցիայից։ Հիշեք, որ դա հնարավոր էր արդեն Kotlin 2.1.0-ից առաջ։
Գնանք մեկ քայլ առաջ և փոխենք event handler-ի պահանջները այնպես, որ այն տպի ամփոփագիր բոլոր իրադարձությունների մշակումից հետո։ Այժմ չենք կարող պարզապես վերադառնալ handleEvents ֆունկցիայից։ Նախ պետք է դուրս գալ for ցիկլից և միայն հետո տպել ամփոփագիրը։ Break հայտարարությունը թույլ է տալիս դա անել։ Փոխարինենք return-ը break-ով՝
internal fun handleEvents(events: Set<Event>) {
for (event in events) {
validateEvent(event) { invalidEvent ->
println("Invalid event $invalidEvent")
break
}
println("Event $event is valid")
// processing the event...
}
println("Processing finished. Summary:...")
}
Այս կոդը 2.1.0-ից հին Kotlin-ով կոմպիլյացնելիս սխալ է առաջանում (թե կոնկրետ որը՝ կախված է Kotlin-ի տարբերակից)։ Սակայն Kotlin 2.1.0-ից սկսած՝ ոչ լոկալ break հայտարարությունները հասանելի են preview-ով և կարող են օգտագործվել հնարավորությունը միացնելուց հետո (տե՛ս Նախապայմանների բաժինը)։ Դրա շնորհիվ կոդը կոմպիլյացվում է և աշխատում է ըստ նախատեսվածի. for ցիկլը կանգ է առնում առաջին անվավեր իրադարձության մոտ, և ամփոփագիրը տպվում է։
Սուր աչքով ընթերցողները կնկատեն, որ թեև կոդն աշխատում է, կոմպիլյատորը զգուշացում է արձակում՝
Պատճառն այն է, որ break հայտարարությունն այստեղ երկիմաստ է, և կոմպիլյատորը չի կարող ասել՝ պետք է արդյոք ավարտի արտաքին for ցիկլը, թե որևէ ներքին ցիկլ, որը կարող է գոյություն ունենալ validateEvent ֆունկցիայի ներսում։ Քանի որ validateEvent-ը inline ֆունկցիա է, դրա կոդը կոմպիլյացիայի ժամանակ ուղղակիորեն տեղադրվում է կանչող ֆունկցիայի մեջ։ Այս երկիմաստությունը վերացնելու երկու եղանակ կա՝
- Ավելացնել label, որը հստակ է դարձնում, թե որ ցիկլը պետք է կանգնեցնել։
- Ավելացնել callsInPlace contract, որը կոմպիլյատորին ասում է, որ onValidationError-ը չի կանչվում validateEvent-ի ներքին ցիկլի ներսում։
Մենք կընտրենք առաջին տարբերակը և կավելացնենք label։ Այս կոդը կոմպիլյացվում է առանց զգուշացումների՝
internal fun handleEvents(events: Set<Event>) {
forEachEventLoop@ for (event in events) {
validateEvent(event) { invalidEvent ->
println("Invalid event $invalidEvent")
break@forEachEventLoop
}
println("Event $event is valid")
// processing the event...
}
println("Processing finished. Summary:...")
}
Այդուհանդերձ, տրամաբանությունը դեռ լրիվ ճիշտ չէ։ Մշակումը կանգ է առնում հենց առաջին անվավեր իրադարձության մոտ, մինչդեռ մենք ուզում ենք բաց թողնել անվավեր իրադարձությունները և շարունակել մնացածի մշակումը։ Դուք արդեն կարող եք կռահել, որ ոչ լոկալ continue հայտարարությունը մեզ տալիս է հենց դա՝
fun handleEvents(events: Set<Event>) {
forEachEventsLoop@ for (event in events) {
validateEvent(event) { invalidEvent ->
println("Invalid event $invalidEvent")
continue@forEachEventsLoop
}
println("Event $event is valid")
// processing the event...
}
println("Processing finished. Summary:...")
}
Այն շատ նման է ոչ լոկալ break-ին (և նույնպես պահանջում է preview ռեժիմ և label կամ contract)։ Տարբերությունն այն է, որ ցիկլն ավարտելու փոխարեն այն պարզապես անցնում է հաջորդ իտերացիային, երբ հանդիպում է անվավեր իրադարձություն։
Այս հնարավորությունը վերացնում է Kotlin-ի անհետևողականությունը. նախկինում ոչ լոկալ return հայտարարություններն արգելված չէին, բայց break-ն ու continue-ն արգելված էին։ Արդյունքում Kotlin-ի լամբդաները դառնում են էլ ավելի հզոր։ Հիշեք, որ ոչ լոկալ break-ն ու continue-ն դեռ preview փուլում են, թեև սպասվում է, որ կդառնան կայուն Kotlin-ի առաջիկա թողարկումներից մեկում (2.2.0)։
Ամփոփում
Kotlin 2.1-ը բերում է թարմ բարելավումների մի շարք, որոնք ձեր կոդը դարձնում են ավելի նիհար, ավելի ընթեռնելի և ավելի արտահայտիչ։ Թողարկումն ամրապնդում է Kotlin-ի դիրքը որպես ժամանակակից, մշակողի համար բարեկամական լեզու և ավելացնում է մի քանի կարևոր հնարավորություն՝
- Բարելավված when արտահայտությունը առաջարկում է ավելի լավ սպառիչության ստուգումներ sealed դասերի համար, այնպես որ պայմանական տրամաբանությունն այժմ կարելի է գրել ավելի հակիրճ՝ առանց ավելորդ else ճյուղերի։
- Guard պայմանները when արտահայտության մեջ թույլ են տալիս լրացուցիչ ֆիլտրումն ուղղակիորեն դնել
whenարտահայտությունների մեջ, ինչը կոդը դարձնում է ավելի հարթ և ավելի հեշտ կարդացվող։ - Բազմադոլար տողային ինտերպոլյացիան հեշտացնում է բազմատող տողերում բառացի դոլարի նշանների մշակումը, ինչը հատկապես օգտակար է JSON սխեմաների և այլ տվյալների ձևաչափերի համար, որոնք կախված են
$նշանից։ - Ոչ լոկալ break և continue վերացնում է Kotlin-ի մի անհետևողականություն և բարելավում է հոսքի կառավարումը լամբդաների և բարդ ցիկլերի ներսում։
Լեզվի այս հնարավորությունները ոչ միայն ձեր Kotlin կոդը դարձնում են ավելի հզոր, այլև հարթում են ճանապարհը առաջիկա թողարկումներում էլ ավելի առաջադեմ հնարավորությունների համար։ Հաճույքով բացահայտեք, թե ինչ է բերում Kotlin 2.1-ը, և ինքներդ համոզվեք, թե ինչպես կարող են այս բարելավումները փոխել ձեր մշակման ձևը։
Քանի որ այս հոդվածը կենտրոնանում է լեզվի հնարավորությունների վրա, այն չի նկարագրում վերջին թողարկման յուրաքանչյուր փոփոխություն։ Փոփոխությունների ամբողջական ցանկը տեսնելու համար խորհուրդ եմ տալիս կարդալ այս release note-ը։