कोटलिन में कार्यों के बीच डिफ़ॉल्ट तर्कों का प्रचार कैसे करें?

Question

कोटलिन में default arguments for function and constructor parameters है। अब, मैं एक समारोह

fun foo(bar: String = "ABC", baz: Int = 42) {} 

है और मैं यह विभिन्न स्थानों से कॉल करने के लिए, लेकिन यह भी संभावना है कि तर्कों की पर पारित नहीं करने के लिए और इसके बजाय डिफ़ॉल्ट मान का उपयोग बनाए रखने चाहते हैं।

मुझे पता है, मैं बुला कार्यों

fun foo2(bar: String = "ABC", baz: Int = 42) { 
    // do stuff 
    foo(bar, baz) 
} 

fun foo3(bar: String = "ABC", baz: Int = 42) { 
    // do other stuff 
    foo(bar, baz) 
} 

लेकिन अब foo में मेरे डिफ़ॉल्ट पैरामीटर व्यर्थ है के रूप में यह हमेशा overwriten है और मैं सभी बुला कार्यों में डिफ़ॉल्ट तर्क दोहराया गया है में डिफ़ॉल्ट तर्क घोषणा कर सकते हैं। वह बहुत शुष्क नहीं है।

क्या डिफ़ॉल्ट तर्कों का प्रचार करने का कोई बेहतर तरीका है?

Answer 1

_{the guidelines द्वारा प्रोत्साहित किए गए अपने स्वयं के प्रश्न का उत्तर दें। , तब}

fun foo2(bar: String? = null: Int? = null) { 
    // do stuff 
    foo(bar, baz) 
} 

fun foo3(bar: String? = null, baz: Int? = null) { 
    // do other stuff 
    foo(bar, baz) 
} 

, elvis operator से एक का उपयोग डिफ़ॉल्ट मान का उपयोग करें:

---

आप क्या कर सकते हैं, नल के रूप में बुला कार्यों में मानकों की घोषणा और डिफ़ॉल्ट तर्क के रूप में null का उपयोग करें जब null प्रदान किया जाता है।

fun foo(bar: String? = null, baz: Int? = null) { 
    val realBar = bar ?: "ABC" 
    val realBaz = baz ?: 42 
} 

आप एक समारोह के बजाय एक वर्ग के साथ काम कर रहे हैं, तो आप निर्माता की संपत्ति बाहर निकालते हैं और वहाँ डिफ़ॉल्ट मान असाइन कर सकते हैं:

class Foo(bar: String? = null, baz: Int? = null) { 
    val bar = bar ?: "ABC" 
    val baz = baz ?: 42 
} 

वैकल्पिक रूप से, का कहना है कि अपने वर्ग है अगर इसके बजाय तीन मज़ा आ रहा है की

class Foo(val bar: String, baz: Int) { 
    companion object { 
     fun create(bar: String? = null, baz: Int? = null) = Foo(bar ?: "ABC", baz ?: 42) 
    } 
} 

Answer 2

: एक data class और आप प्राथमिक निर्माता में गुण होते हैं करना चाहते हैं, तो आप मूलभूत मूल्यों को संभालने के लिए एक कारखाने प्रणाली की घोषणा कर सकते हैं एक ही डिफ़ॉल्ट तर्क के साथ ctions:

fun foo(bar: String = "ABC", baz: Int = 42) 
fun foo2(bar: String = "ABC", baz: Int = 42) 
fun foo3(bar: String = "ABC", baz: Int = 42) 

मानकों के बिना एक आवरण वर्ग कि बहस में ले जाता है बनाएँ, और है कार्य:

class Foo(val bar: String = "ABC", val baz: Int = 42) { 

    fun foo() { /* ... */ } 

    fun foo2() { 
    // ... 
    foo() 
    } 

    fun foo3() { 
    // ... 
    foo() 
    } 
} 

Answer 3

आप एक ही तर्क लेने कई कार्य होते हैं (साथ हैं वही डिफ़ॉल्ट मान), फिर यह एक कोड-गंध है जो यह सुझाव देता है कि वे पैरामीटर निकट से संबंधित हैं और अपनी कक्षा के अंदर रहना चाहिए।

data class FooArgs(val bar: String = "ABC", val baz: Int = 42) 

fun foo(args: FooArgs = FooArgs()) { /* ... */} 

fun foo2(args: FooArgs = FooArgs()) { 
    ... 
    foo(args) 
} 

fun foo3(args: FooArgs = FooArgs()) { 
    ... 
    foo(args) 
} 

तो foo और/या foo2

, foo3 केवल अपने तर्क का उपयोग करें, तो आगे रिफैक्टरिंग FooArgs वर्ग में foo और foo2 कदम होगा, the answer by @nhaarman