TypeScript กับ React



โปรเจกต์ React + TS: npm create vite@latest my-app -- --template react-ts

typing component props

interface ButtonProps {
  label: string;
  onClick: () => void;
  variant?: "primary" | "secondary";
  disabled?: boolean;
}

function Button({ label, onClick, variant = "primary", disabled = false }: ButtonProps) {
  return (
    <button className={`btn btn-${variant}`} onClick={onClick} disabled={disabled}>
      {label}
    </button>
  );
}

// ใช้งาน
<Button label="บันทึก" onClick={() => save()} variant="primary" />

อย่าใช้ React.FC (เดิมนิยม) — มันเพิ่ม children implicit ที่มักไม่ต้องการ และมีปัญหากับ generic; เขียน function Component(props: Props) ตรง ๆ

children

import { type ReactNode } from "react";

interface CardProps {
  title: string;
  children: ReactNode;   // อะไรก็ได้ที่ render ได้ (element, string, number, array, null)
}

function Card({ title, children }: CardProps) {
  return (
    <div className="card">
      <h2>{title}</h2>
      <div className="card-body">{children}</div>
    </div>
  );
}

<Card title="โปรไฟล์">
  <p>เนื้อหา...</p>
</Card>

ReactNode = renderable; ReactElement = JSX element เฉพาะ; (props) => ReactNode = render prop

useState

const [count, setCount] = useState(0);              // number (infer)
const [name, setName] = useState("");               // string
const [user, setUser] = useState<User | null>(null); // ต้องระบุ — null infer เป็น null

const [items, setItems] = useState<string[]>([]);   // [] infer เป็น never[]

setCount((prev) => prev + 1);                        // updater — prev: number
setUser({ id: 1, name: "อร" });
setUser(null);

ระบุ generic เมื่อ: initial เป็น null/[]/{} (infer แคบเกิน), หรือ type ต่างจาก initial

useRef — 2 กรณี

// 1. DOM ref
const inputRef = useRef<HTMLInputElement>(null);

useEffect(() => {
  inputRef.current?.focus();   // current: HTMLInputElement | null
}, []);

<input ref={inputRef} />

// 2. mutable value (ไม่ trigger re-render)
const renderCount = useRef(0);
renderCount.current += 1;

const timerRef = useRef<ReturnType<typeof setTimeout>>();
timerRef.current = setTimeout(() => {}, 1000);

event handlers

function Form() {
  const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
    event.preventDefault();
    const formData = new FormData(event.currentTarget);
    const email = formData.get("email");
  };

  const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
    console.log(event.target.value);   // string
  };

  const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
    console.log(event.clientX);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input name="email" onChange={handleChange} />
      <button onClick={handleClick}>ส่ง</button>
    </form>
  );
}

inline handler infer event type อัตโนมัติ:

<input onChange={(e) => setName(e.target.value)} />   // e: ChangeEvent<HTMLInputElement>

useReducer — typed ด้วย discriminated union

interface State {
  count: number;
  step: number;
}

type Action =
  | { type: "increment" }
  | { type: "decrement" }
  | { type: "setStep"; step: number }
  | { type: "reset" };

function reducer(state: State, action: Action): State {
  switch (action.type) {
    case "increment": return { ...state, count: state.count + state.step };
    case "decrement": return { ...state, count: state.count - state.step };
    case "setStep": return { ...state, step: action.step };   // action.step: number
    case "reset": return { count: 0, step: 1 };
    default: {
      const _exhaustive: never = action;
      return state;
    }
  }
}

function Counter() {
  const [state, dispatch] = useReducer(reducer, { count: 0, step: 1 });

  return (
    <>
      <p>{state.count}</p>
      <button onClick={() => dispatch({ type: "increment" })}>+</button>
      <button onClick={() => dispatch({ type: "setStep", step: 5 })}>step 5</button>
    </>
  );
}

dispatch type-safe — dispatch({ type: "setStep" }) error (ขาด step)

custom hook

function useLocalStorage<T>(key: string, initialValue: T) {
  const [value, setValue] = useState<T>(() => {
    const stored = localStorage.getItem(key);
    return stored ? (JSON.parse(stored) as T) : initialValue;
  });

  useEffect(() => {
    localStorage.setItem(key, JSON.stringify(value));
  }, [key, value]);

  return [value, setValue] as const;   // as const → tuple type
}

// ใช้งาน
const [theme, setTheme] = useLocalStorage<"light" | "dark">("theme", "light");

Context — typed

interface AuthContextValue {
  user: User | null;
  login: (email: string, password: string) => Promise<void>;
  logout: () => void;
}

const AuthContext = createContext<AuthContextValue | undefined>(undefined);

function useAuth(): AuthContextValue {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error("useAuth ต้องใช้ภายใน <AuthProvider>");
  }
  return context;   // narrow แล้ว — ไม่ใช่ undefined
}

function AuthProvider({ children }: { children: ReactNode }) {
  const [user, setUser] = useState<User | null>(null);
  // ...
  return <AuthContext.Provider value={{ user, login, logout }}>{children}</AuthContext.Provider>;
}

generic component

interface ListProps<T> {
  items: T[];
  renderItem: (item: T) => ReactNode;
  keyExtractor: (item: T) => string;
}

function List<T>({ items, renderItem, keyExtractor }: ListProps<T>) {
  return (
    <ul>
      {items.map((item) => (
        <li key={keyExtractor(item)}>{renderItem(item)}</li>
      ))}
    </ul>
  );
}

<List
  items={users}
  keyExtractor={(u) => u.id}
  renderItem={(u) => <span>{u.name}</span>}   // u: User infer
/>

เรื่องที่คนมักพลาด

  • ใช้ React.FC — เพิ่ม children ที่ไม่ต้องการ, มีปัญหากับ generic; ใช้ function C(props: Props)
  • useState([]) — infer never[]; useState<string[]>([])
  • useState(null) — infer null; useState<User | null>(null)
  • useRef DOM ref แล้วลืม ?.current — current เป็น T | null
  • custom hook return array ไม่มี as const — type เป็น (T | Dispatch<T>)[] แทน tuple
  • Context default null แล้วเข้าถึงตรง ๆ — undefined check ใน custom hook + throw
  • event handler ระบุ type element ผิด — MouseEvent<HTMLDivElement> เมื่อจริงเป็น button

สรุป

  • props: function Button(props: ButtonProps) — ไม่ใช้ React.FC; children: ReactNode
  • useState(0) infer; useState<User | null>(null) / useState<string[]>([]) — ระบุเมื่อ initial แคบเกิน
  • useRef<HTMLInputElement>(null) (DOM, ?.current) vs useRef(0) (mutable value)
  • event: React.ChangeEvent<HTMLInputElement>, React.FormEvent<HTMLFormElement>, React.MouseEvent<...> — inline handler infer เอง
  • useReducer + discriminated union Action — dispatch type-safe, exhaustive never check
  • custom hook: return [...] as const (tuple); Context: default undefined + custom hook ที่ throw
  • generic component: function List<T>({ items, renderItem }: ListProps<T>)

บทถัดไปว่าด้วย TypeScript กับ Express — typing Request/Response, middleware และ extend Request