Əsas məzmuna keç
FrontDepth, Ana səhifə

TypeScript

React komponentlərini tipləmək

React komponentlərini React 19-un tipləri ilə necə tipləmək olar: props, children və default dəyərlər, event handler-lər, useState, useRef və useReducer, ref-i prop kimi qəbul edən native element wrapper-ləri, generic komponentlər və yalnız müəyyən birləşmələrdə mənalı olan props.

JuniorMiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

Seçilmiş səviyyəyə qədər olan bölmələr göstərilir.

Bu mövzu Junior səviyyəsindən başlayır.

JuniorKonsepsiya

Props və children-in tipləri

Komponentin props-u bir obyektdir, ona görə onu istənilən obyekt kimi tipləyirsən: type alias və ya interface yazırsan və parametrə annotasiya qoyursan. Bundan sonra TypeScript komponentin istifadə olunduğu hər yeri yoxlayır. JSX atributları obyekt literalının xassələri kimi yoxlanır, ona görə çatışmayan, səhv yazılmış və ya tipi uyğun gəlməyən prop kompilyasiya xətası verir.

TSX
type BadgeProps = {
  label: string;
  tone?: "neutral" | "success" | "danger";
  count?: number;
};

function Badge({ label, tone = "neutral", count }: BadgeProps) {
  return (
    <span className={`badge badge-${tone}`}>
      {label}
      {count !== undefined && <b>{count}</b>}
    </span>
  );
}

<Badge label="New" />;
// Xəta: 'label' xassəsi yoxdur
<Badge />;
// Xəta: "warn" tone dəyərlərindən biri deyil
<Badge label="New" tone="warn" />;
// Xəta: BadgeProps-da 'colour' yoxdur
<Badge label="New" colour="red" />;

? prop-u məcburi olmayan (optional) edir. Komponentin içində onun tipinə undefined da daxil olur (count number | undefined-dir), ona görə TypeScript prop-un verilmədiyi halı da nəzərə almağa məcbur edir. Destructuring-dəki default dəyər undefined-i aradan qaldırır: yuxarıdakı tone sadəcə union-dır. React 19 funksiya komponentləri üçün defaultProps-u ləğv edib, ona görə default dəyərlər destructuring-də verilir. Default yalnız dəyər undefined olanda işləyir; null kimi ötürülən prop isə null qalır.

Props üçün həm type, həm də interface yararlıdır; kod bazası üçün birini seç. Qaytarılan tipi nadir hallarda yazırsan: TypeScript onu özü . React.FC<Props> də məcburi deyil. O, funksiyanı tipləyir, amma React 18 tiplərindən bəri props-a children əlavə etmir.

children

children adi prop-dur və onu özün yazırsan. Adətən onun tipi ReactNode-dur: React-in render edə bildiyi hər şey, məsələn, elementlər, sətirlər, ədədlər, boolean-lar, null, undefined və bunlardan ibarət massivlər.

TSX
import type { ReactNode } from "react";

type CardProps = {
  title: string;
  children: ReactNode;
};

function Card({ title, children }: CardProps) {
  return (
    <section>
      <h2>{title}</h2>
      {children}
    </section>
  );
}

ReactElement daha dardır: yalnız JSX elementləri, ona görə onunla <Card>Text</Card> xəta verərdi. Heç biri "yalnız <li> elementləri" deyə bilməz: react.dev qeyd edir ki, TypeScript children-i müəyyən növ JSX elementi kimi təsvir edə bilmir. PropsWithChildren<P> P-yə məcburi olmayan children?: ReactNode əlavə edir, style prop-u isə React.CSSProperties qəbul edir.

JuniorKonsepsiya

Event handler-lərin tipləri

Handler-i inline yazanda event-in tipini ümumiyyətlə yazmırsan: TypeScript <input>-un onChange prop-unun tipini bilir və onu parametrə verir.

TSX
function TaskTitle() {
  const [title, setTitle] = useState("");
  // e: React.ChangeEvent<HTMLInputElement>
  return <input value={title} onChange={(e) => setTitle(e.target.value)} />;
}

Handler-i adlı funksiyaya çıxaranda bu kontekst itir. strict rejimində tipsiz parametr implicit any xətası verir, ona görə ona annotasiya yazırsan. react.dev-in məsləhəti: redaktorda kursoru prop-un (onChange) üzərinə gətir və onun hansı event tipini gözlədiyinə bax.

TSX
function handleChange(event: React.ChangeEvent<HTMLInputElement>) {
  console.log(event.target.value);
}

// və ya bütün funksiyanı handler tipi ilə tiplə
const handleKeyDown: React.KeyboardEventHandler<HTMLInputElement> = (event) => {
  if (event.key === "Escape") event.currentTarget.blur();
};

Gündəlik işdə ən çox lazım olanlar ChangeEvent (input, select, textarea), MouseEvent, KeyboardEvent və FocusEvent-dir. onSubmit üçün cari tiplər SubmitEvent<HTMLFormElement> istifadə edir; köhnə FormEvent hələ kompilyasiya olunur, amma deprecated kimi işarələnib. Tip parametri handler-in bağlandığı elementdir. Bunlar React-in tipləridir: onları react-dən import et və ya React.MouseEvent yaz. Sadəcə MouseEvent DOM-un öz tipidir və onunla tiplənmiş handler onClick-ə uyğun gəlmir.

target, yoxsa currentTarget

currentTarget handler-in bağlandığı elementdir və məhz o elementin tipini daşıyır. target isə event-in başladığı yerdir, bu, uşaq element də ola bilər, ona görə klikdə onun tipi sadəcə EventTarget-dir:

TSX
function handleClick(event: React.MouseEvent<HTMLButtonElement>) {
  // Xəta: 'EventTarget' tipində 'disabled' yoxdur
  event.target.disabled = true;
  event.currentTarget.disabled = true;
}

Change event-ləri istisnadır: onların target-i form elementi kimi tiplənib, ona görə onChange-də e.target.value işləyir. Digər hallarda event.target as HTMLButtonElement kimi cast əvəzinə currentTarget-dən istifadə et.

Callback props

Komponentin öz event prop-ları DOM event-lərini yox, dəyərləri ötürməlidir. AddTaskForm-un valideyninə başlıq lazımdır:

TSX
type AddTaskFormProps = {
  onAdd: (title: string) => void;
};

function AddTaskForm({ onAdd }: AddTaskFormProps) {
  const [title, setTitle] = useState("");

  function handleSubmit(event: React.SubmitEvent<HTMLFormElement>) {
    event.preventDefault();
    onAdd(title.trim());
    setTitle("");
  }

  return (
    <form onSubmit={handleSubmit}>
      <input value={title} onChange={(e) => setTitle(e.target.value)} />
      <button type="submit">Add</button>
    </form>
  );
}
JuniorKonsepsiya

useState: tipin çıxarılması, union-lar və null

useState tipini ilkin dəyərdən götürür: useState(0) number, useState("") string, useState(false) isə boolean saxlayır. İlkin dəyər state-in nə saxlaya biləcəyini artıq göstərirsə, bu kifayətdir. Göstərmədiyi üç tipik hal:

TSX
const [user, setUser] = useState(null);
// Xəta: 'User' tipi 'SetStateAction<null>'-a mənimsədilə bilməz
setUser(currentUser);

const [tags, setTags] = useState([]);
// Xəta: 'string' tipi 'never'-ə mənimsədilə bilməz
setTags(["sale"]);

const [status, setStatus] = useState("idle");
// Xəta yoxdur: status istənilən sətirdir, hərf səhvi də daxil
setStatus("svaed");

Tipi tip arqumenti kimi ötür:

TSX
const [user, setUser] = useState<User | null>(null);
const [tags, setTags] = useState<string[]>([]);
const [status, setStatus] = useState<"idle" | "saving" | "saved">("idle");

User | null olanda TypeScript istifadədən əvvəl yoxlamağa məcbur edir: user?.name və ya erkən if (!user) return <SignInLink />. Bu, deməkdir. İlkin dəyəri olmayan tip arqumenti, useState<User>(), User | undefined verir.

Yoxlamadan yayınmaq üçün yalan danışma: useState<User>({} as User) kompilyasiya olunur, amma data gələnə qədər user.name undefined-dir və tip artıq səni xəbərdar etmir.

Bayraqları yox, vəziyyətləri modelləşdir

Ayrı-ayrı boolean-lar komponentin mənasız vəziyyətlərə düşməsinə imkan verir: error təyin olunduğu halda isLoading, və ya xəta ilə yanaşı data. eyni anda yalnız bir vəziyyət saxlayır və TypeScript-ə hər vəziyyətdə hansı sahələrin olduğunu bildirir:

TSX
type ProfileState =
  | { status: "loading" }
  | { status: "error"; message: string }
  | { status: "ready"; user: User };

function Profile() {
  const [state, setState] = useState<ProfileState>({ status: "loading" });

  if (state.status === "loading") return <p>Loading...</p>;
  if (state.status === "error") return <p role="alert">{state.message}</p>;
  return <h1>{state.user.name}</h1>;
}

Hər yoxlamadan sonra TypeScript state-i daraldır: state.message yalnız xəta budağında, state.user isə yalnız sonuncu budaqda mövcuddur. Yeniləmələr də yoxlanır: user olmadan setState({ status: "ready" }) kompilyasiya olunmur, ona görə komponent göstərəcək heç nə olmadan "ready" vəziyyətinə keçə bilmir.

JuniorKonsepsiya

useRef: DOM node-ları və dəyişkən dəyərlər

useRef-in iki işi var və tip məhz hansı iş üçün istifadə olunduğundan asılıdır.

DOM node-u. null ilə başla və elementin tipini yaz. React commit-dən sonra current-ə node-u yazır, element silinəndə isə onu yenidən null edir, ona görə tip HTMLInputElement | null-dur və TypeScript səni onu yoxlamağa məcbur edir:

TSX
function TaskFilter() {
  const inputRef = useRef<HTMLInputElement>(null);

  function focusInput() {
    // Xəta: 'inputRef.current' 'null' ola bilər
    inputRef.current.focus();
    inputRef.current?.focus();
  }

  return (
    <>
      <input ref={inputRef} />
      <button onClick={focusInput}>Filter</button>
    </>
  );
}

Elementin tipi ref-in bağlandığı yerə uyğun olmalıdır: <input ref={...}>-ə ötürülən useRef<HTMLDivElement>(null) tip xətasıdır.

Dəyişkən dəyər: render-lər arasında qalan, amma yeni render-ə səbəb olmayan dəyər, məsələn, taymerin id-si. Onun tipi ilkin dəyərdən və ya tip arqumentindən gəlir:

TSX
function CopyButton({ text }: { text: string }) {
  const [copied, setCopied] = useState(false);
  const hideTimer = useRef<number | null>(null);

  async function copy() {
    await navigator.clipboard.writeText(text);
    setCopied(true);
    if (hideTimer.current !== null) window.clearTimeout(hideTimer.current);
    hideTimer.current = window.setTimeout(() => setCopied(false), 2000);
  }

  return <button onClick={copy}>{copied ? "Copied" : "Copy"}</button>;
}

window.setTimeout number qaytarır. @types/node yüklənibsə, sadəcə setTimeout isə Node-un Timeout obyektini qaytarır, ona görə ortaq kodda çox vaxt ReturnType<typeof setTimeout> yazılır. current-i dəyişmək heç vaxt render-ə səbəb olmur: dəyər ekranda görünməlidirsə, onun yeri state-dir.

React 19-un tiplərində nə dəyişdi

  • useRef arqument tələb edir. useRef<HTMLDivElement>() xətadır ("Expected 1 argument"); useRef<HTMLDivElement>(null) yaz, boş başlayan dəyər üçün isə useRef<number>(undefined).
  • Yalnız bir RefObject<T> var və current həmişə yazıla biləndir. Köhnə tiplərdə useRef<number>(null) yalnız oxunan ref verirdi; MutableRefObject indi deprecated-dir.
  • Ref callback-i cleanup funksiyası qaytara bilər, başqa heç nə. ref={(node) => (instance = node)} node-u qaytarır, ona görə artıq kompilyasiya olunmur; arrow funksiyaya blok gövdə ver: ref={(node) => { instance = node; }}.
MiddleKonsepsiya

Action union-ları ilə useReducer və tiplənmiş context

State-in bir neçə hissəsi birlikdə dəyişəndə useReducer keçidləri bir funksiyaya toplayır. Action-ları kimi tiplə: hər action-ın literal type-ı və yalnız ona lazım olan sahələri olur.

TSX
type Line = { id: string; qty: number };
type CartAction =
  | { type: "added"; id: string }
  | { type: "removed"; id: string }
  | { type: "cleared" };

function cartReducer(lines: Line[], action: CartAction): Line[] {
  switch (action.type) {
    case "added":
      return lines.some((l) => l.id === action.id)
        ? lines.map((l) => (l.id === action.id ? { ...l, qty: l.qty + 1 } : l))
        : [...lines, { id: action.id, qty: 1 }];
    case "removed":
      return lines.filter((l) => l.id !== action.id);
    case "cleared":
      return [];
    default: {
      const unhandled: never = action;
      throw new Error(`Unknown action: ${JSON.stringify(unhandled)}`);
    }
  }
}

function Cart() {
  const [lines, dispatch] = useReducer(cartReducer, []);
  return <button onClick={() => dispatch({ type: "cleared" })}>Clear ({lines.length})</button>;
}

Hər case-in içində TypeScript action-ı daraldır: action.id "added" və "removed"-də var, "cleared"-də yoxdur. dispatch da yoxlanır: id-siz dispatch({ type: "removed" }) xətadır, səhv yazılmış type da. never-ə mənimsətmə tamlıq (exhaustiveness) yoxlamasıdır: dördüncü action əlavə edib onun case-ini unutsan, bu sətir kompilyasiya olunmaz. throw yenə də lazımdır: JSON.parse ilə bərpa olunan action datada nə yazılıbsa, odur.

React 19-un tipləri state və action tiplərini reducer-dən çıxarır, react.dev-in upgrade guide-ı isə useReducer-ə tip arqumenti ötürməməyi tövsiyə edir: bunun əvəzinə reducer-in parametrlərinə annotasiya yaz. Mütləq lazımdırsa, forma indi useReducer<State, [Action]>-dir; köhnə useReducer<React.Reducer<State, Action>> artıq kompilyasiya olunmur.

Tiplənmiş context

createContext tipini default dəyərdən götürür. Mənalı default olmayanda, məsələn, daxil olmuş istifadəçinin sessiyası üçün, tipə null əlavə et və useContext-i xəta atan hook-a bük ki, istifadəçilər heç vaxt null olmayan dəyər alsın:

TSX
type Session = { user: User; signOut: () => void };

const SessionContext = createContext<Session | null>(null);

export function useSession(): Session {
  const session = useContext(SessionContext);
  if (session === null) throw new Error("useSession must be used inside <SessionProvider>");
  return session;
}

export function SessionProvider({ session, children }: { session: Session; children: ReactNode }) {
  return <SessionContext value={session}>{children}</SessionContext>;
}

React 19-da context-in özü provider kimi render olunur. Provider-dən kənardakı komponent isə dərhal aydın mesajla dayanır.

MiddleFramework

Native elementləri bükmək: ComponentProps və prop kimi ref

Dizayn sisteminin Button-u <button>-un qəbul etdiyi hər şeyi (type, disabled, aria-*, onClick...) əl ilə sadalamadan qəbul etməlidir. ComponentProps<"button"> məhz bu siyahıdır, React-in JSX tiplərindən götürülür.

TSX
import type { ComponentProps } from "react";

type ButtonProps = ComponentProps<"button"> & {
  variant?: "primary" | "ghost";
};

export function Button({ variant = "primary", className, ...rest }: ButtonProps) {
  return <button {...rest} className={`btn btn-${variant} ${className ?? ""}`} />;
}

İstifadə etdiyin props-u destructuring ilə götür, qalanını elementə spread et; children, handler-lər və atributlar ötürülür və istifadə yerində yoxlanır (<Button type="sumbit"> xətadır). İcra zamanı sıra vacibdir: {...rest}-dən sonrakı atributlar çağıranın dəyərlərini əvəz edir, ondan əvvəlkilər isə çağıranın əvəz edə biləcəyi default-lardır, hətta açıq undefined ilə də.

React 19-da ref prop-dur

Funksiya komponenti indi ref-i digər prop-lar kimi alır və ComponentProps<"button"> onu da əhatə edir, ona görə yuxarıdakı spread çağıranın ref-ini artıq <button>-a ötürür. react.dev: forwardRef artıq lazım deyil və gələcək buraxılışda deprecated olacaq. Ref daxili elementə aiddirsə, onu özün elan et:

TSX
type TextFieldProps = Omit<ComponentProps<"input">, "ref"> & {
  label: string;
  ref?: Ref<HTMLInputElement>;
};

function TextField({ label, id, ref, ...rest }: TextFieldProps) {
  const generatedId = React.useId();
  const inputId = id ?? generatedId;
  return (
    <div className="field">
      <label htmlFor={inputId}>{label}</label>
      <input id={inputId} ref={ref} {...rest} />
    </div>
  );
}

Hansı köməkçi tip nə vaxt:

  • ComponentProps<"input"> (elementlər üçün ComponentPropsWithRef ilə eynidir) ref-i də əhatə edir. Qalan props, ref də daxil, həmin elementə düşəndə bundan istifadə et.
  • ComponentPropsWithoutRef<"input">-da ref yoxdur. Komponent ref-i həmin elementə qoymayanda bundan istifadə et ki, çağıran heç yerə getməyən ref ötürə bilməsin.
  • ComponentProps<typeof DatePicker> mövcud komponentin props-unu verir; kitabxana props tipini export etməyəndə əlverişlidir.

Native prop-u dəyişmək: əvvəlcə Omit

Native prop-a başqa tip vermək üçün öz tipini əlavə etməzdən əvvəl onu çıxar. Sadə intersection hər ikisini saxlayır və onChange eyni anda həm React change handler-i, həm də (value: string) => void olmalı olardı:

TSX
type SelectProps = Omit<ComponentProps<"select">, "value" | "onChange"> & {
  value: string;
  onChange: (value: string) => void;
};

TypeScript adı düzgün identifikator olmayan JSX atributlarını yoxlamır, ona görə data-testid elan olunmadan istənilən komponentdən keçir.

MiddleTipik səhvlər

Bug-ları gizlədən qaçış yolları

React kodundakı tip xətalarının çoxunun düzgün həlli və tez bir qaçış yolu olur. Qaçış yolu kompilyasiya olunur, bug isə icra vaxtına keçir.

Yalan danışan placeholder state.

TSX
function Greeting() {
  const [user, setUser] = useState<User>({} as User);
  // Kompilyasiya olunur, sonra xəta atır: data gələnə qədər user.name undefined-dir
  return <p>Hello, {user.name.toUpperCase()}</p>;
}

{} as User (və ya null!) TypeScript-ə istifadəçinin artıq mövcud olduğunu deyir. State-i User | null kimi tiplə və olmayan halı da render et.

Ref-də !. inputRef.current!.focus() node-un mövcud olduğunu iddia edir. Bu, komponent mount olunduqdan sonra həmişə render olunan element üçün doğrudur, şərtin arxasındakı element üçün isə yox. inputRef.current?.focus() cəmi bir simvol artıqdır.

Event target-i cast etmək. Klik handler-indəki (event.target as HTMLInputElement).value klik düymənin içindəki ikonadan başlayanda da kompilyasiya olunur. event.currentTarget isə handler-in bağlandığı elementin tipini daşıyır.

Event və props üçün any. (e: any) => ... bütün handler üçün yoxlamanı söndürür, props: any isə bütün komponent üçün. Bunun əvəzinə kursoru prop-un üzərinə gətir və event tipinə bax.

Qlobal JSX namespace-i. React 19-un tipləri artıq qlobal JSX elan etmir, ona görə JSX.Element qaytarma tipi "Cannot find namespace 'JSX'" xətası verir. React.JSX.Element yaz və ya qaytarma tipini TypeScript-in özünə burax. JSX.IntrinsicElements-dəki custom element elanları react və ya JSX runtime modulu üçün declare module blokuna köçür.

Ref callback-lərində implicit return. ref={(node) => (instance = node)} node-u qaytarır, React 19-un tipləri isə qaytarılan dəyər kimi yalnız cleanup funksiyasına icazə verir. Blok gövdədən istifadə et.

Elementin props-unu oxumaq. ReactElement["props"] indi any yox, unknown-dur, ona görə children.props.title oxuyan kod kompilyasiya olunmur. Bunun əvəzinə datanı props kimi ötür, elementləri həqiqətən yoxladığın yerdə isə elementə tip arqumenti ver (ReactElement<{ title: string }>).

JSX-in üstündə @ts-ignore. O, növbəti sətirdəki bütün xətaları susdurur, hələ heç kimin görmədiyi xətaları da. Qaçış yolu labüddürsə, səbəbi yazılmış @ts-expect-error heç olmasa xəta aradan qalxanda özü xəta verir.

SeniorKonsepsiya

Generic komponentlər

Siyahı, cədvəl və ya seçici istənilən element tipi ilə işləyir, amma hər istifadədə elementlərlə callback-lər arasındakı əlaqə qorunmalıdır: elementlər məhsuldursa, renderItem məhsul almalıdır. Funksiya komponenti funksiyadır, ona görə komponent də generic funksiya kimi işləyir.

TSX
import type { Key, ReactNode } from "react";

type ListProps<T> = {
  items: readonly T[];
  getKey: (item: T) => Key;
  renderItem: (item: T) => ReactNode;
  emptyText?: string;
};

export function List<T>({ items, getKey, renderItem, emptyText = "Nothing here" }: ListProps<T>) {
  if (items.length === 0) return <p>{emptyText}</p>;
  return (
    <ul>
      {items.map((item) => (
        <li key={getKey(item)}>{renderItem(item)}</li>
      ))}
    </ul>
  );
}

<List items={products} getKey={(p) => p.sku} renderItem={(p) => `${p.title}: ${p.price}`} />;
// Xəta: məhsul tipində 'name' xassəsi yoxdur
<List items={products} getKey={(p) => p.sku} renderItem={(p) => p.name} />;

T istifadə yerində items-dən çıxarılır və callback-lər ona qarşı yoxlanır. Çıxarmağa heç nə olmayanda, məsələn, boş massiv literalında, tip arqumentini JSX-də ötür: <List<Product> items={[]} ... />. readonly T[] as const massivləri də qəbul edir. Məhdudiyyətlər (constraint) funksiyalardakı kimi işləyir: function Table<T extends { id: string }> row.id-ni key kimi işlədə bilər və id-si olmayan sətirləri qəbul etmir.

.tsx fayllarında arrow funksiyalar

.tsx faylında arrow funksiyanın qarşısındakı <T> JSX teqi kimi oxunur. <T,> yaz və ya funksiya elanından istifadə et:

TSX
export const Grid = <T,>({ items }: { items: T[] }) => <div>{items.length}</div>;

Generic komponentlər və ref-lər

forwardRef tip parametrini saxlamır: generic komponenti ona bükəndə istifadə yerində T unknown olur, köhnə kodda onun ətrafında cast-ların yazılmasının səbəbi də budur. React 19-da ref prop olduğu üçün komponent ref?: Ref<HTMLUListElement>-i digər prop-lar kimi elan edir və generic qalır.

Nə vaxt lazım deyil

Tip parametri ən azı iki yeri bir-birinə bağlamalıdır. T yalnız items: T[]-də görünürsə və heç nə elementi çağırana geri vermirsə, items: unknown[] və ya konkret tip eyni şeyi daha az səs-küylə deyir. Generic komponentlər həm də daha uzun xəta mesajları yaradır, ona görə onları həqiqətən ortaq istifadə olunan baza komponentləri üçün saxla.

SeniorNümunə

Bir-birindən asılı props

Bəzi props yalnız birlikdə mənalıdır: düymə ya link (href), ya da əməliyyatdır (onClick); modal ya idarə olunandır (open və onClose), ya da yox (defaultOpen). Hər şey üçün optional props istənilən qarışığa, o cümlədən "hər ikisi" və "heç biri" variantlarına icazə verir. isə yalnız düzgün birləşmələri sadalayır:

TSX
type ActionProps =
  | { as: "link"; href: string; children: ReactNode }
  | { as: "button"; onClick: () => void; children: ReactNode };

function Action(props: ActionProps) {
  if (props.as === "link") return <a href={props.href}>{props.children}</a>;
  return (
    <button type="button" onClick={props.onClick}>
      {props.children}
    </button>
  );
}

<Action as="link" href="/pricing">Pricing</Action>;
// Xəta: button variantında 'href' yoxdur
<Action as="button" href="/pricing" onClick={track}>Pricing</Action>;

Narrowing props.as üzərində işləyir. Parametr siyahısında destructuring-dən sonra da işləyir, bir şərtlə ki, destructuring edilən hər xassə bütün üzvlərdə olsun və dəyişənlərə yenidən dəyər mənimsədilməsin (TypeScript 4.6 və sonrakı versiyalar): { kind: "text"; value: string } | { kind: "number"; value: number } olanda kind yoxlaması value-nu daraldır. ...rest obyekti isə daralmır, ona görə qalanını spread edən komponent destructuring-dən əvvəl props.as-ı yoxlayır.

Discriminant-sız union-lar müstəsna deyil

TypeScript union-ın bir üzvünə uyğun gələn props-u, onlarda başqa üzvün props-u olsa belə, qəbul edir:

TSX
type ModalProps =
  | { open: boolean; onClose: () => void }
  | { defaultOpen: boolean };
declare function Modal(props: ModalProps): ReactNode;

// Kompilyasiya olunur: birinci üzv uyğun gəlir, defaultOpen isə yanında gəlir
<Modal open onClose={closeModal} defaultOpen />;

Qarışığı digər üzvün açarları üçün ?: never ilə qadağan et:

TSX
type ModalProps =
  | { open: boolean; onClose: () => void; defaultOpen?: never }
  | { defaultOpen: boolean; open?: never; onClose?: never };

İndi eyni JSX xəta verir. Bu üsul bayraqdan asılı dəyəri də tipləyir: { multiple?: false; value: string } | { multiple: true; value: string[] }.

Qiyməti

Omit<ActionProps, "children"> hər üzv üçün ayrıca işləmir: union üzərində Omit yalnız bütün üzvlərdə ortaq olan açarları saxlayır, ona görə href və onClick yox olur. Belə komponenti bükmək üçün distributiv versiya lazımdır: T extends unknown ? Omit<T, K> : never (union üzərində paylanan ). Xəta mesajları da böyüyür. Union-lardan yanlış birləşmənin real bug olacağı yerdə istifadə et, hər cüt prop üçün yox.

SeniorMüsahibə məsləhətləri

Müsahibə üçün məsləhətlər

30 saniyəlik cavab. "Props-u obyekt tipi kimi tipləyirəm, qalanını isə TypeScript-in özü çıxarır: inline handler-lər event tipini prop-dan, useState ilkin dəyərdən, useReducer isə reducer-dən alır. TypeScript-in özünün bilə bilmədiyi yerlərdə tip əlavə edirəm: useState<User | null>(null), useRef<HTMLInputElement>(null), JSX-dən çıxarılmış handler-lər. Native elementlərin wrapper-ləri ComponentProps<"button"> qəbul edir və React 19-da ref-i prop kimi alır. Yalnız müəyyən birləşmələrdə mənalı olan props üçün discriminated union, təkrar istifadə olunan siyahılar üçün isə generic komponent yazıram."

Gözlənilən suallar

  • Children üçün ReactNode, ReactElement, yoxsa JSX.Element? Render oluna bilən hər şey üçün ReactNode, yalnız JSX elementləri üçün ReactElement; JSX.Element JSX ifadəsinin tipidir (React 19-un tiplərində React.JSX.Element).
  • JSX-dən çıxarılmış onChange handler-ini necə tipləyirsən? Parametr üçün React.ChangeEvent<HTMLInputElement>, funksiya üçün isə React.ChangeEventHandler<HTMLInputElement>. target ilə currentTarget fərqini də əlavə et.
  • React 19-un tiplərində nə dəyişdi? useRef arqument tələb edir və bütün ref-lər dəyişkəndir; ref callback-ləri yalnız cleanup qaytarır; qlobal JSX yoxdur; ReactElement-in props-u default halda unknown-dur; useReducer tipləri reducer-dən çıxarır; ref prop-dur, ona görə forwardRef artıq lazım deyil.
  • Bütün native props-u qəbul edən Button-u necə tipləyərdin? ComponentProps<"button"> üstəgəl öz props-un, dəyişdiyin props üçün Omit, qalanı isə elementə spread olunur.
  • İki prop-u bir-birini istisna edən necə edirsən? Discriminated union ilə, discriminant yoxdursa, ?: never ilə.
  • Generic Select<T>-ni necə tipləyirsən? Generic funksiya komponenti kimi; .tsx-dəki arrow funksiyalarda <T,>-ni və forwardRef-in T-ni itirdiyini qeyd et.

Bal itirdən səhvlər

  • Xətaları as, ! və ya any ilə susdurmaq, xüsusən useState({} as User).
  • React.FC-nin məcburi olduğunu və ya children əlavə etdiyini demək (React 18 tiplərindən bəri əlavə etmir).
  • Tipləri icra zamanı yoxlaması saymaq: API cavabından doldurulan prop cavabın özü qədər düzgündür. Tiplər datanı təsvir edir, onu yoxlamır.

Senior səviyyəni göstərən məqamlar

Sintaksisdən çox kompromislərdən danış: annotasiyalar əvəzinə tipin çıxarılması, yalnız yanlış birləşmənin real bug olduğu yerdə union-lar, yalnız ortaq baza komponentləri üçün generic komponentlər və dizayn sistemində native props-u, ref-ləri və əlçatanlıq atributlarını ötürən wrapper tipləri. Tip yoxlamasının harada dayandığını bildiyini göstər: datanın tətbiqə daxil olduğu sərhəddə.

JuniorYoxlama siyahısı

Tiplənmiş React komponentlərini review edərkən nəyi yoxlamalı

Yazmadığın tiplənmiş React kodunu — komanda yoldaşının pull request-ini, kitabxananın nümunəsini və ya AI assistentin təklifini — review edəndə bu siyahıdan istifadə et. Yalan danışan tip düzgün tip qədər rahat kompilyasiya olunur, ona görə bu bug-lar sonra üzə çıxır: gec gələn datada çökmə və ya heç kimin nəzərə almadığı prop birləşməsi kimi.

  • Tip yoxlaması strict aktiv olanda və yeni any, as, ! və ya @ts-ignore olmadan keçirmi? Layihənin tip yoxlamasını (tsc --noEmit) işə sal: tipləri sadəcə silən bundler tip xətaları olan kodu da build edir. Hər qaçış yolunun səbəbi olmalıdır; useState({} as User) və ref.current! üçün adətən tiplənmiş həll var.
  • null, [] və ya sətir literalı ilə başlayan hər useState-in real dəyərləri əhatə edən tip arqumenti varmı? useState(null) heç vaxt null-dan başqa heç nə saxlaya bilməz, useState([]) never[]-dir, useState("idle") isə union nəzərdə tutulan yerdə istənilən sətri qəbul edir.
  • Ref-lər bağlandıqları elementin tipi ilə tiplənib və istifadədən əvvəl yoxlanırmı? useRef<HTMLInputElement>(null) <input>-a bağlanır, handler-lər isə ?. və ya açıq yoxlamadan istifadə edir; arqumentsiz useRef() React 19-un tipləri ilə kompilyasiya olunmur.
  • JSX-dən çıxarılmış handler-lər React-in event tipləri ilə tiplənib və currentTarget-i oxuyurmu? DOM-un MouseEvent-i və ya any yox, React.MouseEvent<HTMLButtonElement>; event.target-in cast-ı uşaq elementdən başlayan klikləri gizlədir.
  • Native element wrapper-ləri qalan props-u və ref-i ötürür, dəyişdirilən props üçün isə Omit istifadə edirmi? ...rest-in elementə çatdığını, ComponentProps ilə tiplənmiş komponentin ref-i həqiqətən haradasa yerləşdirdiyini və dəyişdirilən value və ya onChange-in əvvəlcə native props-dan çıxarıldığını yoxla.
  • Props komponentin nəzərə almadığı birləşməni ifadə edə bilirmi? Şübhəli istifadə yerini yaz, məsələn, onClick ilə href və ya defaultOpen ilə open; kompilyasiya olunursa və komponent bunun yarısına məhəl qoymursa, discriminated union və ya ?: never çatışmır.
  • Hər reducer-in switch-i never yoxlaması ilə bitirmi? Öz kompüterində action union-ına saxta üzv əlavə et: reducer yenə kompilyasiya olunursa, yeni action səssizcə nəzərə alınmayacaq.

Özünü yoxla

  • Məşq

    Kodun nəticəsini təxmin et, açıq müsahibə suallarına cavab ver və özünü qiymətləndir.

    3 nəticə sualı · 4 açıq sual

  • Quiz

    İzahlı test sualları və yekun nəticə.

    7 sual