How to use Traditional Redux Approach In Redux

Involves defining actions, action creators, and reducers separately, leading to verbose code and manual state management.

Approach:

  • Involves defining action types, action creators, and reducers separately, leading to fragmented code organization.
  • Requires writing repetitive code for defining actions, action creators, and reducers.
  • Store setup involves creating a Redux store manually using createStore from Redux.
  • Dispatching actions requires accessing the store and dispatching actions using store.dispatch().

Example: This example uses the traditional redux approach to justify the above title.

CSS
/* App.css */

button {
    margin: 10px;
}
JavaScript
// src/actions/actions.js

export const increment = () => ({
  type: 'INCREMENT'
});

export const decrement = () => ({
  type: 'DECREMENT'
});
JavaScript
// src/reducers/reducers.js

const initialState = {
    count: 0
  };
  
  const counterReducer = (state = initialState, action) => {
    switch (action.type) {
      case 'INCREMENT':
        return {
          count: state.count + 1
        };
      case 'DECREMENT':
        return {
          count: state.count - 1
        };
      default:
        return state;
    }
  };
  
  export default counterReducer;
  
JavaScript
// src/store/store.js

import { createStore } from 'redux';
import counterReducer from '../reducers/reducers';

const store = createStore(counterReducer);

export default store;
JavaScript
// src/app.js

import './App.css';
import Counter from './counter';

function App() {
  return (
    <div className="App">
      <Counter/>
    </div>
  );
}

export default App;
JavaScript
// src/counter.js
import React from 'react';
import { useSelector, useDispatch } from 'react-redux';
import { increment, decrement } from './actions/actions';

const Counter = () => {
  const count = useSelector(state => state.count);
  const dispatch = useDispatch();

  return (
    <div>
      <h2>Counter: {count}</h2>
      <button onClick={() => dispatch(increment())}>Increment</button>
      <button onClick={() => dispatch(decrement())}>Decrement</button>
    </div>
  );
};

export default Counter;
JavaScript
// src/index.js
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import store from './store/store';
import App from './App';

ReactDOM.render(
  <Provider store={store}>
    <App />
  </Provider>,
  document.getElementById('root')
);

Step to Run Application: Run the application using the following command from the root directory of the project

npm start

Output: Your project will be shown in the URL http://localhost:3000/

How does Redux Toolkit simplify Redux development?

Redux is a powerful state management library for JavaScript applications, but setting it up and managing boilerplate code can be cumbersome. Redux Toolkit is an official package from the Redux team designed to streamline Redux development and reduce boilerplate code. In this article, we’ll explore how Redux Toolkit simplifies Redux development and improves developer productivity.

Similar Reads

What is Redux Toolkit?

Redux Toolkit is an opinionated set of utilities and tools for efficient Redux development. It provides a collection of pre-configured Redux packages and abstractions that abstract away much of the complexity of setting up and managing Redux applications. Redux Toolkit is built on top of Redux principles and best practices, making it an ideal choice for both beginners and experienced Redux developers....

How Redux toolkit simplifies Redux Development

Boilerplate Reduction: Redux Toolkit reduces the need for boilerplate code when setting up Redux. It offers utility functions like createSlice() for creating reducers and action creators together, saving developers time and effort.Immutable Updates: The Redux Toolkit promotes immutable updates to the state, ensuring predictability and simplified debugging. It utilizes the immer library internally, allowing developers to write reducer logic that appears to mutate state directly while producing a new immutable state.Built-in Middleware: Redux Toolkit comes with pre-configured middleware like redux-thunk for handling asynchronous actions without manual setup. This reduces configuration overhead and simplifies the development process.Performance Optimizations: Redux Toolkit includes performance optimizations such as “batched” state updates. This can improve performance in large applications by reducing the number of re-renders triggered by state changes, resulting in smoother user experiences....

Steps to create React app

Step 1: Create a reactJS application by using this command...

Using Traditional Redux Approach:

Involves defining actions, action creators, and reducers separately, leading to verbose code and manual state management....

Using Redux Toolkit Approach

Redux Toolkit streamlines Redux development by providing utilities like “createSlice” for combined reducer and action creation, promoting immutability, simplifying async logic, and offering built-in support for dev tools and middleware....