Redux’ın Temel Kavramlarına Giriş
Modern web uygulamaları, kullanıcı arayüzlerinin (UI) karmaşıklığı arttıkça, yönetilmesi gereken durumun (state) hacmi ve karmaşıklığı da artmaktadır. Bir uygulamanın durumu, kullanıcıdan gelen verilerden, sunucudan çekilen bilgilere, UI bileşenlerinin kendi iç ayarlarından, uygulamanın genel navigasyon bilgilerine kadar birçok farklı şeyi kapsayabilir. Bu durumun etkili, öngörülebilir ve bakımı kolay bir şekilde yönetilmesi, büyük ölçekli uygulamalar için kritik bir zorluk haline gelmiştir. İşte bu noktada Redux gibi durum yönetim kütüphaneleri devreye girer.
Redux, JavaScript uygulamaları için öngörülebilir bir durum kapsayıcısıdır. Özellikle React, Angular veya Vue gibi modern ön yüz kütüphaneleriyle birlikte kullanılmak üzere tasarlanmış olsa da, aslında herhangi bir JavaScript uygulamasıyla kullanılabilir. Redux’ın temel amacı, uygulamanızın durumunu merkezi bir yerde tutarak, bu duruma erişimi ve bu durumdaki değişiklikleri tutarlı ve öngörülebilir bir şekilde yönetmektir. Bu sayede, uygulamanızın farklı bileşenleri arasında durum paylaşımı ve senkronizasyonu kolaylaşır, hataların tespiti ve ayıklanması basitleşir ve uygulamanın genel davranışının anlaşılması daha net hale gelir.
Bu makalede, Redux’ın temel prensiplerini, ana bileşenlerini ve çalışma mekanizmasını derinlemesine inceleyeceğiz. Redux’ın neden bu kadar popüler olduğunu, hangi sorunları çözdüğünü ve modern web geliştirme dünyasındaki yerini anlamanıza yardımcı olacağız.
Neden Redux Kullanmalıyız?
Redux, durum yönetiminde karşılaşılan yaygın sorunlara çözüm sunarak geliştiricilere bir dizi avantaj sağlar:
1. Öngörülebilirlik (Predictability)
Redux’ın en büyük faydalarından biri, durumun nasıl değiştiğini öngörülebilir hale getirmesidir. Redux, tek yönlü bir veri akışı (unidirectional data flow) modelini benimser. Bu, durum değişikliklerinin her zaman belirli bir sıra ve kurallar dizisi takip ettiği anlamına gelir. Bir action’ın gönderilmesi, reducer’ın çalışması ve yeni bir durumun oluşması süreci her zaman aynıdır. Bu tutarlılık, uygulamanızın davranışını anlamayı ve hataları bulmayı kolaylaştırır. Hangi action’ın hangi durumda ne tür bir değişikliğe yol açacağını kesin olarak bilebilirsiniz.
2. Merkeziyetçilik (Centralized State)
Tüm uygulama durumu tek bir büyük JavaScript nesnesi olarak tek bir “store” içinde saklanır. Bu merkezi yapı, uygulamanızın herhangi bir yerinden herhangi bir duruma kolayca erişmenizi sağlar. Bileşenler arası prop drilling (bir durumu birçok ara bileşen üzerinden geçirme) ihtiyacını azaltır ve farklı bileşenlerin aynı duruma bağımsız olarak erişmesine olanak tanır. Global bir durumu yönetmek gerektiğinde, bu merkezi yaklaşım oldukça etkilidir.
3. Hata Ayıklama Kolaylığı (Debuggability)
Redux DevTools gibi araçlar sayesinde, uygulamanızın durumunu zaman içinde takip edebilir, her bir action’ın durumu nasıl etkilediğini gözlemleyebilir ve hatta geçmiş durumlara geri dönebilirsiniz (time-travel debugging). Bu, özellikle karmaşık hataların izini sürmek ve uygulamanın beklenmeyen davranışlarını anlamak için paha biçilmez bir özelliktir. Her action bir kayıt bırakır ve bu kayıtlar durumun nasıl değiştiğinin eksiksiz bir geçmişini sunar.
4. Bakım Kolaylığı (Maintainability)
Redux’ın katı yapısı ve prensipleri, uygulamanızın kod tabanını daha düzenli ve tutarlı hale getirir. Durum yönetim mantığı, UI bileşenlerinden ayrı tutulur, bu da her bir parçanın kendi sorumluluk alanına odaklanmasını sağlar. Yeni geliştiricilerin projeye adaptasyonu kolaylaşır, çünkü durum yönetiminin nasıl çalıştığını öğrenmek için belirli bir şablon mevcuttur.
5. Performans Optimizasyonu
React ile kullanıldığında, react-redux kütüphanesi, yalnızca durumun ilgili kısımları değiştiğinde bileşenlerin yeniden render edilmesini sağlayarak performans optimizasyonuna yardımcı olur. useSelector hook’u veya connect HOC’u, bileşenlerin yalnızca ihtiyaç duydukları durum parçalarına abone olmasını sağlar ve gereksiz yeniden render’ları önler.
Redux’ın Üç Temel Prensibi
Redux’ın çalışma şeklini anlamak için üç temel prensibini kavramak esastır. Bu prensipler, Redux’ın öngörülebilir ve yönetilebilir olmasının temelini oluşturur.
1. Tek Doğruluk Kaynağı (Single Source of Truth)
Uygulamanızın tüm durumu, tek bir JavaScript nesnesi olarak tek bir “store” içinde saklanır. Bu, uygulamanızın herhangi bir yerindeki bir durum parçasını ararken nereye bakacağınızı her zaman bildiğiniz anlamına gelir. Birden fazla durum kaynağına sahip olmak, karmaşıklığı artırır ve senkronizasyon sorunlarına yol açabilir. Redux bu sorunu, tüm durumu tek bir ağaç yapısında toplayarak çözer.
// Örnek bir store durumu
{
kullanici: {
id: 1,
ad: "Ahmet",
email: "ahmet@example.com"
},
urunler: [
{ id: 101, ad: "Laptop", fiyat: 12000 },
{ id: 102, ad: "Mouse", fiyat: 250 }
],
sepet: {
urunler: [{ urunId: 101, miktar: 1 }],
toplam: 12000
},
ui: {
isLoading: false,
hataMesaji: null
}
}
Bu yapı, uygulamanızın anlık durumunun tam bir “snapshot”ını sunar.
2. Durum Salt Okunurdur (State is Read-Only)
Uygulamanın durumu doğrudan değiştirilemez. Durumu değiştirmek için tek yol, ne olduğunu açıklayan bir eylem (action) göndermektir. Bu, durumun ne zaman, neden ve nasıl değiştiğini açıkça belirtir. Doğrudan durum manipülasyonu, beklenmeyen yan etkilere ve hata ayıklama zorluklarına yol açabilir. Durumun salt okunur olması, veri akışını daha şeffaf ve izlenebilir hale getirir.
3. Değişiklikler Saf Fonksiyonlarla Yapılır (Changes are Made with Pure Functions)
Durumu değiştirmek için gönderilen action’lar, “reducer” adı verilen saf fonksiyonlar tarafından işlenir. Bir reducer, mevcut durumu (state) ve bir action’ı girdi olarak alır ve yeni bir durum döndürür. Saf fonksiyonlar, aynı girdilerle her zaman aynı çıktıyı üretir ve dışarıdaki herhangi bir şeyi değiştirmezler (yan etkisi yoktur). Bu prensip, Redux’ın öngörülebilirliğini ve test edilebilirliğini sağlar. Reducer’lar asla doğrudan mevcut durumu değiştirmemeli, her zaman yeni bir durum nesnesi döndürmelidir. Bu, immutability (değişmezlik) kavramının temelini oluşturur.
Redux’ın Temel Bileşenleri
Redux ekosisteminde birkaç anahtar bileşen ve kavram bulunur. Bunları anlamak, Redux ile etkili bir şekilde çalışmak için hayati öneme sahiptir.
1. Store (Mağaza)
Store, Redux uygulamanızın kalbidir. Tek doğruluk kaynağı prensibini somutlaştırır. Tüm uygulama durumu tek bir store nesnesinde saklanır. Store’un temel görevleri şunlardır:
* Uygulamanın durumunu tutar.
* Action’ları dispatch ederek durumun değişmesine izin verir.
* Reducer’ları kullanarak action’ları işler ve yeni durumu oluşturur.
* Durumdaki değişiklikleri dinleyen dinleyicileri (listeners) kaydetmenize olanak tanır.
Bir Redux store’u genellikle createStore (eski API) veya configureStore (Redux Toolkit ile önerilen API) fonksiyonu ile oluşturulur.
// Örnek Store Oluşturma (createStore ile - eski yöntem)
import { createStore } from 'redux';
// Reducer'ı tanımlayacağız (aşağıda detaylı incelenecek)
function sayacReducer(state = { sayi: 0 }, action) {
switch (action.type) {
case 'ARTTIR':
return { sayi: state.sayi + 1 };
case 'AZALT':
return { sayi: state.sayi - 1 };
default:
return state;
}
}
const store = createStore(sayacReducer);
console.log(store.getState()); // { sayi: 0 }
store.getState() metodu, mevcut durumu döndürür. store.dispatch(action) metodu, bir action göndererek durumu değiştirmek için kullanılır. store.subscribe(listener) metodu ise durum değiştiğinde çağrılacak bir fonksiyonu kaydetmenizi sağlar.
2. Actions (Eylemler)
Action’lar, uygulamanızda ne olduğunu açıklayan düz JavaScript nesneleridir. Durumu değiştirmek için tek yoldur. Bir action’ın en temel özelliği, type adında bir özelliğe sahip olmasıdır. Bu type özelliği, action’ın ne tür bir eylem olduğunu belirten bir dizedir (string). Genellikle büyük harflerle ve alt çizgi ile ayrılmış kelimelerle tanımlanır (örneğin, ADD_TODO, USER_LOGGED_IN).
Action’lar, değiştirilmek istenen verileri (payload) de taşıyabilir.
// Örnek Action Nesneleri
const arttirAction = {
type: 'ARTTIR'
};
const azaltAction = {
type: 'AZALT'
};
const urunEkleAction = {
type: 'URUN_EKLE',
payload: {
id: 103,
ad: 'Klavye',
fiyat: 500,
miktar: 1
}
};
Action Creators (Eylem Oluşturucular): Action’ları manuel olarak yazmak yerine, bunları oluşturan fonksiyonlar yazmak yaygın bir uygulamadır. Bu fonksiyonlara “action creators” denir. Action creators, action nesnelerini daha kolay ve hatasız bir şekilde oluşturmanızı sağlar.
// Örnek Action Creators
function arttir() {
return {
type: 'ARTTIR'
};
}
function azalt() {
return {
type: 'AZALT'
};
}
function urunEkle(urunBilgisi) {
return {
type: 'URUN_EKLE',
payload: urunBilgisi
};
}
// Kullanımı
store.dispatch(arttir());
store.dispatch(urunEkle({ id: 104, ad: 'Monitör', fiyat: 3000 }));
3. Reducers (İndirgeyiciler)
Reducer’lar, Redux’ın durum değişikliklerini yönettiği yerdir. Saf fonksiyonlardır ve iki argüman alırlar: mevcut durum (state) ve bir action. Bu iki girdiye dayanarak yeni bir durum nesnesi döndürürler. Unutulmamalıdır ki reducer’lar asla doğrudan mevcut durumu değiştirmemeli (mutate etmemeli), her zaman yeni bir durum nesnesi oluşturmalıdır. Bu, immutability prensibinin temelidir.
// Örnek Reducer
function sayacReducer(state = { sayi: 0 }, action) {
switch (action.type) {
case 'ARTTIR':
// Mevcut durumu doğrudan değiştirmek yerine yeni bir nesne döndürüyoruz
return { ...state, sayi: state.sayi + 1 };
case 'AZALT':
return { ...state, sayi: state.sayi - 1 };
case 'BELIRLI_MIKTAR_ARTTIR':
return { ...state, sayi: state.sayi + action.payload };
default:
// Bilinmeyen bir action geldiğinde mevcut durumu olduğu gibi döndürüyoruz
return state;
}
}
İmmutability (Değişmezlik) ve Reducer’lar: Reducer’larda immutability sağlamak kritik öneme sahiptir. JavaScript’te nesneler ve diziler referans tipleridir. Bir nesneyi veya diziyi doğrudan değiştirmek (örneğin state.sayi++ veya state.dizi.push()), Redux’ın durum değişikliklerini doğru bir şekilde algılamasını engeller ve beklenmeyen hatalara yol açabilir. Bunun yerine, spread operatörü (...) veya Object.assign() gibi yöntemler kullanılarak yeni nesneler veya diziler oluşturulmalıdır.
* Nesneler için: return { ...state, yeniOzellik: deger }
* Diziler için:
* Ekleme: return [...state, yeniOge]
* Silme: return state.filter(item => item.id !== id)
* Güncelleme: return state.map(item => item.id === id ? { ...item, guncelOzellik: yeniDeger } : item)
combineReducers: Uygulamanız büyüdükçe, tek bir büyük reducer yerine durumu daha küçük, yönetilebilir parçalara bölmek istersiniz. Her bir parça, uygulamanın belirli bir bölümünün durumunu yöneten kendi reducer’ına sahip olabilir. combineReducers yardımcı fonksiyonu, bu küçük reducer’ları bir araya getirerek tek bir kök reducer oluşturur ve Redux store’una verilecek tek bir fonksiyon haline getirir.
import { combineReducers } from 'redux';
function kullaniciReducer(state = { ad: '', email: '' }, action) {
switch (action.type) {
case 'KULLANICI_GIRISI':
return { ...state, ad: action.payload.ad, email: action.payload.email };
default:
return state;
}
}
function urunlerReducer(state = [], action) {
switch (action.type) {
case 'URUN_EKLE':
return [...state, action.payload];
case 'URUN_SIL':
return state.filter(urun => urun.id !== action.payload.id);
default:
return state;
}
}
const rootReducer = combineReducers({
kullanici: kullaniciReducer,
urunler: urunlerReducer,
sayac: sayacReducer // Yukarıdaki sayacReducer'ı da ekleyelim
});
// Şimdi store'u bu rootReducer ile oluşturabiliriz
// const store = createStore(rootReducer);
combineReducers ile oluşturulan store’un durumu şu şekilde görünür:
{
kullanici: { ad: '', email: '' },
urunler: [],
sayac: { sayi: 0 }
}
4. Dispatch (Gönderme)
dispatch metodu, bir action’ı Redux store’una göndermek için kullanılır. Durumu değiştirmek istediğinizde, bir action nesnesini store.dispatch() fonksiyonuna iletirsiniz. Bu, Redux veri akışını başlatan tetikleyicidir.
store.dispatch(arttir()); // { sayi: 1 } olur
store.dispatch(azalt()); // { sayi: 0 } olur
store.dispatch({ type: 'BELIRLI_MIKTAR_ARTTIR', payload: 5 }); // { sayi: 5 } olur
Bir action dispatch edildiğinde, Redux store’u bu action’ı tüm reducer’lara iletir. Her reducer, kendi ilgilendiği action tipini kontrol eder ve duruma uygun değişiklikleri yapar.
5. Selectors (Seçiciler)
Selector’lar, Redux store’undaki durumdan belirli parçaları çıkarmak için kullanılan fonksiyonlardır. Bir selector, tüm store durumunu girdi olarak alır ve uygulamanızın bir bileşeninin ihtiyaç duyduğu belirli veriyi döndürür.
Selector’ları kullanmanın faydaları şunlardır:
* Veri Çıkarma Mantığını Merkezi Hale Getirme: Durumdan veri çekme mantığını bileşenlerden ayırır.
* Yeniden Kullanılabilirlik: Aynı veri parçasını birden fazla bileşen kullanıyorsa, tek bir selector yazıp her yerde kullanabilirsiniz.
* Performans Optimizasyonu (Memoization ile): reselect gibi kütüphanelerle birlikte kullanıldığında, selector’lar memoize edilebilir. Bu, selector’ın girdileri değişmediği sürece hesaplamayı tekrar yapmamasını ve önbelleğe alınmış sonucu döndürmesini sağlar. Bu, özellikle karmaşık hesaplamalar gerektiren durumlarda performansı artırır.
// Örnek Selector
const getToplamUrunSayisi = (state) => state.urunler.length;
const getSepetToplamFiyat = (state) => state.sepet.urunler.reduce((acc, item) => acc + item.fiyat * item.miktar, 0);
// Kullanımı (örneğin React bileşeninde)
// const toplamUrun = useSelector(getToplamUrunSayisi);
// const sepetFiyat = useSelector(getSepetToplamFiyat);
Redux Veri Akışı (Lifecycle)
Redux’ın temel bileşenlerini anladıktan sonra, bir action’ın dispatch edilmesinden durumun güncellenmesine ve UI’ın yeniden render edilmesine kadar olan tüm veri akışını adım adım inceleyelim:
1. Kullanıcı Etkileşimi / Uygulama Olayı: Her şey bir kullanıcının bir düğmeye tıklaması, bir form göndermesi veya uygulamanın bir API çağrısı yapması gibi bir olayla başlar.
2. Action Oluşturma: Bu olay, ne olduğunu açıklayan bir action nesnesinin oluşturulmasını tetikler. Genellikle bir “action creator” fonksiyonu çağrılarak yapılır.
Örnek:* Kullanıcı “Arttır” düğmesine tıklar. arttir() action creator çağrılır ve { type: 'ARTTIR' } action’ı oluşturulur.
3. Action Dispatch Etme: Oluşturulan action, store.dispatch() metodu aracılığıyla Redux store’una gönderilir.
Örnek:* store.dispatch(arttir());
4. Middleware (İsteğe Bağlı): Action, reducer’lara ulaşmadan önce bir veya daha fazla middleware’den geçebilir. Middleware’ler, action’ları yakalama, değiştirme, loglama veya asenkron işlemler (API çağrıları gibi) gerçekleştirme gibi yan etkiler için kullanılır.
Örnek:* Bir loglama middleware’i, her action’ı konsola yazdırabilir. Bir Redux Thunk middleware’i, bir API çağrısı yapabilir ve sonuçlara göre yeni action’lar dispatch edebilir.
5. Reducer’lara Ulaşma: Middleware’leri geçtikten sonra, action nihayet store’un ana reducer’ına ulaşır (genellikle combineReducers tarafından oluşturulan kök reducer). Reducer, mevcut durumu ve action’ı girdi olarak alır.
6. Yeni Durum Oluşturma: Reducer, action.type özelliğine göre bir switch ifadesi kullanarak ilgili durumu hesaplar. Mevcut durumu değiştirmeden, yeni bir durum nesnesi oluşturur ve döndürür.
Örnek:* sayacReducer, ARTTIR action’ını görür ve { sayi: state.sayi + 1 } şeklinde yeni bir durum döndürür.
7. Store Güncellemesi: Reducer’dan dönen yeni durum, store’daki mevcut durumu tamamen değiştirir.
8. Dinleyicileri Bilgilendirme: Store, durumundaki değişikliği dinleyen tüm abone olmuş bileşenleri veya fonksiyonları bilgilendirir.
9. UI Yeniden Render Etme: React-Redux gibi kütüphaneler, durumdaki değişiklikleri algılar ve yalnızca etkilenen bileşenleri yeni durum verileriyle yeniden render eder.
Örnek:* Sayacı gösteren React bileşeni, sayi değeri değiştiği için yeniden render edilir ve ekranda güncel değeri gösterir.
Bu tek yönlü, döngüsel veri akışı, Redux’ın öngörülebilirliğini ve hata ayıklama kolaylığını sağlayan temel mekanizmadır.
Değişmezlik (Immutability) Neden Önemli?
Daha önce de belirttiğimiz gibi, Redux’ta durumun doğrudan değiştirilmemesi (immutability) kritik bir prensiptir. Bunun neden önemli olduğunu daha detaylı inceleyelim:
1. Performans Optimizasyonu: React gibi UI kütüphaneleri, bileşenlerin ne zaman yeniden render edilmesi gerektiğine karar verirken durum nesnelerinin referanslarını karşılaştırır. Eğer bir nesnenin içeriği değişse bile referansı aynı kalırsa (yani nesneyi doğrudan değiştirirseniz), React değişikliği algılamayabilir ve UI güncellenmeyebilir. Yeni bir nesne döndürmek, her zaman yeni bir referans sağlar ve React’in değişikliği doğru bir şekilde algılamasına olanak tanır.
2. Hata Ayıklama Kolaylığı: Durumun doğrudan değiştirilmemesi, Redux DevTools gibi araçların zaman yolculuğu (time-travel debugging) gibi özelliklerini mümkün kılar. Her action’dan sonra oluşan yeni durum, önceki durumdan bağımsız bir kopyadır. Bu sayede, uygulamanızın durumunun geçmişini adım adım inceleyebilir ve herhangi bir noktaya geri dönebilirsiniz.
3. Yan Etkilerden Kaçınma: Saf fonksiyon prensibiyle birleşen immutability, durum değişikliklerinin yan etkilerden arındırılmasını sağlar. Bir reducer’ın sadece kendisine verilen mevcut durumu ve action’ı kullanarak yeni bir durum döndürmesi, dışarıdaki herhangi bir şeyi değiştirmesini engeller. Bu, kodun daha güvenli, daha öngörülebilir ve daha kolay test edilebilir olmasını sağlar.
4. Concurrency (Eşzamanlılık) ve Multi-threading (Çoklu İş Parçacığı): Her ne kadar JavaScript tek iş parçacıklı olsa da, immutability prensipleri eşzamanlı programlama ortamlarında paylaşılan verilerin güvenli bir şekilde yönetilmesi için temeldir. Redux, bu prensipleri benimseyerek gelecekteki olası mimarilere veya daha karmaşık senaryolara uyumluluk sağlar.
JavaScript’te immutability sağlamanın yaygın yolları, spread operatörü (...), Object.assign(), Array.prototype.map(), Array.prototype.filter(), Array.prototype.concat() gibi metotları kullanmaktır.
Middleware (Ara Yazılım)
Redux middleware’leri, dispatch fonksiyonunu genişletmek için kullanılan bir mekanizmadır. Bir action dispatch edildiğinde ve reducer’lara ulaşmadan önce, bu action’ın middleware zincirinden geçmesini sağlar. Middleware’ler, asenkron işlemler, loglama, hata raporlama veya API çağrıları gibi yan etkileri yönetmek için mükemmel bir yerdir.
Middleware’lerin temel yapısı genellikle şöyledir: ({ getState, dispatch }) => next => action => { ... }. Bu, bir fonksiyonun iç içe üç fonksiyon döndürdüğü curried bir yapıdır.
* getState ve dispatch: Middleware’in mevcut duruma erişmesini ve yeni action’lar dispatch etmesini sağlar.
* next: Zincirdeki bir sonraki middleware’i veya en sonunda reducer’ı temsil eden fonksiyondur.
* action: Dispatch edilen action nesnesidir.
Yaygın Middleware Kullanım Alanları:
1. Asenkron İşlemler: En yaygın kullanım alanıdır. API çağrıları, veritabanı etkileşimleri gibi zaman alan işlemleri yönetmek için kullanılır.
* Redux Thunk: Basit asenkron işlemler için popüler bir middleware’dir. Action creators’ın doğrudan bir action nesnesi döndürmek yerine bir fonksiyon döndürmesine izin verir. Bu fonksiyon, dispatch ve getState argümanlarını alarak asenkron mantığı yürütür ve tamamlandığında yeni action’lar dispatch eder.
* Redux Saga / Redux Observable: Daha karmaşık asenkron akışları ve yan etkileri yönetmek için kullanılır. Genellikle daha büyük ve karmaşık uygulamalarda tercih edilirler.
2. Loglama: Her action dispatch edildiğinde veya durum değiştiğinde konsola bilgi yazdırmak için kullanılır. Redux DevTools’un temelini oluşturur.
3. Hata Raporlama: Uygulamada bir hata oluştuğunda (örneğin bir API çağrısı başarısız olduğunda) hata raporlama servisine bilgi göndermek için kullanılabilir.
4. Yönlendirme (Routing): Bazı yönlendirme kütüphaneleri, yönlendirme durumunu Redux store’unda saklamak için middleware kullanır.
// Basit bir loglama middleware'i örneği
const loggerMiddleware = store => next => action => {
console.log('Dispatch edilen action:', action);
console.log('Önceki durum:', store.getState());
const result = next(action); // Action'ı bir sonraki middleware'e veya reducer'a gönder
console.log('Sonraki durum:', store.getState());
return result;
};
// Store oluşturulurken middleware'i uygulamak
import { createStore, applyMiddleware } from 'redux';
// const store = createStore(rootReducer, applyMiddleware(loggerMiddleware));
Redux Toolkit (RTK) ile Modern Redux
Redux, güçlü bir kütüphane olsa da, başlangıçta çok fazla “boilerplate” (tekrar eden kod) gerektirmesi ve belirli kurulum adımlarının karmaşık olabilmesi eleştirilerine maruz kalmıştır. Bu sorunları çözmek ve Redux geliştirme deneyimini iyileştirmek amacıyla Redux Toolkit (RTK) geliştirilmiştir.
Redux Toolkit, Redux ekibinin resmi olarak önerdiği ve en iyi uygulamaları teşvik eden, önceden yapılandırılmış bir araç setidir. RTK, Redux ile çalışmayı daha basit, daha verimli ve daha keyifli hale getirir.
Redux Toolkit’in Temel Özellikleri:
1. configureStore: createStore yerine geçer. Store’u oluşturmayı basitleştirir, Redux DevTools entegrasyonunu otomatik olarak yapar, Redux Thunk’ı varsayılan olarak ekler ve mutasyonları tespit eden bir middleware’i (immer ile) içerir.
2. createSlice: Reducer’ları, action creator’ları ve action type’larını tek bir yerde tanımlamanızı sağlar. Bu, boilerplate kodunu önemli ölçüde azaltır. createSlice, Immer kütüphanesini kullanarak reducer’ların içinde doğrudan durum mutasyonu yapar gibi kod yazmanıza olanak tanır, ancak arka planda değişmezliği otomatik olarak korur.
3. createAsyncThunk: Asenkron veri çekme işlemlerini (örneğin API çağrıları) yönetmek için standartlaştırılmış bir yol sunar. pending, fulfilled ve rejected action’larını otomatik olarak dispatch eder.
4. createEntityAdapter: Normalleştirilmiş durum (normalized state) yönetimini kolaylaştırır. Özellikle ID’ye göre erişilebilen koleksiyonları yönetmek için kullanışlıdır.
Redux Toolkit, Redux’ın temel prensiplerini ve bileşenlerini değiştirmez; aksine, bu prensipleri daha kolay ve daha az kodla uygulamanızı sağlar. Bu nedenle, Redux’ın temel kavramlarını anlamak, RTK’yı etkili bir şekilde kullanmak için hala çok önemlidir. RTK, temel kavramların üzerine inşa edilmiş bir soyutlama katmanıdır.
// Redux Toolkit ile basit bir sayac slice örneği
import { createSlice, configureStore } from '@reduxjs/toolkit';
const sayacSlice = createSlice({
name: 'sayac',
initialState: { sayi: 0 },
reducers: {
arttir: (state) => {
state.sayi += 1; // Immer sayesinde burada doğrudan mutasyon yapabiliriz
},
azalt: (state) => {
state.sayi -= 1;
},
belirliMiktarArttir: (state, action) => {
state.sayi += action.payload;
},
},
});
export const { arttir, azalt, belirliMiktarArttir } = sayacSlice.actions;
const store = configureStore({
reducer: {
sayac: sayacSlice.reducer,
},
});
console.log(store.getState().sayac.sayi); // 0
store.dispatch(arttir());
console.log(store.getState().sayac.sayi); // 1
store.dispatch(belirliMiktarArttir(5));
console.log(store.getState().sayac.sayi); // 6
Görüldüğü gibi, createSlice ile action type’larını manuel olarak tanımlamaya, action creator’ları yazmaya ve switch ifadeleri kullanmaya gerek kalmaz. RTK, Redux’ın gücünü korurken geliştirici deneyimini önemli ölçüde iyileştirir.
Redux Ne Zaman Kullanılmalı ve Ne Zaman Kullanılmamalı?
Redux güçlü bir araç olsa da, her uygulama için en iyi çözüm olmayabilir. Doğru araç seçimi, projenizin ihtiyaçlarına bağlıdır.
Redux Ne Zaman Kullanılmalı?
* Büyük ve Karmaşık Uygulamalar: Uygulamanızın durumu çok sayıda bileşen arasında paylaşılıyorsa ve bu durumun mantığı karmaşıksa.
* Global Durum Yönetimi: Uygulamanın birçok yerinden erişilmesi gereken global bir durumunuz varsa (örneğin, kullanıcı kimlik doğrulama bilgileri, tema ayarları, sepet içeriği).
* Öngörülebilirlik ve Hata Ayıklama İhtiyacı: Uygulamanın davranışının öngörülebilir olması ve kolayca hata ayıklanabilmesi kritikse.
* Birden Fazla Bileşenin Aynı Duruma Erişimi: Çok sayıda bileşen aynı durumu okumak veya güncellemek zorundaysa, Redux merkezi bir çözüm sunar.
* Asenkron İşlemlerin Yoğun Olduğu Uygulamalar: API çağrıları, web soketleri gibi asenkron işlemlerin durum üzerindeki etkilerini yönetmek karmaşık hale geldiğinde.
* Takım Çalışması: Büyük ekiplerde, Redux’ın yapılandırılmış yaklaşımı, durum yönetimini tutarlı hale getirir ve işbirliğini kolaylaştırır.
Redux Ne Zaman Kullanılmamalı?
* Küçük ve Basit Uygulamalar: Uygulamanızın durumu basit ve az sayıda bileşen arasında paylaşılıyorsa, Redux’ın ek karmaşıklığı gereksiz olabilir.
* Yalnızca Yerel Bileşen Durumu: Bileşenlerinizin çoğu kendi iç durumlarını yönetiyorsa ve bu durumlar diğer bileşenlerle nadiren paylaşılıyorsa, React’in useState ve useContext gibi yerleşik hook’ları yeterli olabilir.
* Öğrenme Eğrisi: Redux’ın kendine özgü kavramları (action, reducer, store, middleware vb.) bir öğrenme eğrisine sahiptir. Eğer projeniz çok küçükse ve zaman kısıtlıysa, bu öğrenme maliyeti ağır gelebilir.
* Alternatif Çözümlerin Yeterli Olduğu Durumlar: React Context API, Zustand, Jotai gibi daha hafif ve genellikle daha az boilerplate gerektiren alternatif durum yönetim kütüphaneleri, bazı senaryolarda Redux’a iyi birer alternatif olabilir.
Sonuç
Redux, modern JavaScript uygulamalarında durum yönetimi için güçlü ve kanıtlanmış bir çözümdür. Tek yönlü veri akışı, merkezi durum, salt okunur durum prensibi ve saf fonksiyonlarla durum değişikliklerinin yönetilmesi gibi temel prensipleri sayesinde, büyük ve karmaşık uygulamaların durumunu öngörülebilir, test edilebilir ve bakımı kolay bir şekilde yönetmenizi sağlar.
Action’lar, reducer’lar, store, dispatch ve middleware gibi temel bileşenleri anlamak, Redux’ın nasıl çalıştığını kavramanın anahtarıdır. Özellikle immutability prensibi, Redux’ın performans ve hata ayıklama yeteneklerinin temelini oluşturur.
Günümüzde Redux Toolkit, Redux’ı kullanmanın önerilen yoludur. Boilerplate kodunu azaltarak ve en iyi uygulamaları teşvik ederek geliştirme deneyimini önemli ölçüde iyileştirmiştir. Ancak, RTK’yı etkili bir şekilde kullanmak için bile, Redux’ın altında yatan temel kavramları anlamak vazgeçilmezdir.
Sonuç olarak, Redux, doğru senaryoda kullanıldığında, uygulamanızın durum yönetimini basitleştirecek ve geliştirme sürecinizi çok daha verimli hale getirecek değerli bir araçtır. Projenizin ihtiyaçlarını dikkatlice değerlendirerek Redux’ın sizin için doğru seçim olup olmadığına karar verebilirsiniz.
