Modifier — Compose'ta değiştirici zinciri ve performans

Yazar: IT Sectr Yayınlanma: 2026-06-28 Okuma süresi: 8 dk

Modifier, Jetpack Compose'ta bir UI bileşeninin özelliklerini (boyut, dolgu, arka plan, jest işleme ve davranış) tanımlayan değiştirilemez bir nesnedir. Değiştiriciler sıralı çağrılar aracılığıyla bir zincir halinde birleştirilir ve uygulanma sıraları sonucu kritik şekilde etkiler. Google Android Developers, 2026'ya göre, Modifier'ın doğru kullanımı bildirimsel UI'da esnek ve yüksek performanslı arayüzler oluşturmanın temelidir.

Anahtar noktalar

  • Modifier, bir UI bileşeninin görünümünü ve davranışını tanımlayan değiştirilemez nesne
  • Zincir sıralı olarak oluşturulur, sıralama görüntülemeyi etkiler
  • Sıralama önemlidir: padding → size, size → padding'den farklıdır
  • Modifier.composed özel bileşik değiştiriciler oluşturmayı sağlar
  • Optimizasyon: her yeniden oluşturmada Modifier'ı yeniden oluşturmaktan kaçının

Jetpack Compose'ta Modifier nedir

Modifier, androidx.compose.ui paketinden Composite desenini uygulayan bir arayüzdür. Her değiştirici, bir öncekini saran ve kendi davranışını ekleyen bir zincir elemanıdır. Modifier değiştirilemez — herhangi bir değişiklik, zincire yeni bir eleman eklenerek kopyalama yoluyla yeni bir nesne oluşturur. Bu, tek bir Modifier'ın birden çok bileşen arasında güvenle paylaşılmasını sağlar.

Temel değiştirici işlevleri, yardımcı nesne Modifier aracılığıyla çağrılır (örneğin, Modifier.padding(), Modifier.fillMaxWidth()). Her işlev, eklenen elemanla birlikte yeni bir Modifier döndürür. Birden çok değiştirici varsa, bir zincir halinde birleştirilir: Modifier.padding(16.dp).fillMaxWidth().background(Color.Blue). Sıralama, UI elemanına göre dıştan içe doğrudur.

Geleneksel View'lerde özellikler setter'lar aracılığıyla ayarlanırken (view.setPadding(...), view.setBackground(...)), Compose'ta Modifier bildirimsel bir tanımlamadır. Bileşen, değiştiricileri çalışma zamanında uygulamaz — LayoutNode, oluşturma sırasında Modifier zincirini dolaşır ve ölçüm ve düzen aşamalarında işlenen bir Modifier.Element listesi oluşturur.

Değiştirici zinciri ve uygulama sırası

Değiştiricilerin sırası, Compose'taki en yaygın hatalardan biridir. Her değiştirici bir öncekini sarar ve işlemler dıştan içe doğru uygulanır. Örneğin, padding(16.dp).clickable { }: önce elemanın etrafına dolgu eklenir, ardından tıklama alanı dolguyu içerir. clickable { }.padding(16.dp): tıklama alanı önce eleman boyutuna eşittir, ardından etrafına dolgu eklenir — dolguya tıklamak çalışmaz.

Hatırlama kuralı: zinciri soldan sağa okuyun ve dıştan içe doğru uygulayın. İlk değiştirici en dıştakidir, elemanın etrafındaki alana uygulanır. Sonuncu en içtekidir, doğrudan içeriğe uygulanır. Boyut değiştiricileri (size, fillMaxWidth), ebeveynden dolgu gerekiyorsa dolgudan sonra, içerik önce sınırlanıp sonra ortalanacaksa dolgudan önce gelmelidir.

Örnek: size(100.dp).padding(10.dp) — sabit boyutlu 100dp eleman, ardından dışta 10dp dolgu (son boyut 120dp). padding(10.dp).size(100.dp) — 10dp dolgu kullanılabilir alanı (ebeveyn - 20dp) kadar azaltır, ardından size(100dp) ebeveyni taşırabilir. Sonucu doğrulamak için görüntüleme testleri kullanarak her zaman sıralamayı bilinçli olarak düşünün.

SıralamaSonuç
padding → clickableTıklama dolgu alanında da çalışır
clickable → paddingTıklama sadece içerikte çalışır, dolgu ölü bölge
size → paddingEleman size(100), dışta dolgu → 100+2*pad
padding → sizeDolgu alanı azaltır, size sınırları aşabilir
background → paddingArka plan dış alan dahil tüm elemanı doldurur
padding → backgroundArka plan sadece dolgu içinde (dış alan şeffaf)

Değiştirici türleri: boyut, dolgu, dekorasyon ve davranış

Standart Compose kitaplığı, kategorilere ayrılmış ~50+ değiştirici içerir. Boyut ve konumlandırma: Modifier.size(), width(), height(), fillMaxSize(), fillMaxWidth(), fillMaxHeight(), defaultMinSize(), requiredSize(). Dolgu ve kenarlıklar: padding(), offset(), margin (ebeveyn dolgusu veya Layout aracılığıyla ayarlanır). Dekorasyon: background(), border(), clip(), alpha(), shadow(), blur().

Davranış ve jestler: clickable(), combinedClickable(), pointerInput(), draggable(), swipeable(). Kapsayıcıda düzen: weight() (Row/Column için), align(), alignBy(), matchParentSize(). Semantik ve erişilebilirlik: semantics(), testTag(), clearAndSetSemantics(). Çizim: drawBehind(), drawWithContent(), drawModifier() — tuval üzerinde özel çizime izin veren değiştiriciler.

Semantik değiştiriciler özel bir kategoridir. Modifier.semantics {}, öğenin Erişilebilirlik ağacında nasıl temsil edileceğini tanımlar. Compose, metinden otomatik olarak semantiği doldurur, ancak özel bileşenlerin rolleri, durumları ve eylemleri manuel olarak ayarlanması gerekir. Bu, WCAG 2.2 uyumluluğu ve TalkBack (Android) ile VoiceOver (iOS)'un doğru çalışması için kritik öneme sahiptir.

kotlin
@Composable
fun ModifierDemo() {
    // Doğru sıralamayla değiştirici zinciri
    Box(
        modifier = Modifier
            .size(150.dp)
            .padding(8.dp)
            .border(2.dp, Color.Gray)
            .background(Color(0xFFE3F2FD))
            .clickable { /* handle click */ }
            .semantics {
                contentDescription = "Demo card with click action"
                role = Role.Button
            }
    ) {
        Text("Bana dokun")
    }
}

Modifier.composed ile özel değiştiriciler oluşturma

Modifier.composed, diğer değiştiricileri, LocalComposition'u ve yerel durumu kullanabilen bileşik değiştiriciler oluşturmayı sağlayan bir fabrika yöntemidir. Normal bir uzantı işlevinin aksine, composed her uygulandığında bir örnek oluşturur ve değiştiricinin kendi durumuna sahip olmasını sağlar.

Composed ne zaman kullanılmalı: yinelenen değiştirici kombinasyonları (örneğin, standart kart stili: padding + background + border + clickable); durumlu değiştiriciler (basıldığında animasyonlu arka plan değişimi); CompositionLocals'a erişim (MaterialTheme renk şeması, piksel yoğunluğu). Sıradan durumlar için, composed olmayan normal bir uzantı işlevi yeterlidir.

Composed performansı: her çağrı yeni bir değiştirici nesnesi oluşturur ve bu da yeniden oluşturma sırasında ekstra bellek ayırımlarına yol açabilir. Bunu önlemek için composed'ı remember ile sarın. Google, composed'ı yalnızca içeride gerçekten durum veya CompositionLocal gerektiğinde kullanmayı önerir. Statik kombinasyonlar için normal uzantı işlevlerini kullanın.

kotlin
// Durumla composed aracılığıyla özel değiştirici
fun Modifier.cardStyle(
    elevation: Dp = 4.dp,
    isSelected: Boolean = false
): Modifier = this.composed {
    val backgroundColor = if (isSelected)
        MaterialTheme.colorScheme.primaryContainer
    else
        MaterialTheme.colorScheme.surface

    this
        .fillMaxWidth()
        .padding(12.dp)
        .background(backgroundColor, RoundedCornerShape(8.dp))
        .shadow(elevation, RoundedCornerShape(8.dp))
}

// Kullanım örneği
@Composable
fun CardList() {
    Column {
        Box(Modifier.cardStyle()) { Text("Öğe 1") }
        Box(Modifier.cardStyle(isSelected = true)) { Text("Seçili") }
    }
}

// Statik sürüm (composed olmadan) — daha hızlı
fun Modifier.simpleCardStyle(): Modifier =
    this.fillMaxWidth().padding(8.dp).clip(RoundedCornerShape(4.dp))

Modifier performansı ve en iyi uygulamalar

Her yeniden oluşturmada Modifier'ı yeniden oluşturmaktan kaçının. Değiştirici değişken verilere bağlı değilse — onu bir sabite veya remember'a taşıyın. Modifier.padding().background() çağrısının her biri yeni Modifier.Element nesneleri oluşturur. İzole bir bileşende bu ihmal edilebilir, ancak yüzlerce öğeye sahip bir LazyColumn'da ekstra ayırımlar kaydırma sırasında gözle görülür gecikmelere neden olur.

Kural: değiştirici zinciri Composable işlev parametrelerine bağlı değilse — işlevin dışında (dosya veya Companion düzeyinde) val olarak bildirin. Bağlıysa — remember(bağımlılık) { ... } kullanın. Her zaman aynı olan değiştiriciler için, Composable dışındaki val en verimlisidir: bu tür nesneler uygulamanın tüm ömrü boyunca bir kez oluşturulur.

Modifier sıralaması için en iyi uygulamalar: değiştiricileri mantıksal sıraya koyun: önce boyut/dolgu (düzen), sonra dekorasyon (background, border), ardından davranış (clickable, pointerInput). Bu yalnızca okunabilirliği artırmakla kalmaz, aynı zamanda Compose Runtime'ın ölçüm sırasında zinciri optimize etmesine yardımcı olur. Ayrıca farklı Modifier ile aşırı iç içe Box öğelerinden kaçının — genellikle ebeveyn kapsayıcıdaki tek bir Modifier, 2-3 iç içe olanı değiştirebilir.

kotlin
// ✅ İyi: Composable dışında sabit
private val cardModifier = Modifier
    .fillMaxWidth()
    .padding(16.dp)
    .clip(RoundedCornerShape(8.dp))

@Composable
fun CardContent() {
    Box(cardModifier.background(Color.White)) { ... }
}

// ❌ Kötü: her yeniden oluşturmada yeniden yaratma
@Composable
fun BadCard() {
    Box(Modifier.fillMaxWidth().padding(16.dp)) { ... }
}

// ✅ İyi: dinamik Modifier için remember
@Composable
fun DynamicCard(color: Color) {
    val modifier = remember(color) {
        Modifier.fillMaxWidth().background(color)
    }
    Box(modifier) { ... }
}

Sıkça sorulan sorular

Birden çok Composable öğesi için aynı Modifier'ı kullanabilir miyim?

Evet, Modifier değiştirilemez olduğundan, tek bir nesne birden çok yerde güvenle kullanılabilir. Ancak, composed değiştirici kullanıyorsanız, her çağrı yeni bir örnek oluşturur. Statik zincirler için, Composable dışında bir sabit veya val en uygun çözümdür.

Değiştirici zincirini nasıl hata ayıklayabilirim?

Android Studio'da Layout Inspector kullanın — her Modifier'ın sınırlarını görsel olarak gösterir. Programlama yoluyla hata ayıklama için, zincirin her adımında farklı renklerle Modifier.border() ekleyerek her değiştiricinin sınırlarını görün.

Modifier.then() nedir ve sıralı çağrılardan farkı nedir?

Modifier.then(other), other zincirini this'e ekler. Sıralı çağrılar (Modifier.a().b()), Modifier.then(a()).then(b()) ile eşdeğerdir. Hiçbir fark yoktur — aynı zincir mekanizmasıdır. then(), bir değişkenden hazır bir zincir eklemeniz gerektiğinde kullanışlıdır.

Modifier, Erişilebilirlik semantiğini nasıl etkiler?

Modifier.semantics {}, öğenin ekran okuyucuya nasıl tanımlanacağını belirler. Modifier.clickable() otomatik olarak Düğme rolü ve Action(OnClick) ekler. Özel jestler için açıkça semantics belirtmeniz gerekir. Semantik değiştiriciler olmadan, TalkBack kullanıcıları özel bileşenlerle etkileşime giremez.

Modifier'daki background neden yuvarlak köşelerle çalışmaz?

Modifier.background(color, shape) köşelerle çalışır, ancak köşelerin kırpılması için clip() background'dan ÖNCE gelmelidir. Doğru sıra: clip(shape).background(color). Ayrıca içteki içeriği de kırpmanız gerekiyorsa, ebeveynde clipToBounds() kullanın.

Özet

  • Modifier görünüm ve davranışı bildirimsel olarak tanımlamak için değiştirilemez nesne
  • Sıralama sonucu belirler: padding → clickable vs clickable → padding
  • Zincir sıralı olarak oluşturulur, her öğe bir öncekini sarar
  • Modifier.composed durum ve CompositionLocal ile değiştiriciler oluşturmayı sağlar
  • Performans: statik zincirleri sabitlere taşıyın, dinamik için remember kullanın
  • Semantik: özel bileşenlerin Erişilebilirliği için Modifier.semantics zorunludur
  • Öneri: değiştiricileri d00üzenden dekorasyona, ardından davranışa sıralayın

Anahtar teslim bir mobil uygulama geliştireceğiz

IT Sectr, 2017'den beri girişimler ve işletmeler için iOS ve Android uygulamaları oluşturmaktadır. Size danışmanlık yapacak ve en iyi çözümü önereceğiz.

Projeyi tartış

Ayrıca okuyun