Apakah tindakan dan pengurangan, dan mengapa pengurangan mesti tulen?

Question

Accepted Answer

Sebuah **tindakan** adalah objek biasa yang menggambarkan *apa yang terjadi*; **pengurangan** adalah fungsi tulen yang mengambil keadaan semasa dan tindakan dan mengembalikan keadaan *berikutnya*. Bersama-sama mereka melaksanakan peralihan keadaan yang dapat diramalkan.

## Tindakan — menggambarkan peristiwa

```js
// just data: a `type` (required) + any payload
{ type: "todos/added", payload: { id: 1, text: "Learn Redux" } }
{ type: "todos/toggled", payload: 1 }
```

Tindakan tidak *melakukan* apa-apa — mereka adalah deskripsi deklaratif peristiwa. Menamakan mereka sebagai fakta waktu lalu ("added", "toggled") mencerminkan bahawa mereka merekodkan apa yang terjadi.

## Pengurangan — mengira keadaan berikutnya

```js
function todosReducer(state = [], action) {
  switch (action.type) {
    case "todos/added":
      return [...state, action.payload];              // new array
    case "todos/toggled":
      return state.map(t =>                             // new array, new object for the changed one
        t.id === action.payload ? { ...t, done: !t.done } : t
      );
    default:
      return state;                                     // unknown action → unchanged
  }
}
```

Tandatangan pengurangan adalah `(state, action) => newState`. Ia mesti mengembalikan objek/tatasusunan keadaan **baru** (secara tidak berubah), tidak boleh bermutasi input.

## Mengapa pengurangan MESTI tulen

Fungsi tulen: (1) mengembalikan keluaran yang sama untuk input yang sama, dan (2) tiada **kesan sampingan**. Pengurangan mesti mematuhi kedua-dua peraturan:

```js
// ❌ NOT pure — breaks everything
function badReducer(state, action) {
  state.value++;              // ❌ mutates input (breaks change detection, time-travel)
  fetch("/api/log");          // ❌ side effect (non-deterministic, untestable)
  return { value: Math.random() }; // ❌ non-deterministic output
}
```

Ketulenan membolehkan ciri tandatangan Redux:

```text
✓ Predictability   — same state + action ALWAYS gives the same result
✓ Time-travel / replay — you can re-run actions to reproduce any state
✓ Testability      — just call reducer(state, action) and assert; no mocks needed
✓ Change detection — returning new references lets the UI detect changes
```

Kesan sampingan (panggilan API, penLog, ketidakpastian) tergolong dalam **middleware** (thunks/sagas) atau kesan — tidak pernah dalam pengurangan.

## Mengapa ini penting

Model tindakan/pengurangan adalah jantung pengurusan keadaan gaya Redux dan sebab mengapa ia sangat mudah dihirap dan diuji.

Persyaratan ketulenan bukanlah sewenang-wenang: ia *yang membuat* penyahpepijatan perjalanan masa, ulangan tindakan, dan ujian unit remeh mungkin, dan ia sebab kesan sampingan mesti tinggal di tempat lain.

Pola pembaruan yang didorong fungsi tulen, tidak berubah ini berulang merentasi Redux, NgRx, useReducer, dan seterusnya — memahaminya (dan disiplin menjaga pengurangan tulen) adalah asas kepada keadaan yang dapat diramalkan.