Skip to content

Mastering useState in React to Handle Multiple Values

Updated: at 02:12 PM

Mastering useState in React to Handle Multiple Values

In the world of React development, efficiently managing state across your application is crucial. While useReducer and Redux often grab the spotlight for handling complex state logic, useState, especially when used with the Context API, can elegantly manage multiple values with far less complexity. This blog post will guide you through setting up a Next.js project, creating a context provider with useState, and integrating it to manage an array of constants effectively. By the end, you’ll see that for many scenarios, useState is not only sufficient but preferable.

Setting Up a Next.js Project

First things first, let’s get a Next.js project off the ground. Next.js is a powerful React framework that facilitates features like server-side rendering and static site generation, making it a popular choice for modern web applications. Learn more about Next.js on their official site.

1. Install Node.js

Ensure Node.js is installed on your system. Download it from the Node.js website.

2. Create a Next.js Application

Open your terminal and run the following command to create a new Next.js project:

npx create-next-app react-constant-manager
cd react-constant-manager

3. Start the Development Server

Kickstart the development server:

npm run dev

Visit http://localhost:3000 to see your new Next.js app in action.

Crafting the Context with useState

We’ll manage a collection of settings, each represented by a ConstantType interface, using a context provider that leverages useState.

Define the ConstantType Interface

This TypeScript interface ensures type safety and clarity in our application.

// types/ConstantType.ts
export interface ConstantType {
  processForReal: boolean;
  showRulesDefault: boolean;
  webSocketPort: number;
  webSocketHost: string;
  consoleLogging: boolean;
  debugFlag: boolean;
  maxEmailsToReturn: number;

Implementing the Context Provider

Set up the context provider using React’s useState, a simpler alternative to useReducer for many use cases. Learn more about useState in the React documentation.

// context/ConstantsContext.tsx
import React, { createContext, useContext, useState, ReactNode } from 'react';
import { ConstantType } from '../types/ConstantType';

interface ConstantsContextType {
  constants: ConstantType[];
  setConstants: (constants: ConstantType[]) => void;

const ConstantsContext = createContext<ConstantsContextType | undefined>(undefined);

export const ConstantsProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
  const [constants, setConstants] = useState<ConstantType[]>([]);

  return (
    <ConstantsContext.Provider value={{ constants, setConstants }}>

export const useConstants = () => {
  const context = useContext(ConstantsContext);
  if (!context) {
    throw new Error('useConstants must be used within a ConstantsProvider');
  return context;

Integrating the Provider in Your App

Incorporate your provider in your app’s main file to make it available throughout your component tree.

// pages/_app.tsx
import { AppProps } from 'next/app';
import { ConstantsProvider } from '../context/ConstantsContext';

function MyApp({ Component, pageProps }: AppProps) {
  return (
      <Component {...pageProps} />

export default MyApp;

Building a Component to Utilize the Context

Here’s how you can use the context in a component to manage and update your constants dynamically.

// components/ConstantsManager.tsx
import React from 'react';
import { useConstants } from '../context/ConstantsContext';

const ConstantsManager = () => {
  const { constants, setConstants } = useConstants();

  const updateConstant = (index: number, field: keyof ConstantType, value: any) => {
    const updatedConstants = [...constants];
    updatedConstants[index] = { ...updatedConstants[index], [field]: value };

  return (
      {, idx) => (
        <div key={idx}>
            onChange={e => updateConstant(idx, 'processForReal',}
          {/* Additional fields and inputs can be managed similarly */}

export default ConstantsManager;


useState offers a clean and straightforward

way to manage state in React applications, particularly when dealing with multiple values that need to be updated together. It reduces boilerplate compared to useReducer and is easier to integrate for simpler state management needs.

When to Consider useReducer

Although useState is highly effective for many scenarios, consider using useReducer when:

For further reading on useReducer, check out the React documentation on useReducer.

By understanding and utilizing useState effectively, you can maintain cleaner and more readable code in your React applications, demonstrating just how powerful this hook can be for state management.

Check out the ORM (Object Relational Mapper) PRISMA. The database access method I use in all my projects