როგორ მუშაობს React hooks-ები React Native-ში?

Question

IT Interview Practice · Accepted Answer

**Hooks** (useState, useEffect, useContext და სხვა) არის React-ის ფუნქციები, რომლებიც გამოიყენება state-ის და side effects-ის მართვისთვის functional components-ებში — და ისინი React Native-ში ზუსტად ისევე მუშაობს. ძირითადი hooks-ების გაცნობა სასიცოვნოა React Native components-ების აგებისთვის.

## useState — state

```jsx
const [count, setCount] = useState(0);     // state + setter; setting it re-renders
const [user, setUser] = useState(null);
```

## useEffect — side effects

```jsx
// useEffect runs side effects (data fetching, subscriptions) after render
useEffect(() => {
  fetchData();                  // runs after render
  // optional CLEANUP (returned function) — runs on unmount / before re-running
  const sub = subscribe();
  return () => sub.unsubscribe();   // CLEAN UP (prevent leaks)
}, [dependency]);                    // dependency array → when to re-run
// → [] = run once on mount; [dep] = run when dep changes; none = every render
```

`useEffect` მართავს side effects-ებს (მონაცემების ამოღება, subscriptions, timers) dependency array-ით, რომელიც აკონტროლებს, როდის გაშვებული იყოს ის, და opsional cleanup ფუნქციით (მნიშვნელოვანი leaks-ის თავიდან ასაცილებლად).

## სხვა მნიშვნელოვანი hooks-ები

```text
useContext → consume context (shared data without prop drilling)
useRef → a mutable reference that persists across renders (e.g. reference a component,
  store a value without re-rendering)
useMemo → memoize an expensive computed value (performance)
useCallback → memoize a function (avoid unnecessary re-creation/re-renders)
useReducer → manage complex state with a reducer
CUSTOM HOOKS → extract reusable stateful logic (e.g. useFetch, useAuth)
```

## hooks-ების წესები

```text
⚠️ Only call hooks at the TOP LEVEL of a component (not in conditions/loops/nested functions)
⚠️ Only call hooks from React components or custom hooks
→ These rules ensure hooks work correctly (React relies on call order).
```

## რატომ არის მნიშვნელოვანი

React hooks-ების გაცნობა სასიცოვნოა React Native-სთვის, რადგან **hooks-ები არის სტანდარტული გზა state-ის და side effects-ის მართვის შორ functional components-ებში**, რომლებითაც აგებული არის თანამედროვე React Native აპლიკაციები, ამიტომ ეს აუცილებელი ცოდნაა.

Hooks-ები ზუსტად იგივენაირად მუშაობს React Native-ში, როგორც ვებ React-ში, რაც ეს ცოდნას პირდაპირ გადაცემადი ხდის. **useState** (state-ის მართვა, re-renders-ის გამოწვევა) ფუნდამენტალური ია ნებისმიერი component-ისთვის, რომელსაც აქვს ცვლადი მონაცემები. **useEffect** განსაკუთრებით მნიშვნელოვანია: ის მართავს **side effects**-ებს (მონაცემების ამოღება, subscriptions, timers) dependency array-ით, რომელიც აკონტროლებს, როდის გაშვებული იყოს ის, და **opsional cleanup ფუნქციით** (გადამწყვეტი leaks-ის თავიდან ასაცილებლად unsubscribing-ით/გასუფთავებით) — useEffect-ის, მისი dependency array-ის და cleanup-ის გაცნობა სასიცოვნოა, რადგან side effects-ები (მაგალითად, მონაცემების ამოღება, როდესაც ეკრანი ჩაიტვირთება) ხშირი მოვლენაა და useEffect-ის არასწორი გამოყენება ბაგებს იწვევს (infinite loops-ები მცდარი dependencies-ებიდან, leaks-ები missing cleanup-ის გამო).

**სხვა მნიშვნელოვანი hooks-ების** გაცნობა — useContext (shared data-ს მოხმარება prop drilling-ის გარეშე), useRef (persistent mutable references), useMemo/useCallback (memoization performance-ის კეთხოვნით), useReducer (რთული state), და **custom hooks** (reusable stateful logic-ის ამოღება, როგორიცაა useFetch ან useAuth — code reuse-ის მძლავრი ნიმუში) — ფარავს toolkit-ს real components-ების აგებისთვის.

**hooks-ების წესების** გაცნობა (ისინი რომ იძახებული იყოს მხოლოდ top level-ზე და მხოლოდ components-ებიდან/custom hooks-ებიდან, რადგან React დამოკიდებელი ა call order-ზე) აუცილებელია subtle bugs-ების თავიდან ასაცილებლად.

যেკითხან hooks-ები არის სტანდარტული მექანიზმი state-ის და side effects-ის მართვის შორ თანამედროვე functional React Native components-ებში (და ცოდნა პირდაპირ React-დან გადაცემადი ია), და যეკითხან ძირითადი hooks-ების (განსაკუთრებით useState და useEffect მისი cleanup-ით) და წესების გაცნობა სასიცოვნოა სწორი components-ების აგებისთვის, React hooks-ების გაცნობა სასიცოვნო, ხშირად გამოყენებული React Native ცოდნა — ფუნდამენტალური თანამედროვე React Native components-ების აგებისთვის, ცენტრალური state-ის და side effects-ის მართვაში, და პირდაპირ გადაცემადი ვებ React-დან, ფუნდამენტალური skill React Native development-სთვის.

useState — state

useEffect — side effects

სხვა მნიშვნელოვანი hooks-ები

hooks-ების წესები

რატომ არის მნიშვნელოვანი

დაკავშირებული კითხვები