remember — मुख्य अवधारणाएँ, पुनर्संयोजन के बीच मानों को संरक्षित करना

Jetpack Compose में remember क्या है

remember androidx.compose.runtime पैकेज से एक अंतर्निहित Jetpack Compose फ़ंक्शन है जो एक ऐसी वस्तु बनाता है जो Composable फ़ंक्शन के क्रमिक कॉलों के बीच अपना मान संरक्षित करती है। तकनीकी रूप से, remember स्लॉट के साथ काम करता है — UI ट्री में प्रत्येक फ़ंक्शन कॉल स्थिति के लिए आवंटित विशेष मेमोरी कोशिकाएँ। जब तक फ़ंक्शन संरचना में रहता है (if-शर्त के माध्यम से हटाया नहीं जाता), remember प्रत्येक पुनर्संयोजन पर सहेजा गया मान लौटाएगा।

remember का सिंटैक्स सरल है: घुंघराले कोष्ठकों के अंदर प्रारंभिक मान की गणना का ब्लॉक निर्दिष्ट किया जाता है। ब्लॉक केवल एक बार निष्पादित होता है — फ़ंक्शन की पहली संरचना के दौरान। सभी बाद के पुनर्संयोजन ब्लॉक को फिर से निष्पादित किए बिना पहले से सहेजे गए मान को लौटाते हैं। हालांकि, यदि कोई कुंजी पैरामीटर निर्दिष्ट किया गया है, तो कुंजी बदलने पर ब्लॉक फिर से निष्पादित होता है, जिससे इनपुट डेटा के आधार पर मान की पुनर्गणना की जा सकती है।

remember Kotlin जादू नहीं है — यह एक कुंजी पैरामीटर और गणना लैम्ब्डा वाला एक सरल फ़ंक्शन है। इसका आंतरिक कार्यान्वयन स्लॉट में पढ़ने और लिखने के लिए Composer का उपयोग करता है। Kotlin कंपाइलर, remember कॉल को देखते हुए, कोड उत्पन्न करता है जो वर्तमान CompositionContext तक पहुँचता है और स्लॉट का प्रबंधन करता है। इसका मतलब है कि remember को केवल Composable फ़ंक्शन के अंदर या संरचना संदर्भ में किसी अन्य फ़ंक्शन में कॉल किया जा सकता है।

remember के प्रकार: remember, rememberSaveable, derivedStateOf

Jetpack Compose में, remember के तीन मुख्य प्रकार हैं, प्रत्येक का अपना उद्देश्य है। मूल remember केवल वर्तमान प्रक्रिया मेमोरी में मान संरक्षित करता है — स्क्रीन घुमाने (कॉन्फ़िग परिवर्तन) पर, Compose संरचना को फिर से बनाता है और सभी remember मान रीसेट हो जाते हैं। कॉन्फ़िगरेशन परिवर्तनों और प्रक्रिया रुकने के दौरान डेटा संरक्षित करने के लिए rememberSaveable का उपयोग किया जाता है।

rememberSaveable SavedStateHandle या Parcelable तंत्र के माध्यम से मान को Bundle में क्रमबद्ध करता है। यह स्क्रीन घुमाव, "गतिविधियों को न रखें" सेटिंग और यहां तक कि अस्थायी ऐप छोटा करने से बचने की अनुमति देता है। हालांकि, rememberSaveable संग्रहीत किए जा सकने वाले डेटा के प्रकार पर प्रतिबंध लगाता है: वे प्रिमिटिव, Parcelable, Serializable होने चाहिए या Saver कनवर्टर का समर्थन करना चाहिए।

derivedStateOf संरक्षण तंत्र नहीं बल्कि एक अनुकूलन है। यह एक State बनाता है जिसका मान अन्य State ऑब्जेक्ट्स से गणना किया जाता है। derivedStateOf स्रोत स्थितियों में परिवर्तनों पर प्रतिक्रिया करता है लेकिन केवल तभी मान की पुनर्गणना करता है जब ग्राहक हों। यदि वर्तमान पुनर्संयोजन derivedStateOf नहीं पढ़ता है, तो गणना नहीं की जाती है, जिससे बार-बार लेकिन अनावश्यक अपडेट पर संसाधनों की बचत होती है।

@Composable
fun RememberVariants() {
    // 1. मूल remember: संरचना छोड़ने तक बना रहता है
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: स्क्रीन घुमाव से बचता है
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: केवल जब आवश्यक हो गणना करता है
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

    Text("बनाया गया: $createdAt")
    TextField(value = username, onValueChange = { username = it })

    if (isButtonVisible.value) {
        Text("बटन दिखाया जाएगा")
    }
}

remember बनाम rememberSaveable: कब क्या उपयोग करें

remember और rememberSaveable के बीच चुनाव इस बात पर निर्भर करता है कि कॉन्फ़िगरेशन परिवर्तनों के दौरान डेटा संरक्षित करना कितना महत्वपूर्ण है। अस्थायी स्थितियों के लिए जिन्हें घुमाने पर खोना महत्वपूर्ण नहीं है (एनिमेशन, वर्तमान स्क्रॉल स्थिति, फ़ोकस स्थिति) — सामान्य remember पर्याप्त है। महत्वपूर्ण डेटा के लिए (फ़ॉर्म में टेक्स्ट, चयनित आइटम, चेकबॉक्स) — rememberSaveable का उपयोग करें।

प्रदर्शन: rememberSaveable सामान्य remember की तुलना में धीमा है क्योंकि इसे Bundle में क्रमबद्धता की आवश्यकता होती है। rememberSaveable का उपयोग केवल उस डेटा के लिए करें जिसे वास्तव में Activity पुनर्निर्माण से बचने की आवश्यकता है। बाकी सबके लिए — सादा remember। rememberSaveable का अत्यधिक उपयोग स्क्रीन घुमाने और ऐप्स के बीच स्विच करने पर धीमापन लाता है।

यदि आप उन वर्गों के साथ काम करते हैं जो Parcelable या Serializable का समर्थन नहीं करते हैं, तो Saver का उपयोग करें — एक कनवर्टर जो परिभाषित करता है कि ऑब्जेक्ट को कैसे सहेजना और पुनर्स्थापित करना है। Saver को लैम्ब्डा की एक जोड़ी द्वारा वर्णित किया गया है: save (ऑब्जेक्ट को संग्रहणीय प्रकार में परिवर्तित करता है) और restore (सहेजे गए डेटा से ऑब्जेक्ट को पुनर्स्थापित करता है)। mutableStateListOf और mutableStateMapOf के लिए एक मानक Saver पहले से लागू है।

वास्तविक परियोजनाओं में remember के उपयोग के उदाहरण

एक विशिष्ट परिदृश्य पर विचार करें — एक प्रोफ़ाइल संपादन स्क्रीन जहाँ remember का उपयोग कई उद्देश्यों के लिए किया जाता है: फ़ॉर्म फ़ील्ड की स्थिति संग्रहीत करना, व्युत्पन्न मानों की गणना करना और कम्प्यूटेशनल रूप से महंगे संचालन को कैश करना।

data class ProfileUiState(
    val name: String = "",
    val bio: String = "",
    val isSaving: Boolean = false
)

@Composable
fun ProfileEditor() {
    var state by rememberSaveable { mutableStateOf(ProfileUiState()) }
    val isValid = remember {
        derivedStateOf { state.name.isNotBlank() && state.bio.length() <= 500 }
    }

    val bioWarning = remember(state.bio) {
        if (state.bio.length() > 400) {
            "${500 - state.bio.length} chars left"
        } else null
    }

    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = state.name,
            onValueChange = { state = state.copy(name = it) },
            label = { Text("नाम") }
        )

        OutlinedTextField(
            value = state.bio,
            onValueChange = { state = state.copy(bio = it) },
            label = { Text("के बारे में") }
        )

        bioWarning?.let { Text(it, color = MaterialTheme.colorScheme.error) }

        Button(onClick = { /* save */ },
            enabled = isValid.value) {
            Text("सहेजें")
        }
    }
}

उदाहरण में, स्थिति rememberSaveable के माध्यम से सहेजी जाती है — स्क्रीन घुमाने पर टेक्स्ट नहीं खोएगा। isValid की गणना derivedStateOf के माध्यम से की जाती है, जो पुनर्संयोजनों के दौरान अनावश्यक गणनाओं को रोकता है। bioWarning bio कुंजी के साथ remember का उपयोग करता है — यह एक महंगी गणना है (वैकल्पिक, प्रदर्शन के लिए) जो केवल bio बदलने पर पुनर्गणना करती है, न कि हर पुनर्संयोजन पर।

व्युत्पन्न स्थितियाँ और कुंजियों के साथ remember

व्युत्पन्न स्थितियाँ वे मान हैं जो अन्य State ऑब्जेक्ट्स से गणना किए जाते हैं। हर पुनर्संयोजन पर उनकी गणना करने और समान परिणामों पर CPU बर्बाद करने के बजाय, remember derivedStateOf के साथ केवल तभी मान की गणना करता है जब स्रोत बदलते हैं। यह विशेष रूप से फ़िल्टरिंग, सॉर्टिंग और डेटा एकत्रीकरण के लिए उपयोगी है।

कुंजियों के साथ remember (remember(key) { calculation }) एक और अनुकूलन तंत्र है। यदि पिछले पुनर्संयोजन के बाद से कुंजी नहीं बदली है, तो गणना ब्लॉक निष्पादित नहीं होता है और कैश किया गया मान लौटाया जाता है। यह उन ऑब्जेक्ट्स को कैश करने के लिए सुविधाजनक है जिनका निर्माण महंगा है: दिनांक स्वरूपण, JSON पार्सिंग, बड़े अपरिवर्तनीय संग्रह बनाना।

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: फ़िल्टर केवल तब पुनर्गणना करता है जब इनपुट बदलते हैं
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // कुंजी के साथ remember: स्वरूपित आँकड़े केवल क्वेरी बदलने पर पुनर्गणना करते हैं
    val statsText = remember(query) {
        "Results for query \"$query\": ${filtered.value.size}"
    }

    Text(statsText)
    LazyColumn {
        items(filtered.value, key = { it.id }) { item ->
            Text(item.title)
        }
    }
}

filtered एक derivedStateOf है जो allItems या query बदलने पर स्वचालित रूप से पुनर्गणना करता है। statsText remember(query) का उपयोग करता है — महंगा स्ट्रिंग स्वरूपण केवल तब किया जाता है जब खोज क्वेरी बदलती है। derivedStateOf और कुंजियों के साथ remember का संयोजन अधिकतम प्रदर्शन देता है: व्युत्पन्न स्थिति की गणना केवल जब आवश्यक होती है, और जटिल ऑब्जेक्ट कुंजी बदलने तक कैश किए जाते हैं।