Kotlin कोड रिव्यू: सीनियर डेवलपर्स को क्या परेशान करता है

सीनियर डेवलपर्स आपका Kotlin कोड कैसे देखते हैं: असली उदाहरणों के साथ समझें

आपने कोड लिखा, रिपॉजिटरी में push किया, और दिल धड़क रहा है कि कब approval मिले। लेकिन हरी टिक के बजाय, सीनियर डेवलपर के दस कमेंट आ जाते हैं। जाना-पहचाना लग रहा है? अगर आप Kotlin में लिखते हैं, तो आपने ज़रूर महसूस किया होगा जब आपका बेहतरीन कोड code review के बाद बेकार लगने लगता है।

इस लेख में हम देखेंगे कि Kotlin कोड रिव्यू में सीनियर डेवलपर्स की सबसे आम टिप्पणियाँ क्या होती हैं। हम आपको सिंटैक्स नहीं सिखाएँगे — हम दिखाएँगे कि ऐसा कोड कैसे लिखें जो पहली बार में ही पास हो जाए। चलिए शुरू करते हैं!

1. Null Safety: "एल्विस ऑपरेटर क्यों नहीं इस्तेमाल करते?"

Kotlin की सबसे बड़ी खासियत है null safety। लेकिन कई डेवलपर्स, खासकर Java से आए हुए, "पहले null चेक करो, फिर execute करो" वाला स्टाइल अपनाते हैं। सीनियर इसे तुरंत पकड़ लेते हैं।

बुरा उदाहरण (Java-स्टाइल)

fun getUserName(user: User?): String {\n    return if (user != null) {\n        user.name\n    } else {\n        "Unknown"\n    }\n}

अच्छा उदाहरण (Kotlin-स्टाइल)

fun getUserName(user: User?): String {\n    return user?.name ?: "Unknown"\n}

एल्विस ऑपरेटर (?:) और safe call (?.) का इस्तेमाल कोड को छोटा और पढ़ने में आसान बनाता है। सीनियर को यह पसंद आता है जब आप स्पष्टता खोए बिना लाइनें बचाते हैं। याद रखें: if (x != null) { ... } else { ... } — यह पुराना तरीका है।

2. Extension Functions: "तुम्हारी utility क्लास कहाँ है?"

जब आप StringUtils.capitalize(str) जैसी स्टैटिक utility क्लास देखते हैं, तो अनुभवी Kotlin डेवलपर भौंहें चढ़ा लेगा। Extension functions ही Kotlin को इतना खूबसूरत बनाते हैं।

बुरा उदाहरण

object StringUtils {\n    fun capitalize(text: String): String {\n        return text.replaceFirstChar { it.uppercase() }\n    }\n}\n\n// इस्तेमाल\nval result = StringUtils.capitalize("hello")

अच्छा उदाहरण

fun String.capitalizeFirst(): String {\n    return this.replaceFirstChar { it.uppercase() }\n}\n\n// इस्तेमाल\nval result = "hello".capitalizeFirst()

सीनियर कहेंगे: "एक कचरा ऑब्जेक्ट क्यों बना रहे हो? बस class को extend करो!" Extension functions का इस्तेमाल करें — इससे कोड पढ़ने में आसान होता है और यह Kotlin best practices का पालन करता है।

3. Sealed Classes बनाम Enum: "तुम्हारा enum पुराना हो गया"

Kotlin में enum अच्छे हैं, लेकिन sealed classes ज़्यादा लचीलापन देते हैं। खासकर जब एक ही hierarchy में अलग-अलग तरह के डेटा स्टोर करने हों।

बुरा उदाहरण (enum)

enum class Result {\n    SUCCESS,\n    ERROR,\n    LOADING\n}\n\nfun handleResult(result: Result) {\n    when (result) {\n        Result.SUCCESS -> // ...\n        Result.ERROR -> // ...\n        Result.LOADING -> // ...\n    }\n}

अच्छा उदाहरण (sealed class)

sealed class Result {\n    data class Success(val data: List<Item>) : Result()\n    data class Error(val message: String, val code: Int) : Result()\n    object Loading : Result()\n}\n\nfun handleResult(result: Result) {\n    when (result) {\n        is Result.Success -> println("Data: ${result.data}")\n        is Result.Error -> println("Error: ${result.message}")\n        Result.Loading -> println("Loading...")\n    }\n}

सीनियर डेवलपर्स सराहेंगे कि आप स्टेट्स दिखाने के लिए sealed classes का इस्तेमाल कर रहे हैं। यह सीनियर Kotlin डेवलपर्स की सबसे अच्छी सलाह में से एक है — टाइप hierarchies को स्पष्ट बनाएँ।

4. Scope Functions: "तुम let, apply और run भूल गए"

Scope functions (let, apply, run, with, also) — ये बहुत शक्तिशाली हैं