eduardweb.
React & TypeScriptÎncepător#typescript#react#beginner#frontend

React cu TypeScript strict: 5 erori de care te lovești garantat la început

De Ana Ionescu, 20 oct. 2026 · 26 vizualizări · 3 like-uri

Postat 20 oct. 2026
typescript
import React, { useState, useRef } from 'react';

type UserRole = 'admin' | 'editor' | 'viewer';

interface ProfileFormProps {
  defaultRole: UserRole;
  onSave: (name: string, role: UserRole) => void;
}

export const ProfileForm = ({ defaultRole, onSave }: ProfileFormProps) => {
  const [name, setName] = useState<string>('');
  const [role, setRole] = useState<UserRole>(defaultRole);
  const inputRef = useRef<HTMLInputElement>(null);

  const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
    e.preventDefault();
    if (!name.trim()) {
      inputRef.current?.focus();
      return;
    }
    onSave(name, role);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        ref={inputRef}
        type="text"
        value={name}
        onChange={(e: React.ChangeEvent<HTMLInputElement>) => setName(e.target.value)}
      />
      <button type="submit">Salvează</button>
    </form>
  );
};

Când bifezi "strict": true în tsconfig.json pe un proiect React, consola devine rapid un câmp de luptă. Am pățit-o toți, iar la un refactor recent pe o aplicație internă cu vreo 40k linii de cod, jumătate din erorile de compilare au fost fix aceleași 5 tipare clasice. Dacă le înțelegi logica acum, scapi de reflexul toxic de a trânti as any ca să treacă build-ul.

1. useState inițializat cu null

Scrii const [user, setUser] = useState(null) și când vrei să faci setUser({ name: 'Alex' }), TypeScript țipă: Argument of type ... is not assignable to parameter of type 'null'.

De ce se întâmplă? Fără un generic explicit, TypeScript deduce că starea ta poate fi doar null pe vecie. Soluția e să-i dai explicit tipul union:

// Greșit
const [user, setUser] = useState(null);

// Corect
interface User { name: string; id: number; }
const [user, setUser] = useState<User | null>(null);

2. Dispariția lui children din React.FC (React 18+)

Dacă ai învățat din tutoriale mai vechi, probabil scriai const Card: React.FC = ({ children }) => .... În React 18, echipa a scos children implicit din React.FC pentru că forța componente să accepte copii chiar dacă ele erau gândite fără.

Rezolvarea modernă: renunță la React.FC complet și tastează direct argumentul:

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

export const Card = ({ title, children }: CardProps) => (
  <div><h2>{title}</h2>{children}</div>
);

3. Tiparea evenimentelor (e: any)

Cea mai rapidă cale spre frustrare e un formular. Scrii onChange={(e) => handleChange(e)} și ai Parameter 'e' implicitly has an 'any' type.

Nu ghici tipul din burtă. Cel mai simplu truc e să scrii funcția inline o secundă, să lași cursorul pe e în VS Code și să vezi ce tip deduce React, apoi să-l muți în handler:

  • Pentru input-uri: React.ChangeEvent<HTMLInputElement>
  • Pentru butoane: React.MouseEvent<HTMLButtonElement>
  • Pentru formulare: React.FormEvent<HTMLFormElement>

4. useRef pe elemente DOM lăsat fără null

Faci const inputRef = useRef<HTMLInputElement>() și când încerci să-l legi pe <input ref={inputRef} />, primești un cârnat lung de eroare despre MutableRefObject incompatibil cu RefObject.

Regula e simplă: când folosești useRef pentru a ține o referință DOM gestionată de React, inițializează-l mereu cu null:

const inputRef = useRef<HTMLInputElement>(null);

Asta îi semnalează lui TS că e un ref de tip read-only pentru React, iar inputRef.current va deveni elementul real doar după mount.

5. Chei dinamice în obiecte: no index signature

Vrei să extragi o valoare dintr-un dicționar sau obiect de configurare: const color = THEME_COLORS[status]. Boom: Element implicitly has an 'any' type because type has no index signature.

TypeScript nu poate garanta că string-ul tău arbitrar chiar există ca proprietate pe obiectul respectiv. Rezolvi restrângând cheia cu keyof typeof:

const THEME = { active: 'green', idle: 'gray' } as const;
type Status = keyof typeof THEME; // 'active' | 'idle'

const getBadge = (status: Status) => THEME[status];

Trade-off sincer

Strict mode încetinește viteza de scriere cu vreo 20% în prima săptămână, mai ales când prototipezi rapid un UI. Dar după ce treci de perioada de adaptare, îți salvează ore întregi de debugging pe ecrane albe apărute din senin în producție.

Tu de care dintre erorile astea te-ai lovit cel mai des când ai trecut pe strict?

Răspunsuri 0

Se încarcă răspunsurile…

Loghează-te pentru a răspunde

Doar membrii comunității pot lăsa comentarii.