Սխալների մշակումը Kotlin-ում
Kotlin-ում սխալները մշակելու մեկ լավագույն ձև չկա. տեսեք, թե ինչ ենք առաջարկում մենք։
Ծրագրավորումն ունի երկու հաստատուն. սխալները անպայման կլինեն, և դրանք պետք է լավ մշակվեն։ Սխալները ծրագրային ինժեներիայի անբաժանելի մասն են՝ պայմանավորված անկանխատեսելի մուտքային տվյալներով, համակարգի սահմանափակումներով կամ պարզապես մարդկային սխալներով։ Սակայն այն, թե ինչպես ենք դրանց հետ գործ ունենում, ազդում է ոչ միայն մեր կոդի որակի և սպասարկելիության, այլև օգտատիրոջ փորձի ու համակարգի հուսալիության վրա։ Որպես ժամանակակից, արտահայտիչ լեզու՝ Kotlin-ը սխալները մշակելու մի քանի եղանակ է առաջարկում՝ դասական try-catch բլոկներից, մինչև ավելի առաջադեմ կառուցվածքներ, ինչպիսիք են Result-ը և sealed classes-ը, որոնք թույլ են տալիս կառուցել սխալների սեփական մոդելներ, և մինչև Either-ը՝ ֆունկցիոնալ պարադիգմից հայտնի կառուցվածք։ Այս գրառման մեջ մենք ավելի մանրամասն քննում ենք յուրաքանչյուր մեթոդը, դիտարկում դրա ուժեղ և թույլ կողմերը և փորձում ենք առաջարկել, թե որ տարբերակն է առավել հարմար տվյալ իրավիճակի համար։
Ում համար է այս գրառումը
Այն նախատեսված է հիմնականում նրանց համար, ովքեր արդեն կատարել են իրենց առաջին քայլերը Kotlin-ում և ցանկանում են սովորել սպասարկելի, ընդլայնելի կոդ գրելու լավ պրակտիկաներ՝ սխալների մշակման մասով։ Այդուհանդերձ, այստեղ նկարագրված մոտեցումները կարող են ոգեշնչել նաև այլ լեզուներով աշխատող մշակողներին՝ նմանատիպ ռազմավարություններ կիրառելու սեփական նախագծերում։
Ինչու է սխալների մշակումը կարևոր
ՏՏ ոլորտի մարդկանց մեծ մասը հավանաբար հանդիպել է Մերֆիի օրենքին, որը ասում է. «Եթե ինչ-որ բան կարող է սխալ գնալ, այն սխալ կգնա»։ Եվ կասկածում եմ, որ ՏՏ-ում գրեթե բոլորը կկանգնեն Մերֆիի կողքին։ Այս արտահայտությունը խորապես արձագանքում է ծրագրային ինժեներներին, ովքեր ապրում են աշխարհում, որտեղ հայտնվում են գրեթե անհնար եզրային դեպքեր, անխոցելի համակարգերը հակված են ձախողվել հենց այն պահին, երբ ամենաքիչն ենք սպասում, և մեր ինքնավստահությունը կտրուկ ընկնում է՝ երբեմն սնելով մեր impostor syndrome-ը։
Յուրաքանչյուր փորձառու մշակող գիտի, որ սխալները ոչ միայն հնարավոր են, այլև անխուսափելի։ Դրանք անտեսելու փոխարեն կարևոր է ընդունել դրանք և նախապես պատրաստվել։ Գուցե չկարողանանք կանխատեսել ամեն կոնկրետ ձախողում, բայց դիմակայունությունը հաշվի առնող համակարգեր նախագծելը օգնում է սահմանափակել անսպասելի խնդիրների ազդեցությունը։ Որքան էլ ակնհայտ հնչի, այս մտածելակերպը հիմնարար է սպասարկելի և ամուր ծրագրեր գրելու համար։
Բացառությունները Kotlin-ում. կարճ ներածություն
Java-ի համեմատ՝ Kotlin-ում բացառությունների մշակումն ավելի պարզ և ճկուն է։ Kotlin-ը, ի տարբերություն Java-ի, բոլոր բացառություններին վերաբերվում է որպես unchecked, ուստի դրանք պարտադիր չէ հայտարարել մեթոդների ստորագրություններում։ Սա կրճատում է boilerplate-ը և մեթոդների ստորագրությունները դարձնում ավելի կոկիկ, բայց նաև սխալների մշակման բեռը դնում է մշակողի վրա։ Դիտարկենք կոդի մի կարճ հատված, որը կարդում է կոնֆիգուրացիայի տվյալները տրված ճանապարհով ֆայլից.
fun readConfigFile(filePath: String): Map<String, String> =
FileReader(filePath).use { reader ->
reader.readLines()
.filter { it.contains("=") }
.associate {
val (key, value) = it.split("=", limit = 2)
key.trim() to value.trim()
}
}
Այս մեթոդից օգտվողը առաջին հայացքից չի կարող ասել, արդյոք իրականացումը անվտանգ կերպով մշակում է հնարավոր բացառությունները։ Իրոք, մեթոդի անունից, պահանջվող պարամետրերից և վերադարձվող տիպից բացի՝ ստորագրությունը շատ քիչ բան է հուշում։ Եթե ավելի ուշադիր նայեք readConfigFile մեթոդին, կնկատեք հնարավոր բացառություն, որը կարող է նետվել, բայց բացահայտորեն չի մշակվում։ Ավելի ճշգրիտ՝ FileReader դասի կոնստրուկտորը կարող է նետել FileNotFoundException. FileReader կոնստրուկտորի ստորագրությունը դա բացահայտորեն նշում է.
public FileReader(String fileName) throws FileNotFoundException
Java-ն ստիպում է կա՛մ բացահայտորեն բռնել բացառությունը, կա՛մ այն հայտարարել մեթոդի ստորագրության մեջ throws FileNotFoundException-ով, որպեսզի կանչողը իմանա, որ բացառությունը կարող է տեղի ունենալ։ Kotlin-ում, սակայն, այդպիսի բացառությունները պարտադիր չէ հայտարարել կամ բացահայտորեն բռնել, քանի որ բոլոր բացառությունները unchecked են։ Սա պարզեցնում է մեթոդի ստորագրությունը, բայց նաև նշանակում է, որ մեթոդի օգտագործողները պետք է ինքնուրույն հոգան հնարավոր բացառությունների մասին։ Զինված այս հիմնական գիտելիքով՝ դիտարկենք Kotlin-ում սխալները մշակելու կոնկրետ եղանակները։
Սխալների մշակման բազմաթիվ համտեսները Kotlin-ում
Try-Catch. ավանդական մոտեցումը
Սա Kotlin-ում սխալները մշակելու ամենահիմնարար եղանակն է. իհարկե ծանոթ Kotlin-ի ավագ եղբայր Java-ից, ինչպես նաև բազմաթիվ այլ ծրագրավորման լեզուներից։ Սա պարզ գործիք է, որը մշակողների մեծ մասն արդեն գիտի, և այն ծառայում է որպես պաշտպանության առաջին գիծ՝ սխալների հետ գործ ունենալիս։
Ինչպես է այն աշխատում։ Շարահյուսությունը շատ պարզ է. կա try դրույթ, որի մեջ մշակողը տեղադրում է կոդ, որը կարող է բացառություն նետել։ Երբ բացառություն է տեղի ունենում, կառավարման հոսքը անցնում է catch բլոկին, որտեղ բռնված բացառությունը սպասում է պատշաճ մշակման։ try-catch-ի ընտրովի վերջին մասը finally բլոկն է, որը կատարում է կոդը՝ անկախ այն բանից, թե բացառություն նետվել է, թե ոչ. այն սովորաբար օգտագործվում է ապահովելու համար, որ բոլոր ռեսուրսները պատշաճ կերպով մաքրվել են։ Նախորդ կոդի հատվածի հիման վրա try-catch-ի օգտագործումը կունենար այսպիսի տեսք.
try {
val config = readConfigFile(configFilePath)
logger.info("Configuration loaded successfully: $config")
} catch (e: FileNotFoundException) {
// Specific handling of file not found error
logger.error("Configuration file not found at path: $configFilePath", e)
} catch (e: Exception) {
// General handling of other unexpected errors
logger.error("An unexpected error occurred while reading the configuration file", e)
}
Բացառությունների մշակման այս եղանակը պարզ է և հեշտ հասկանալի՝ նույնիսկ Kotlin-ի սկսնակների կամ Java-ից եկողների համար։ Սա սխալների կառավարման համար խելամիտ մեկնակետ է, քանի որ թույլ է տալիս ճշգրիտ կերպով մշակել կոնկրետ բացառություններ (օր.՝ FileNotFoundException), ինչպես նաև բացառությունների հիերարխիայի ավելի ընդհանուրները՝ միաժամանակ ապահովելով պահուստային տարբերակ անսպասելի խնդիրների համար։ Սակայն այն ունի իր սահմանափակումները։ readConfigFile-ը բացահայտորեն չի հայտարարում, թե որ բացառությունները կարող է նետել, ուստի կանչողին անհրաժեշտ է անուղղակի գիտելիք դրա վարքի մասին։ Դատելով մեթոդի ստորագրությունից՝ կարող եք մտածել, որ այն միշտ վերադարձնում է Map<String, String>։ Իրականում դա երաշխավորված չէ. կատարման ընթացքում կարող են բացառություններ նետվել՝ խախտելով հոսքը և կոդը դարձնելով ավելի քիչ կանխատեսելի։ try-catch-ը ինտուիտիվ է և շատ պարզ դեպքերի համար բավարար, բայց այն չի տալիս սխալների բացահայտ հետևում։ Մշակողները ստիպված են ապավինել անուղղակի գիտելիքին կամ արտաքին փաստաթղթերին, որպեսզի իմանան, թե որ բացառությունները կարող են նետվել, ինչը ավելի բարդ սցենարներում կարող է հանգեցնել սխալների բաց թողնման կամ չմշակված մնալու։ Կոդն ավելի կանխատեսելի դարձնելու և այս խնդիրները լուծելու համար Kotlin-ն առաջարկում է Result դասը՝ հաջողությունն ու ձախողումը բացահայտորեն մշակելու ժամանակակից և սեղմ եղանակ։ Տեսնենք, թե ինչպես է այս մոտեցումը պարզեցնում սխալների մշակումը։
Result. բացառությունների հետ գործ ունենալու ավելի լավ ձև
try-catch-ը սխալները կառավարելու ավանդական, ծանոթ եղանակն է, բայց Kotlin-ը առաջարկում է Result դասը որպես ավելի ժամանակակից և իդիոմատիկ այլընտրանք։ Result-ի միջոցով մշակողները կարող են հաջողությունն ու ձախողումը արտահայտել որպես արժեքներ, ինչը սխալների մշակումը դարձնում է բացահայտ և շատ իրավիճակներում նվազեցնում է բացառությունների կարիքը։ Result-ը թույլ է տալիս մոդելավորել գործողություններ, որոնք կարող են ձախողվել՝ տալով սխալները մշակելու ավելի մաքուր, ավելի ֆունկցիոնալ եղանակ։ Ձախողումը բացառություններով տարածելու փոխարեն՝ մեթոդը կարող է վերադարձնել Result, որը բացահայտորեն ասում է՝ գործողությունը հաջողվել է, թե ոչ։
Ինչպես է այն աշխատում։ Result դասը պարզեցնում է սխալների մշակումը՝ փաթաթելով գործողության արդյունքը այնպես, որ հաջողությունն ու ձախողումը բացահայտորեն տարբերվեն։ Սխալները բացառություններով ազդարարելու փոխարեն՝ Result-ը թույլ է տալիս գործողության արդյունքը ներկայացնել որպես երկու բանից մեկը.
- Success. գործողությունը հաջողությամբ ավարտվել է և տալիս է սպասվող արդյունքը։
- Failure. գործողությունը ձախողվել է, և բացառությունը փաթաթված է Result օբյեկտի մեջ։
Ավելի լավ հասկանալու համար վերաշարադրենք readConfigFile ֆունկցիան այնպես, որ այն օգտագործի Result դասը.
fun readConfigFile(filePath: String): Result<Map<String, String>> =
runCatching {
FileReader(filePath).use { reader ->
reader.readLines()
.filter { it.contains("=") }
.associate {
val (key, value) = it.split("=", limit = 2)
key.trim() to value.trim()
}
}
}
Ինչպես տեսնում եք, մեթոդի ստորագրությունից և readConfigFile-ի ներսում runCatching ֆունկցիայի օգտագործումից բացի՝ քիչ բան է փոխվել։ runCatching-ը ընդունում է կոդի բլոկ, որը կարող է բացառություններ նետել։ Այն բռնում է բլոկի կատարման ժամանակ նետված ցանկացած բացառություն և վերադարձնում է այն որպես Result օբյեկտ։ Երբ գործողությունը հաջողվում է, runCatching-ը վերադարձնում է Result օբյեկտ, որը պարունակում է ստացված Map<String, String>-ը։ Երբ այն ձախողվում է (օր.՝ ֆայլը գոյություն չունի), վերադարձնում է Result օբյեկտ, որը փաթաթում է բացառությունը։ Դրա շնորհիվ readConfigFile-ի ստորագրությունը բացահայտորեն նշում է, որ այն վերադարձնում է Result<Map<String, String>>, ուստի կանչողը պետք է բացահայտորեն մշակի հաջողությունն ու ձախողումը։ Նայենք դրան կանչողի կողմից.
readConfigFile(configFilePath).fold(
onSuccess = { config ->
logger.info("Configuration loaded successfully: $config")
},
onFailure = { exception ->
// Handle errors based on the type of exception
when (exception) {
is FileNotFoundException ->
// Specific handling for file not found errors
logger.error("Configuration file not found at path: $configFilePath", exception)
else ->
// General handling for all other unexpected exceptions
logger.error("An unexpected error occurred while reading the configuration file", exception)
}
}
)
Ամենակարևոր փոփոխությունը գալիս է readConfigFile-ի նոր ստորագրությունից, որը ստիպում է մշակել վերադարձված Result-ը։ fold մեթոդը պահանջում է մշակել երկու վիճակները, ուստի ծրագրավորողը չի կարող անտեսել ո՛չ Success-ը, ո՛չ Failure-ը։ Սա ոչ միայն հաջողության և ձախողման մշակումը դարձնում է բացահայտ, այլև API-ն դարձնում է ավելի հստակ։ Քանի որ կանչողը պետք է մշակի և՛ հաջողության, և՛ ձախողման ճանապարհը, fold-ը նվազեցնում է եզրային դեպքերի բաց թողնման կամ բացառությունների լուռ կուլ տալու հավանականությունը։ Դրանից բացի, այն համընկնում է Kotlin-ի իդիոմատիկ ֆունկցիոնալ ծրագրավորման ոճին, ուստի կոդն ավելի կանխատեսելի է դառնում և ավելի հեշտ սպասարկվում։ Ավելին, Result-ը կարող է կրճատել կոդային բազայով մեկ ցրված ավանդական try-catch բլոկները, ինչի արդյունքում սխալների մշակումը դառնում է ավելի սեղմ և դեկլարատիվ։ Սա հատկապես արժեքավոր է բարդ համակարգերում, որտեղ սխալները պետք է հետևողականորեն տարածվեն։
Վերջապես, հաջողության և ձախողման վիճակների հստակ բաժանումը հեշտացնում է թեստավորումն ու վրիպազերծումը, քանի որ մշակողները կարող են առանձին կենտրոնանալ յուրաքանչյուր սցենարի վրա, ինչն արդյունքում տալիս է ավելի ամուր և հուսալի ծրագրեր։ Հարկ է նշել, որ Result դասը առաջարկում է Result օբյեկտների հետ աշխատելու շատ այլ հարմար մեթոդներ, օրինակ.
- getOrNull. վերադարձնում է արժեքը, եթե գործողությունը հաջողվել է, կամ null՝ եթե ձախողվել է։
- getOrElse. վերադարձնում է արժեքը հաջողության դեպքում, կամ տրամադրված լռելյայն արժեքը՝ ձախողման դեպքում։
- exceptionOrNull. վերադարձնում է բացառությունը, եթե գործողությունը ձախողվել է, կամ null՝ եթե հաջողվել է։
- onSuccess / onFailure. թույլ է տալիս կատարել կողմնակի էֆեկտներ՝ կախված հաջողությունից կամ ձախողումից։
- map / mapCatching. փոխակերպում է արդյունքի արժեքը՝ պահպանելով հաջողության կամ ձախողման վիճակը։
- recover / recoverCatching. տրամադրում է պահուստային արժեք կամ ձախողումը վերածում է հաջողության։
Սրանք Result դասի առաջարկած հարմար մեթոդներից միայն մի քանիսն են։ Ամբողջական պատկերի համար տե՛ս պաշտոնական Kotlin Result API փաստաթղթերը։ Result-ը թեթև է և իդեալական պարզ գործողությունների համար, բայց ունի սահմանափակումներ ավելի բարդ սցենարներում։ Մասնավորապես, Result-ը բավարար չէ, երբ անհրաժեշտ է մոդելավորել տիրույթին հատուկ սխալներ՝ հարուստ տվյալներով, կամ երբ հավելվածը պետք է գործ ունենա բազմաթիվ նուրբ սխալների դեպքերի հետ։ Այդ իրավիճակներում մեզ պետք է ավելի կառուցվածքային և սպառիչ մոտեցում՝ տիպերի անվտանգությունն ու սպասարկելիությունը պահպանելու համար, երբ հավելվածն աճում է։ Այս կարիքների համար Kotlin-ի sealed classes-ը կամ sealed interfaces-ը տալիս են հուսալի շրջանակ բարդ, տիրույթին հատուկ սցենարները մոդելավորելու համար։
Sealed Classes. կառուցվածքային մոտեցում
Sealed classes-ը առաջարկում են տիրույթին հատուկ սցենարները մոդելավորելու հուսալի եղանակ, որտեղ յուրաքանչյուր դեպք մշակվում է սպառիչ կերպով։ Kotlin-ում sealed class-ը դասի հատուկ տեսակ է, որը սահմանափակում է, թե որ ենթադասերը կարող են ժառանգել իրենից։ Արդյունքում բոլոր հնարավոր դեպքերը հայտնի են կոմպիլյացիայի ժամանակ, ինչը կոդը դարձնում է ավելի կանխատեսելի և տիպով անվտանգ։ Ի տարբերություն ընդհանուր մոտեցումների, ինչպիսին Result-ն է, sealed classes-ը թույլ են տալիս տիրույթին հատուկ սցենարները մոդելավորել այնպես, որ Kotlin կոմպիլյատորը կարող է պարտադրել՝ երաշխավորելով, որ յուրաքանչյուր հնարավոր դեպք մշակված է։ Ինչպես միշտ, պարզ օրինակը հեշտացնում է հասկացությունը։ Պատկերացրեք էլեկտրոնային առևտրի պատվերների մշակման պարզեցված տիրույթ։ Ենթադրենք՝ մեզ պետք է պատվերը մշակող մեթոդ։ Տիրույթի փորձագետը մեզ տվել է հստակեցում, ըստ որի՝ պատվերը հաստատելուց առաջ մշակումը պետք է ներառի այս ստուգումները.
- Տարիքից ելնելով՝ օգտատերը կարող է պատվիրել ընտրված ապրանքը։
- Ապրանքը պետք է առկա լինի պահեստում։
- Վճարման գործընթացը հաջողությամբ ավարտվել է։
Երբ այս բոլոր ստուգումները անցնում են, մեթոդը կարող է վերադարձնել հաջողության արդյունք։ Սա նկատի ունենալով՝ կարող ենք սկսել մոդելավորել մեր processOrder մեթոդը։
Պատվերի մշակման մոդելավորումը Sealed Classes-ով Սկզբում սահմանում ենք sealed class, որը ներկայացնում է պատվերի մշակման արդյունքը։ Այն կընդգրկի բոլոր հնարավոր արդյունքները՝ ինչպիսիք են հաջողությունը և սխալների տարբեր տեսակները.
sealed class OrderProcessingResult {
data object Success : OrderProcessingResult()
sealed class Error : OrderProcessingResult() {
data object AgeRestriction : Error()
data object PaymentFailed : Error()
data object OutOfStock : Error()
data class SystemError(val reason: String) : Error()
}
}
Այնուհետև գրում ենք մեթոդ, որը մշակում է պատվերը և վերադարձնում OrderProcessingResult։ Այն կատարում է բոլոր պահանջվող ստուգումները, և արդյունքը մեզ ասում է, թե ինչպես է ավարտվել գործողությունը։ Այդպիսի մեթոդը կարող է այսպիսի տեսք ունենալ.
class OrderProcessor(
private val agePolicy: AgePolicy,
private val stockService: StockService,
private val paymentService: PaymentService
) {
fun processOrder(order: Order): OrderProcessingResult {
return Result.runCatching {
when {
!agePolicy.isUserAllowedToOrder(order.productId, order.orderingUser) ->
OrderProcessingResult.Error.AgeRestriction
stockService.isNotAvailableInStock(order.productId) ->
OrderProcessingResult.Error.OutOfStock
paymentService.processPayment(order.orderingUser) is PaymentResult.Failure ->
OrderProcessingResult.Error.PaymentFailed
// potentially more logic
else -> OrderProcessingResult.Success
}
}.getOrElse { exception ->
OrderProcessingResult.Error.SystemError("Unexpected error: ${exception.message}")
}
}
}
Այս իրականացմամբ մեթոդը կանչողը պետք է մշակի արդյունքը։ Գործնականում Kotlin-ի when կառուցվածքը լավագույն ընտրությունն է, քանի որ այն օգտվում է կոմպիլյատորի սպառիչության ստուգումներից։ Խորանանք և տեսնենք, թե ինչ տեսք ունի այն.
when (val processingOrderResult = orderProcessor.processOrder(order)) {
is OrderProcessingResult.Error.AgeRestriction -> {
logger.error("Order failed: User is not allowed to order the product due to age restrictions.")
// Additional logic for handling age restriction cases can be implemented here
}
is OrderProcessingResult.Error.OutOfStock -> {
logger.error("Order failed: The product is out of stock. Product ID: ${order.productId}.")
// Additional logic for handling out-of-stock cases can be implemented here
}
is OrderProcessingResult.Error.PaymentFailed -> {
logger.error("Order failed: Payment processing failed for User: ${order.orderingUser}.")
// Additional logic for handling payment failure cases can be implemented here
}
is OrderProcessingResult.Error.SystemError -> {
logger.error("Order failed: System error occurred - ${processingOrderResult.reason}")
// Additional logic for system error handling can be implemented here
}
is OrderProcessingResult.Success -> {
logger.info("Order processed successfully! Order ID: ${order.orderId}.")
// Additional logic for successful order processing can be implemented here
}
}
}
Ամփոփելով՝ processOrder-ի արդյունքների մշակումը sealed class-ով տալիս է տիպով անվտանգ, ամբողջական մեխանիզմ, որն երաշխավորում է, որ յուրաքանչյուր հնարավոր դեպք մշակվում է բացահայտորեն։ when հրահանգի հետ միասին սա սխալների մշակումը դարձնում է պարզ և սպասարկելի։ else ճյուղը բաց թողնելով՝ դուք թույլ եք տալիս կոմպիլյատորին պարտադրել յուրաքանչյուր հնարավոր արդյունքի մշակումը, ուստի կոդը մնում է անվտանգ նոր դեպքեր ավելացնելիս։
Այս մոտեցումն ընդգծում է.
- Ընթեռնելիություն և հստակություն. when հրահանգի յուրաքանչյուր ճյուղ համապատասխանում է մեկ կոնկրետ արդյունքի, ուստի տրամաբանությունը ինքն իրեն բացատրում է և հեշտ է հետևել։
- Մասշտաբավորելիություն. նոր արդյունքի տիպերը հեշտ է ավելացնել, քանի որ Kotlin կոմպիլյատորը պահանջում է մշակել յուրաքանչյուր սահմանված դեպք։ Սա նվազեցնում է աչքից վրիպած սցենարների հավանականությունը և խրախուսում է ավելի անվտանգ կոդ։
- Սպասարկելիություն. սխալների մշակման տրամաբանությունը գտնվում է մեկ փակ հիերարխիայում, ուստի կոնկրետ դեպքերը ավելի հեշտ է փոխել, թեստավորել կամ ընդլայնել՝ առանց կոդի մնացած մասին դիպչելու։
Kotlin-ի կոմպիլյատորի ստուգումները երաշխավորում են, որ յուրաքանչյուր դեպք մշակված է, ինչը նվազեցնում է աշխատանքային ժամանակի սխալների ռիսկը և համապատասխանում է Kotlin-ի նախագծման փիլիսոփայությանը։ Արդյունքում ձեր կոդը հստակ է, հուսալի և պատրաստ ապագա պահանջներին՝ միաժամանակ պահպանելով սխալների մշակման ամուր ռազմավարություններ։
Պատվերի մշակման մոդելավորումը Either-ով
Sealed classes-ը առաջարկում են բազմաթիվ արդյունքների հետ գործ ունենալու հուսալի, ինտուիտիվ եղանակ, բայց Kotlin մշակողները հաճախ դիմում են ֆունկցիոնալ ծրագրավորման կառուցվածքների, ինչպիսին Either-ն է, որը տրամադրվում է արտաքին գրադարաններից, օրինակ՝ arrow-kt։ Այն նախատեսված է այն իրավիճակների համար, երբ արդյունքը բնականորեն բաժանվում է երկու առանձին տիպի՝ հաջողության և ձախողման։ Either-ը գալիս է ֆունկցիոնալ ծրագրավորման պարադիգմներից և թույլ է տալիս այս երկու վիճակները արտահայտել սեղմ, տիպով անվտանգ եղանակով։ Դա այն դարձնում է Kotlin-ում սխալների մշակման և ֆունկցիոնալ կոմպոզիցիայի տարածված ընտրություն։
Վերադառնանք processOrder օրինակին։ Այս անգամ պատվերի մշակման արդյունքը կմոդելավորի Either-ը։ Սեփական sealed class հիերարխիան Either-ով փոխարինելը թույլ է տալիս պարզեցնել հաջողության և ձախողման ներկայացումը՝ միաժամանակ օգտագործելով ֆունկցիոնալ ոճի գործողություններ, ինչպիսիք են map, flatMap և fold։ Վերանայված կոդը կարող է այսպիսի տեսք ունենալ.
sealed class OrderProcessingError {
data object AgeRestriction : OrderProcessingError()
data object PaymentFailed : OrderProcessingError()
data object OutOfStock : OrderProcessingError()
data class SystemError(val reason: String) : OrderProcessingError()
}
class OrderProcessor(
private val agePolicy: AgePolicy,
private val stockService: StockService,
private val paymentService: PaymentService
) {
fun processOrder(order: Order): Either<OrderProcessingError, Unit> =
Result.runCatching {
when {
!agePolicy.isUserAllowedToOrder(order.productId, order.orderingUser) ->
Either.Left(OrderProcessingError.AgeRestriction)
stockService.isNotAvailableInStock(order.productId) ->
Either.Left(OrderProcessingError.OutOfStock)
paymentService.processPayment(order.orderingUser) is PaymentResult.Failure ->
Either.Left(OrderProcessingError.PaymentFailed)
// potentially more logic
else -> Either.Right(Unit)
}
}.getOrElse { exception ->
Either.Left(OrderProcessingError.SystemError("Unexpected error: ${exception.message}"))
}
}
Sealed classes-ից Either-ին անցումը փոխել է հաջողության և ձախողման ներկայացումը processOrder մեթոդում։ Ամենանկատելի տարբերությունը մեթոդի վերադարձվող տիպն է, որն այժմ բացահայտորեն վերադարձնում է Either։ Սա տալիս է և՛ հաջողության, և՛ ձախողման վիճակի հետ գործ ունենալու կառուցվածքային, տիպով անվտանգ եղանակ։
Ըստ պայմանավորվածության՝ Left-ը ներկայացնում է ձախողման վիճակը, իսկ Right-ը՝ հաջողության վիճակը։ Այստեղ processOrder-ը վերադարձնում է Either, որի Left տիպը OrderProcessingError է։ Այս sealed class-ը պարունակում է նախորդ OrderProcessingResult.Error հիերարխիայի բոլոր սխալների դեպքերը, ուստի յուրաքանչյուր հնարավոր սխալ մշակվում է բացահայտորեն։ Right տիպը Unit է, ինչը նշանակում է, որ հաջող գործողությունը ներկայացնող կոնկրետ արդյունք չկա։ Նախկինում հաջողությունն արտահայտվում էր որպես OrderProcessingResult.Success, մինչդեռ այստեղ Unit-ը պարզեցնում է հաջողության մշակումը՝ պահպանելով նախագծի իմաստալիցությունն ու հստակությունը։
Այս նախագծային որոշումը, սակայն, բացահայտում է փոխզիջում պարզության և արտահայտչականության միջև։ Հաջողության համար Unit օգտագործելը խուսափում է ավելորդ բարդությունից, բայց սահմանափակում է, թե որքան իմաստալից տիրույթին հատուկ տեղեկություն կարող է կրել հաջող արդյունքը։ Օրինակ, եթե processOrder մեթոդը պետք է վերադարձներ պատվերի հետևման ID կամ հաջողության մանրամասն կարգավիճակ, ապա Right կողմում նվիրված տիպը ավելի հարմար կլիներ։
Այս փոխզիջումը ցույց է տալիս, որ նման ընտրությունները կախված են տիրույթի կոնկրետ պահանջներից։ Որտեղ հաջողությունն ուղեկցվում է լրացուցիչ համատեքստով կամ տվյալներով, նկարագրական տիպը բարելավում է հստակությունը և հեշտացնում է ապագա ընդլայնումը։ Իսկ որտեղ հաջողությունը իմաստալից տեղեկություն չի կրում, Unit-ը սեղմ և գործնական տարբերակ է։
Այժմ, երբ կոդն օգտագործում է Either, տեսնենք, թե ինչպես կարելի է այն օգտագործել օգտատիրոջ կողմից.
orderProcessor.processOrder(order).fold(
ifLeft = { orderProcessingError ->
when (orderProcessingError) {
OrderProcessingError.AgeRestriction -> {
logger.error("Order failed: User is not allowed to order the product due to age restrictions.")
// Additional logic for handling age restriction cases can be implemented here
}
OrderProcessingError.OutOfStock -> {
logger.error("Order failed: The product is out of stock. Product ID: ${order.productId}.")
// Additional logic for handling out-of-stock cases can be implemented here
}
OrderProcessingError.PaymentFailed -> {
logger.error("Order failed: Payment processing failed for User: ${order.orderingUser}.")
// Additional logic for handling payment failure cases can be implemented here
}
is OrderProcessingError.SystemError -> {
logger.error("Order failed: System error occurred - ${orderProcessingError.reason}")
// Additional logic for system error handling can be implemented here
}
}
},
ifRight = { logger.info("Order processed successfully! Order ID: ${order.orderId}.") }
)
Either-ի վրա հիմնված վերանայված իրականացման մեջ processOrder-ի արդյունքը մշակվում է ֆունկցիոնալ կերպով։ Նախկինում, sealed classes-ի դեպքում, հաճախորդը մշակում էր արդյունքները Kotlin-ի when հրահանգով՝ բացահայտորեն ընդգրկելով յուրաքանչյուր հնարավոր դեպք։ Either-ի դեպքում fold մեթոդը առաջարկում է այլ մոտեցում՝ ֆունկցիոնալ ծրագրավորման պարադիգմներին համապատասխան, թույլ տալով հաջողությունն ու ձախողումը սեղմ մշակել երկու ճյուղով։ Սակայն հարկ է նշել, որ թեև Either-ը կոդին ֆունկցիոնալ երանգ է հաղորդում, սխալները դեռ ներկայացված են sealed class հիերարխիայով, ուստի սխալների վիճակները մնում են բացահայտորեն մոդելավորված։ fold-ից բացի՝ Either-ն առաջարկում է մի շարք առանցքային մեթոդներ, որոնք հեշտացնում են գործողությունների մշակումն ու կոմպոզիցիան.
- map. փոխակերպում է Right արժեքը և Left-ը թողնում է անփոփոխ։
- flatMap. շղթայում է գործողություններ, որոնք վերադարձնում են մեկ այլ Either, ինչը հնարավորություն է տալիս կոմպոզիցիոն աշխատանքային հոսքերի։
- mapLeft. փոխակերպում է Left արժեքը և Right-ը թողնում է անփոփոխ։
- getOrElse. վերադարձնում է Right արժեքը կամ լռելյայն արժեք՝ Left-ի դեպքում։
- swap. փոխանակում է Left և Right արժեքները։
- catch. բռնում է բացառությունները և դրանք վերածում Either-ի։
Սրանք մի քանի առանցքային մեթոդներ են, որոնք ցույց են տալիս, թե ինչ կարող է անել Either դասը։ Դրա ամբողջական API-ի համար տե՛ս պաշտոնական Arrow Either API փաստաթղթերը։
Ինչպես տեսնում եք, Either դասն ունի հարուստ API, որն աջակցում է ֆունկցիոնալ ծրագրավորմանը, ինչը այն դարձնում է հիանալի ընտրություն գործողություններ շղթայելու, արդյունքները փոխակերպելու և հաջողության ու ձախողման հետ դեկլարատիվ աշխատելու համար։ Այն հատկապես հարմար է այն նախագծերի համար, որոնք ողջ կոդային բազայում հետևում են ֆունկցիոնալ մոտեցմանը, քանի որ Either-ը միայն այստեղ-այնտեղ օգտագործելը այլապես իմպերատիվ կոդում կարող է հանգեցնել անհետևողականության։ Եթե ցանկանում եք բացահայտել այն ամենը, ինչ այն կարող է անել, arrow-kt գրադարանի և ֆունկցիոնալ ծրագրավորման մեջ խորանալը կարող է բացել մաքուր, արտահայտիչ Kotlin կոդ գրելու էլ ավելի շատ եղանակներ։
Ամփոփում. սխալների մշակման ճիշտ մոտեցման ընտրությունը
Երբ ընտրում եք, թե ինչպես մշակել սխալները Kotlin-ում, կարևոր է ընտրել մոտեցում, որը համապատասխանում է ձեր տիրույթի բարդությանը, ձեր թիմի նախասիրություններին և նախագծի ոճին։ Ստորև կարճ համեմատություն է՝ որոշելու համար.
| Մոտեցում | Կիրառության դեպք | Առավելություններ | Թերություններ |
| try-catch | Սխալների հիմնական մշակում | Հեշտ է հասկանալ, բնիկ է Kotlin-ի համար | Սխալների բացահայտ հետևում չկա, տիպով անվտանգ չէ |
| Result | Հաջողության/ձախողման պարզ մշակում | Ներկառուցված է, թեթև | Այնքան էլ ճկուն չէ |
| sealed class / interface | Բարդ, տիրույթին հատուկ սխալների մոդելավորում | Տիպով անվտանգ, սպառիչ | Պահանջում է ավելի շատ կարգավորում |
| Either | Կոմպոզիցիա ֆունկցիոնալ ոճով | Հզոր, ճկուն, կոմպոզիցիոն | Պահանջում է ֆունկցիոնալ պարադիգմի հետևողական կիրառում, ավելի զառիթափ ուսուցման կորագիծ |
Երբ ընտրել յուրաքանչյուր մոտեցումը
- Օգտագործեք try-catch. արագ, պարզ սխալների մշակման համար, որը պահանջում է հնարավորինս քիչ կոդ։ Լավագույնս աշխատում է սկրիպտների կամ փոքր խնդիրների համար։
- Օգտագործեք Result. հաջողության/ձախողման պարզ գործողությունների համար, որոնք չեն պահանջում սխալների բարդ մոդելավորում։ Հիանալի ընտրություն է բնիկ Kotlin նախագծերի համար։
- Օգտագործեք sealed classes. հարուստ տիրույթի մոդելներ ունեցող հավելվածների համար, որտեղ սխալների տարբեր վիճակներ կրում են իմաստալից տվյալներ, և սպառիչ մշակումը կարևոր է։
- Օգտագործեք Either. երբ հետևում եք ֆունկցիոնալ ծրագրավորման պարադիգմին կամ աշխատում եք աշխատանքային հոսքերի հետ, որոնք ներառում են բարդ փոխակերպումներ կամ շղթայված գործողություններ։
Եզրափակիչ մտքեր
Սխալների մշակումը վճռորոշ է ամուր հավելվածներ կառուցելու համար, և Kotlin-ում համընդհանուր լուծում չկա։ Թե որ մոտեցումն է լավագույնը, կախված է նրանից, թե որքան բարդ է ձեր տիրույթը, ինչ է նախընտրում ձեր թիմը և ինչ է պետք ձեր նախագծին։ Ավելի պարզ սցենարներում սկսեք try-catch-ից կամ Result-ից։ Sealed classes-ը հստակություն և տիպային անվտանգություն են բերում ավելի բարդ տիրույթներին, մինչդեռ Either-ը և այլ ֆունկցիոնալ կառուցվածքները հարմար են այն թիմերի համար, որոնք ընդունում են ֆունկցիոնալ ծրագրավորման պարադիգմը։ Որպես առաջին քայլ՝ վերլուծեք ձեր տիրույթը, թիմի հետ պայմանավորվեք մեկ հետևողական մոտեցման շուրջ և առաջնահերթություն տվեք ընթեռնելիությանը։ Սկսեք ավելի պարզ գործիքներից և անցեք առաջադեմ գրադարանների, ինչպիսին arrow-kt-ն է, երբ ձեր կարիքներն աճեն։ Պարզության, արտահայտչականության և սպասարկելիության միջև հավասարակշռություն գտնելը ձեր նախագիծը պահում է հստակ ու ամուր։