it Keyword क्या है

it एक shortcut nickname है जो Kotlin अपने आप किसी lambda के इकलौते parameter को देता है, ताकि आपको इसे खुद नाम न देना पड़े।

In this page:

Using it for a Single Parameter
Comparing it to an Explicit Name
Avoiding Confusing Nested it
When to Prefer a Named Parameter

Syntax

kotlin

list.map { it * 2 }              // it: single implicit parameter
list.map { item -> item * 2 }    // same, with an explicit name

Using it for a Single Parameter

जब कोई lambda बिल्कुल एक parameter लेता है, Kotlin आपको इसे नाम देने से बचने देता है और lambda body के अंदर इसे बस it के रूप में refer करने देता है।

उदाहरण: Using it for a Single Parameter

markup

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `numbers`, set to `listOf(1, 2, 3, 4)`
    val numbers = listOf(1, 2, 3, 4)
    // Declare a read-only variable `doubled`, set to `numbers.map { it * 2 }`
    val doubled = numbers.map { it * 2 }
    // Print `doubled` to the console, with a trailing newline
    println(doubled)
}

Comparing it to an Explicit Name

वही lambda it के बजाय एक explicit parameter name के साथ लिखा जा सकता है; दोनों बराबर हैं, लेकिन लंबी bodies के लिए explicit names ज़्यादा साफ़ हैं।

उदाहरण: Comparing it to an Explicit Name

markup

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `numbers`, set to `listOf(1, 2, 3, 4)`
    val numbers = listOf(1, 2, 3, 4)
    // Declare a read-only variable `doubledImplicit`, set to `numbers.map { it * 2 }`
    val doubledImplicit = numbers.map { it * 2 }
    // Declare a read-only variable `doubledExplicit`, set to `numbers.map { number -> number * 2 }`
    val doubledExplicit = numbers.map { number -> number * 2 }
    // Print "Implicit: $doubledImplicit" to the console, with a trailing newline
    println("Implicit: $doubledImplicit")
    // Print "Explicit: $doubledExplicit" to the console, with a trailing newline
    println("Explicit: $doubledExplicit")
}

Avoiding Confusing Nested it

जब lambdas nested हों और दोनों it उपयोग करें, inner it outer वाले को shadow कर देता है, जो भ्रामक हो सकता है -- कम से कम एक को explicitly नाम देना ambiguity से बचाता है।

उदाहरण: Avoiding Confusing Nested it

markup

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `groups`, set to `listOf(listOf(1, 2), listOf(3, 4))`
    val groups = listOf(listOf(1, 2), listOf(3, 4))
    // Declare a read-only variable `result`, set to `groups.map { group -> group.map { it * 10 } }`
    val result = groups.map { group -> group.map { it * 10 } }
    // Print `result` to the console, with a trailing newline
    println(result)
}

When to Prefer a Named Parameter

multi-line या complex logic वाले lambdas के लिए, parameter को it के बजाय एक descriptive name देना आमतौर पर intent को भविष्य के readers के लिए कहीं स्पष्ट बना देता है।

उदाहरण: When to Prefer a Named Parameter

markup

// Entry point: execution of the program starts here
fun main() {
    // Declare a read-only variable `prices`, set to `listOf(10, 25, 40)`
    val prices = listOf(10, 25, 40)
    // Declare a read-only variable `withTax`, set to `prices.map { price ->`
    val withTax = prices.map { price ->
        // Declare a read-only variable `tax`, set to `price * 0.1`
        val tax = price * 0.1
        price + tax
    }
    // Print `withTax` to the console, with a trailing newline
    println(withTax)
}

Chapter Quiz — Complete all 6 topics to unlock

0/6 topics done

Complete these topics first:

← Previous Lesson map, filter, reduce Next Lesson → Function References

it Keyword क्या है

Using it for a Single Parameter

Comparing it to an Explicit Name

Avoiding Confusing Nested it

When to Prefer a Named Parameter

Chapter Quiz — Complete all 6 topics to unlock

Login to run this code