React 19 membawa peningkatan ketara kepada pengoptimuman prestasi, terutamanya dalam cara ia mengendalikan hafalan. Mari kita terokai cara memo, useMemo dan useCallback telah berkembang dan cara ia kini dioptimumkan secara lalai.

Evolusi Memoisasi dalam Reaksi

Sebelum ini dalam React 18, pembangun perlu mempertimbangkan dengan teliti masa untuk menggunakan teknik memoisasi untuk mengelakkan pemaparan semula yang tidak perlu dan mengoptimumkan prestasi. React 19 mengubah paradigma ini dengan memperkenalkan pengoptimuman automatik yang menjadikan alat ini lebih cekap dan, dalam banyak kes, tidak diperlukan.

memo dalam React 19: Memoisasi Komponen Lebih Pintar

Memo React 19 kini jauh lebih bijak tentang masa untuk memaparkan semula komponen. Rangka kerja secara automatik menjejaki perubahan prop dan kesannya pada output komponen.

Contoh 1: Perbandingan Alat Asas

// React 18
const UserCard = memo(({ user, onUpdate }) => {
  return (
    <div>
      <h2>{user.name}</h2>
      <button onClick={onUpdate}>Update</button>
    </div>
  );
});

// React 19
// memo is now automatically optimized
const UserCard = ({ user, onUpdate }) => {
  return (
    <div>
      <h2>{user.name}</h2>
      <button onClick={onUpdate}>Update</button>
    </div>
  );
});

Contoh 2: Komponen Bersarang

// React 18
const CommentThread = memo(({ comments, onReply }) => {
  return (
    <div>
      {comments.map(comment => (
        <Comment 
          key={comment.id}
          {...comment}
          onReply={onReply}
        />
      ))}
    </div>
  );
});

// React 19
const CommentThread = ({ comments, onReply }) => {
  return (
    <div>
      {comments.map(comment => (
        <Comment 
          key={comment.id}
          {...comment}
          onReply={onReply}
        />
      ))}
    </div>
  );
});

useMemo: Penghafalan Nilai Automatik

Memo penggunaan React 19 kini dioptimumkan untuk mengesan secara automatik apabila memoisasi bermanfaat, mengurangkan keperluan untuk pengoptimuman manual.

Contoh 1: Pengiraan Mahal

// React 18
const ExpensiveChart = ({ data }) => {
  const processedData = useMemo(() => {
    return data.map(item => ({
      ...item,
      value: complexCalculation(item.value)
    }));
  }, [data]);

  return <ChartComponent data={processedData} />;
};

// React 19
const ExpensiveChart = ({ data }) => {
  // React 19 automatically detects expensive operations
  const processedData = data.map(item => ({
    ...item,
    value: complexCalculation(item.value)
  }));

  return <ChartComponent data={processedData} />;
};

Contoh 2: Rujukan Objek

// React 18
const UserProfile = ({ user }) => {
  const userStyles = useMemo(() => ({
    background: user.premium ? 'gold' : 'silver',
    border: `2px solid ${user.active ? 'green' : 'gray'}`
  }), [user.premium, user.active]);

  return <div>



<h3>
  
  
  Example 3: Derived State
</h3>



<pre class="brush:php;toolbar:false">// React 18
const FilteredList = ({ items, filter }) => {
  const filteredItems = useMemo(() => 
    items.filter(item => item.category === filter),
    [items, filter]
  );

  return <List items={filteredItems} />;
};

// React 19
const FilteredList = ({ items, filter }) => {
  // React 19 automatically optimizes derived state
  const filteredItems = items.filter(item => item.category === filter);
  return <List items={filteredItems} />;
};

useCallback: Memoisasi Fungsi Lebih Pintar

Penggunaan React 19Callback kini lebih bijak tentang kestabilan fungsi dan kesamaan rujukan.

Contoh 1: Pengendali Acara

// React 18
const TodoList = ({ todos, onToggle }) => {
  const handleToggle = useCallback((id) => {
    onToggle(id);
  }, [onToggle]);

  return todos.map(todo => (
    <TodoItem 
      key={todo.id}
      {...todo}
      onToggle={handleToggle}
    />
  ));
};

// React 19
const TodoList = ({ todos, onToggle }) => {
  // React 19 automatically maintains function stability
  const handleToggle = (id) => {
    onToggle(id);
  };

  return todos.map(todo => (
    <TodoItem 
      key={todo.id}
      {...todo}
      onToggle={handleToggle}
    />
  ));
};

Contoh 2: Panggilan balik dengan Ketergantungan

// React 18
const SearchComponent = ({ onSearch, searchParams }) => {
  const debouncedSearch = useCallback(
    debounce((term) => {
      onSearch({ ...searchParams, term });
    }, 300),
    [searchParams, onSearch]
  );

  return <input onChange={e => debouncedSearch(e.target.value)} />;
};

// React 19
const SearchComponent = ({ onSearch, searchParams }) => {
  // React 19 handles function stability automatically
  const debouncedSearch = debounce((term) => {
    onSearch({ ...searchParams, term });
  }, 300);

  return <input onChange={e => debouncedSearch(e.target.value)} />;
};

Contoh 3: Pengendalian Acara Kompleks

// React 18
const DataGrid = ({ data, onSort, onFilter }) => {
  const handleHeaderClick = useCallback((column) => {
    onSort(column);
    onFilter(column);
  }, [onSort, onFilter]);

  return (
    <table>
      <thead>
        {columns.map(column => (
          <th key={column} onClick={() => handleHeaderClick(column)}>
            {column}
          </th>
        ))}
      </thead>
      {/* ... */}
    </table>
  );
};

// React 19
const DataGrid = ({ data, onSort, onFilter }) => {
  // React 19 optimizes function creation and stability
  const handleHeaderClick = (column) => {
    onSort(column);
    onFilter(column);
  };

  return (
    <table>
      <thead>
        {columns.map(column => (
          <th key={column} onClick={() => handleHeaderClick(column)}>
            {column}
          </th>
        ))}
      </thead>
      {/* ... */}
    </table>
  );
};

Faedah Utama Pengoptimuman React 19

1. Boilerplate Dikurangkan: Kurang memerlukan kod pembalut hafalan yang jelas
2. Prestasi Automatik: Bertindak balas dengan bijak mengendalikan kemas kini komponen
3. Pengalaman Pembangun yang Lebih Baik: Lebih sedikit keputusan tentang pengoptimuman
4. Saiz Himpunan Yang Diperbaiki: Kod hafalan yang kurang bermakna berkas yang lebih kecil
5. Kestabilan Automatik: Pengendalian kesamaan rujukan yang lebih baik
6. Pemarahan Semula Pintar: Penjadualan kemas kini yang lebih cekap

Bila Masih Menggunakan Memoisasi Eksplisit

Walaupun pengoptimuman automatik React 19 berkuasa, masih terdapat kes di mana penghafalan eksplisit mungkin bermanfaat:

1. Apabila anda mempunyai pengiraan yang sangat mahal yang anda ingin pastikan dihafal
2. Apabila berurusan dengan struktur data yang kompleks di mana anda ingin menjamin kestabilan rujukan
3. Dalam aplikasi kritikal prestasi yang anda perlukan kawalan yang terperinci
4. Apabila menyepadukan dengan perpustakaan luaran yang mengharapkan rujukan yang stabil

Kesimpulan

Penambahbaikan React 19 pada hafalan memudahkan anda menulis aplikasi berprestasi tanpa mengurus pengoptimuman secara manual. Rangka kerja kini mengendalikan banyak senario pengoptimuman biasa secara automatik, membawa kepada kod yang lebih bersih dan prestasi yang lebih baik di luar kotak.

Ingat bahawa walaupun pengoptimuman ini berkuasa, memahami cara ia berfungsi boleh membantu anda membuat keputusan yang lebih baik tentang masa bergantung pada pengoptimuman automatik berbanding masa untuk melaksanakan pengoptimuman manual untuk kes penggunaan tertentu.

Selamat Pengekodan!

Atas ialah kandungan terperinci React Automatic Optimization: Selamat tinggal memo, useMemo dan useCallback?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!