React Native Academy · Ders

Bağlam Performansı Sorunlarından Kaçınma

Bağlam Performansı Sorunlarından Kaçınma, CoddyKit'te ücretsiz bir React Native Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, React Native Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. React Native Academy kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

The Context Re-Render Problem

When the Context Provider re-renders with a new value, every component that calls useContext for that context re-renders, regardless of whether the specific part of the value they use has changed. In large apps with many consumers this can cascade into significant performance problems.

Diagnosing Unnecessary Context Re-renders

Use the React DevTools Profiler to identify components that re-render too often. Record an interaction that should only affect one part of the UI, then inspect which components highlighted in the flame chart. If components that only read one piece of context re-render when an unrelated piece changes, you have a performance problem.

The Inline Object Anti-Pattern

The most common source of unnecessary context re-renders is creating the value object inline in JSX. This creates a new object reference on every render of the Provider, which React treats as a changed value — even when the contents are identical — triggering a re-render cascade in all consumers.

// Bad: new object on every render
<MyContext.Provider value={{ user, logout }}>

// Good: stable reference with useMemo
const value = useMemo(() => ({ user, logout }), [user, logout]);
<MyContext.Provider value={value}>

Memoizing Context Values with useMemo

Wrap the context value object in useMemo inside the Provider. React will only create a new object (and thus notify consumers) when one of the listed dependencies changes. This is the simplest and most impactful fix for context performance issues.

function CartProvider({ children }) {
  const [items, setItems] = useState([]);

  const addItem = useCallback((item) => {
    setItems((prev) => [...prev, item]);
  }, []);

  const value = useMemo(() => ({
    items,
    addItem,
    total: items.reduce((sum, i) => sum + i.price, 0),
  }), [items, addItem]);

  return <CartContext.Provider value={value}>{children}</CartContext.Provider>;
}

Splitting Contexts for Independent Concerns

If your context holds both frequently changing values (e.g., cart item count) and rarely changing values (e.g., user profile), consumers that only need the stable data are forced to re-render whenever the volatile data changes. The fix is to split the context into two separate providers — one for each concern.

// Instead of one big UserContext:
export const UserDataContext = createContext(null);    // changes rarely
export const UserActionsContext = createContext(null); // changes rarely
export const CartItemsContext = createContext([]);     // changes often

// Consumers only subscribe to what they use

Separating State from Dispatch

A proven pattern is to split context into a state context and a dispatch context. Dispatch functions never change (useCallback or useReducer dispatch are stable), so components that only dispatch actions are never re-rendered by state changes. Only components reading state re-render when state changes.

export const AppStateContext = createContext(null);
export const AppDispatchContext = createContext(null);

function AppProvider({ children }) {
  const [state, dispatch] = useReducer(appReducer, initialState);

  return (
    <AppStateContext.Provider value={state}>
      <AppDispatchContext.Provider value={dispatch}>
        {children}
      </AppDispatchContext.Provider>
    </AppStateContext.Provider>
  );
}

React.memo Does NOT Help Context Consumers

A common mistake is wrapping context consumers in React.memo thinking it will prevent re-renders caused by context changes. It does not — React.memo only compares props, not context subscriptions. A component consuming context will always re-render when the context value changes, regardless of React.memo.

// React.memo does NOT prevent context-driven re-renders
const MyComponent = React.memo(() => {
  const { value } = useContext(MyContext);
  // Still re-renders every time MyContext changes
  return <Text>{value}</Text>;
});

// Solution: Split context or memoize the value in the Provider

Selector Pattern for Context

If you need granular subscriptions similar to Redux's useSelector, you can implement a simple selector pattern. A custom hook accepts a selector function and memoizes the selected value with useMemo. Re-renders only occur when the selected value changes, not the entire context.

function useCartTotal() {
  const { items } = useContext(CartContext);
  // Only recomputes when items changes
  return useMemo(
    () => items.reduce((sum, item) => sum + item.price, 0),
    [items]
  );
}

// Component only re-renders when the total number changes
function CartBadge() {
  const total = useCartTotal();
  return <Text>${total.toFixed(2)}</Text>;
}

Keeping Providers Lightweight

The Provider component itself should be as simple as possible. Move expensive computations out of the Provider render into useMemo or into the reducer. Avoid fetching data, running heavy transformations, or creating large objects inline inside the Provider JSX on every render.

Composition Over One Giant Context

Avoid the temptation to put all global app state in a single context. A better architecture uses many small, focused contexts: AuthContext for auth, ThemeContext for colors, CartContext for cart, NotificationContext for alerts. Each context re-renders only its own consumers, keeping the surface area of each re-render small and predictable.

// Architecture with focused contexts
export default function App() {
  return (
    <AuthProvider>
      <ThemeProvider>
        <CartProvider>
          <NotificationProvider>
            <AppContent />
          </NotificationProvider>
        </CartProvider>
      </ThemeProvider>
    </AuthProvider>
  );
}

When to Consider Zustand or Redux

If context performance optimizations become too complex — or if you find yourself building an elaborate selector system — consider switching to Zustand or Redux Toolkit. These libraries offer fine-grained subscriptions out of the box and are designed for large-scale state management. Context remains ideal for simple global values like theme, auth, and preferences.

Quick Check

Test your understanding of avoiding context performance issues from this lesson.

Lesson Recap

In this lesson you learned: inline value objects in Provider JSX cause unnecessary re-renders — use useMemo to stabilize them, split large contexts into focused smaller contexts to limit re-render scope, and separate state and dispatch into two contexts so action-only components never re-render on state changes. Next up we explore the useEffect hook and dependency arrays for data fetching.

Sıkça Sorulan Sorular

“Bağlam Performansı Sorunlarından Kaçınma” dersi ücretsiz mi?

Evet — “Bağlam Performansı Sorunlarından Kaçınma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve React Native Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. React Native Academy kursu toplamda 4 dersten oluşur.

“Bağlam Performansı Sorunlarından Kaçınma” dersinde ne öğreneceğim?

Bağlam değeri değişikliklerinin neden olduğu gereksiz yeniden oluşturmaları belirleyin, bağlamı birden çok sağlayıcıya ayırın ve performansı iyileştirmek için bağlam değerlerini önbelleğe alın. React Native Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

React Native Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te React Native Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Bağlam Performansı Sorunlarından Kaçınma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu React Native Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her React Native Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Bağlam Oluşturma ve Sağlama
useContext ile Bağlam Tüketme
Koyu Mod Açma-Kapamalı Tema Bağlamı
Bağlam Performansı Sorunlarından Kaçınma

← React Native Academy Sayfasına Dön