remember — asosiy tushunchalar, qiymatlarni rekompozitsiyalar orasida saqlash

Jetpack Compose-da remember nima

remember — androidx.compose.runtime paketidagi Jetpack Compose-ning o'rnatilgan funksiyasi bo'lib, Composable funksiyasining ketma-ket chaqiruvlari orasida o'z qiymatini saqlaydigan obyekt yaratadi. Texnik jihatdan, remember slotlar bilan ishlaydi — UI daraxtidagi funksiya chaqiruvining har bir pozitsiyasi uchun ajratilgan maxsus xotira hujayralari. Funksiya kompozitsiya tarkibida qolsa (if sharti bilan o'chirilmagan bo'lsa), remember har bir rekompozitsiyada saqlangan qiymatni qaytaradi.

remember sintaksisi sodda: jingalak qavslar ichida boshlang'ich qiymatni hisoblash bloki ko'rsatiladi. Blok faqat bir marta — funksiyaning birinchi kompozitsiyasida bajariladi. Barcha keyingi rekompozitsiyalar saqlangan qiymatni qaytaradi, blokni qayta chaqirmaydi. Agar kalit (key parametri) ko'rsatilgan bo'lsa, blok kalit o'zgarganda qayta bajariladi, bu esa qiymatni kirish ma'lumotlari asosida qayta hisoblash imkonini beradi.

remember Kotlin sehri emas — bu kalit parametri va hisoblash lambdasi bo'lgan oddiy funksiya. Uning ichki amalga oshirilishi slotlardan o'qish va yozish uchun Composer-dan foydalanadi. Kotlin kompilyatori remember chaqiruvini ko'rib, joriy CompositionContext-ga murojaat qiladigan va slotlarni boshqaradigan kod yaratadi. Bu remember faqat Composable funksiyasi ichida yoki kompozitsiya kontekstidagi boshqa funksiyada chaqirilishi mumkinligini anglatadi.

remember turlari: remember, rememberSaveable, derivedStateOf

Jetpack Compose-da remember-ning har biri o'z maqsadiga ega bo'lgan uchta asosiy varianti mavjud. Asosiy remember qiymatni faqat joriy jarayon xotirasida saqlaydi — ekran aylantirilganda (config change) Compose Composition-ni qayta yaratadi va barcha remember qiymatlari nolga tushadi. Konfiguratsiya o'zgarishlari va jarayon to'xtatilganda ma'lumotlarni saqlash uchun rememberSaveable ishlatiladi.

rememberSaveable qiymatni SavedStateHandle yoki Parcelable mexanizmi orqali Bundle-ga serializatsiya qiladi. Bu ekran aylantirilishi, “Faoliyatni saqlama” chaqiruvi va hatto ilovaning vaqtincha kichraytirilishidan omon qolishga imkon beradi. Lekin rememberSaveable saqlanadigan ma'lumotlar turiga cheklovlar qo'yadi: ular primitiv, Parcelable, Serializable bo'lishi yoki Saver konvertorini qo'llab-quvvatlashi kerak.

derivedStateOf — bu saqlash mexanizmi emas, balki optimallashtirishdir. Qiymati boshqa State obyektlari asosida hisoblanadigan State yaratadi. derivedStateOf manba holatlarning o'zgarishlariga reaksiya beradi, lekin qiymatni faqat obunachilar mavjud bo'lganda qayta hisoblaydi. Agar joriy rekompozitsiya derivedStateOf-ni o'qimasa, hisoblash bajarilmaydi, bu tez-tez sodir bo'ladigan, lekin hech kimga kerak bo'lmagan yangilanishlarda resurslarni tejaydi.

@Composable
fun RememberVariants() {
    // 1. Asosiy remember: kompozitsiyadan chiqquncha saqlanadi
    val createdAt = remember { System.currentTimeMillis() }

    // 2. rememberSaveable: ekran aylantirilishidan omon qoladi
    var username by rememberSaveable { mutableStateOf("") }

    // 3. derivedStateOf: faqat kerak bo'lganda hisoblanadi
    val isButtonVisible = remember {
        derivedStateOf { username.length() > 3 }
    }

    Text("Yaratildi: $createdAt")
    TextField(value = username, onValueChange = { username = it })

    if (isButtonVisible.value) {
        Text("Tugma ko'rsatiladi")
    }
}

remember vs rememberSaveable: qachon nimani ishlatish kerak

remember va rememberSaveable o'rtasidagi tanlov konfiguratsiya o'zgarishlari vaqtida ma'lumotlarni saqlash qanchalik muhimligiga bog'liq. Aylantirishda yo'qotilishi muhim bo'lmagan vaqtinchalik holatlar uchun (animatsiya, joriy aylantirish pozitsiyasi, fokus holati) — oddiy remember yetarli. Muhim ma'lumotlar uchun (formadagi matn, tanlangan elementlar, katakchalar) — rememberSaveable dan foydalaning.

Samaradorlik rememberSaveable oddiy remember-dan pastroq, chunki Bundle-ga serializatsiyani talab qiladi. rememberSaveable-ni faqat Activity-ni qayta yaratishdan omon qolishi kerak bo'lgan ma'lumotlar uchun ishlating. Qolgan hamma narsa uchun — oddiy remember. Haddan tashqari rememberSaveable ishlatilishi ekran aylantirishlari va ilovalar orasida almashishda sekinlashishga olib keladi.

Parcelable yoki Serializable-ni qo'llab-quvvatlamaydigan sinflar bilan ishlayotgan bo'lsangiz, Saver — obyektni qanday saqlash va tiklashni belgilaydigan konvertordan foydalaning. Saver bir juft lambda bilan tavsiflanadi: save (obyektni saqlanadigan turga o'zgartiradi) va restore (saqlangan ma'lumotlardan obyektni tiklaydi). Standart Saver allaqachon mutableStateListOf va mutableStateMapOf uchun amalga oshirilgan.

Real loyihalarda remember-dan foydalanish misollari

Oddiy stsenariyni ko'rib chiqaylik — profilni tahrirlash ekrani, bu erda remember bir nechta maqsadlar uchun ishlatiladi: forma maydonlarining holatini saqlash, hosilaviy qiymatlarni hisoblash va hisoblash jihatidan qimmat operatsiyalarni keshlash.

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("Ism") }
        )

        OutlinedTextField(
            value = state.bio,
            onValueChange = { state = state.copy(bio = it) },
            label = { Text("Haqida") }
        )

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

        Button(onClick = { /* save */ },
            enabled = isValid.value) {
            Text("Saqlash")
        }
    }
}

Misolda holat rememberSaveable orqali saqlanadi — ekran aylantirilganda matn yo'qolmaydi. isValid derivedStateOf orqali hisoblanadi, bu rekompozitsiyalarda keraksiz hisoblashlarning oldini oladi. bioWarning bio kaliti bilan remember dan foydalanadi — bu qimmat hisoblash (ixtiyoriy, namoyish uchun) faqat bio o'zgarganda qayta hisoblanadi, har bir rekompozitsiyada emas.

Hosilaviy holatlar va kalitlar bilan remember

Hosilaviy holatlar (derived state) — boshqa State obyektlaridan hisoblanadigan qiymatlardir. Ularni har bir rekompozitsiyada hisoblab, bir xil natijalarga CPU sarflash o'rniga, remember derivedStateOf bilan qiymatni faqat manbalar o'zgarganda hisoblaydi. Bu, ayniqsa, ma'lumotlarni filtrlash, saralash va aggregatsiya qilish uchun foydalidir.

Kalitlar bilan remember (remember(key) { calculation }) — boshqa optimallashtirish mexanizmi. Agar kalit oldingi rekompozitsiyadan o'zgarmagan bo'lsa, hisoblash bloki bajarilmaydi va keshlangan qiymat qaytariladi. Bu yaratilishi qimmat bo'lgan obyektlarni keshlash uchun qulaydir: sanalarni formatlash, JSON-ni pars qilish, katta o'zgarmas kolleksiyalarni yaratish.

@Composable
fun SearchResults(allItems: List<Item>, query: String) {
    // derivedStateOf: filtr faqat kirish ma'lumotlari o'zgarganda qayta hisoblanadi
    val filtered = remember {
        derivedStateOf {
            allItems.filter { it.title.contains(query, true) }
        }
    }

    // kalit bilan remember: formatlangan statistika faqat so'rov o'zgarganda qayta hisoblanadi
    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 — allItems yoki query o'zgarganda avtomatik qayta hisoblanadigan derivedStateOf. statsText remember(query) dan foydalanadi — qimmat satr formatlash faqat qidiruv so'rovi o'zgarganda bajariladi. derivedStateOf va kalitlar bilan remember kombinatsiyasi maksimal samaradorlikni beradi: hosilaviy holat faqat kerak bo'lganda hisoblanadi, murakkab obyektlar esa kalit o'zgarguncha keshlanadi.