DEV Community: Ujjwal Sinha

Handle Form State in React

Ujjwal Sinha — Tue, 28 Jan 2025 07:16:43 +0000

Handle Form State in React is used to update the state of a component when the user interacts with an input field (e.g., typing in a text box, selecting an option, etc.). It is a fundamental part of handling form inputs in React.

Let’s break down how it works, its use cases, and how you can extend it to perform specific actions (like when the user is on the mobile_number field).

How Input Change Handler Works

1. Event Object:

When the user types in an input field, an onChange event is triggered.
This event contains information about the input field, such as its name and value.

2. Updating State:

The input change handler extracts the name and value from the event object.
It then updates the corresponding state property using the setState function.

3. Dynamic State Updates:

By using the name attribute of the input field, the handler can dynamically update the correct property in the state object.

Basic Input Change Handler

Here’s a simple example of an input change handler:

const handleInputChange = (e) => {
  const { name, value } = e.target; // Extract name and value from the event
  setFormState({
    ...formState, // Spread the existing state
    [name]: value // Update the specific field
  });
};

Use Cases for Input Change Handler

1. Form Handling:

Update form state as the user types in input fields.
Enable/disable buttons or show/hide elements based on form state.

2. Validation:

Perform real-time validation (e.g., check if an email is valid or if a password meets requirements).

3. Dynamic Behavior:

Trigger specific actions when the user interacts with a particular field (e.g., auto-format a phone number or show suggestions).

4. Conditional Rendering:

Show or hide additional fields based on user input.

Advanced Use Case: Perform Actions Based on the Active Field

If you want to perform specific actions when the user is interacting with a particular field (e.g., mobile_number), you can extend the input change handler to include conditional logic.

Example: Auto-Format Mobile Number

const handleInputChange = (e) => {
  const { name, value } = e.target;

  // Perform specific actions based on the field name
  if (name === 'mobile_number') {
    // Auto-format mobile number (e.g., add dashes)
    const formattedValue = value.replace(/(\d{3})(\d{3})(\d{4})/, '$1-$2-$3');
    setFormState({
      ...formState,
      [name]: formattedValue
    });
  } else {
    // Update other fields normally
    setFormState({
      ...formState,
      [name]: value
    });
  }
};

How Error.CaptureStackTrace Works!

Ujjwal Sinha — Mon, 23 Dec 2024 08:02:09 +0000

Error.captureStackTrace(this, this.constructor) is a method provided by the V8 JavaScript engine (used in Node.js and Chrome). It is used to create a stack trace for an error object, allowing developers to track where the error originated in the code. Here’s a detailed explanation:

Breakdown of Error.captureStackTrace

1-What is Error.captureStackTrace?

It’s a static method of the Error class in V8-based JavaScript environments.
It customizes the stack trace associated with an error object (this in this case).
2-Parameters of Error.captureStackTrace

this: Refers to the error object that is being constructed (e.g., the AppError instance).
this.constructor: Specifies the constructor function (in this case, AppError) to exclude from the stack trace.

How It Works
The method populates the stack property of the error object.
The stack trace provides a detailed list of function calls leading up to the point where the error was created.
By passing this.constructor, it removes the AppError constructor itself from the stack trace, making the output cleaner and more focused on the actual location of the error.

Why Use It?

1- Clean Stack Traces:

Including the constructor in the stack trace often adds unnecessary noise.
By omitting it, the trace starts from the point where the error was thrown or created, making debugging easier.
2-Custom Error Classes:

In custom error classes, you typically want the stack trace to reflect where the error occurred in user code, not where the custom error was constructed.
Example
Here’s a practical example to demonstrate its use:

class AppError extends Error {
    constructor(message, statusCode) {
        super(message);
        this.statusCode = statusCode;
        Error.captureStackTrace(this, this.constructor);
    }
}

// Simulate an error in a function
function faultyFunction() {
    throw new AppError("Something went wrong!", 500);
}

try {
    faultyFunction();
} catch (err) {
    console.log(err.stack);
}

Output Without Error.captureStackTrace
The stack trace might include the AppError constructor, which is less relevant:

AppError: Something went wrong!
    at new AppError (/path/to/file.js:10:9)
    at faultyFunction (/path/to/file.js:15:11)
    at Object.<anonymous> (/path/to/file.js:18:1)
    ...

Output With Error.captureStackTrace
The constructor (new AppError) is omitted, making the stack trace cleaner:

AppError: Something went wrong!
    at faultyFunction (/path/to/file.js:15:11)
    at Object.<anonymous> (/path/to/file.js:18:1)
    ...

Conclusion

Error.captureStackTrace(this, this.constructor) enhances stack trace readability by focusing on where the error occurred rather than its construction. This is particularly useful in custom error classes for debugging complex applications.

Implementation of Stack Using Array

Ujjwal Sinha — Fri, 17 Nov 2023 15:27:03 +0000

In this Article, We will learn how we can Implementation our own Stack and Use it. I'm using java but you can use whatever language you comfortable with.

Prerequisites :- You must be familiar with classes and object to implement stack.

Before Moving to Implementation, Let's have look to this What is tack? What Operation we can perform? for better understanding.

*How Stack Works ? *
As we know stack is linear data structure and follows the particular order to perform operations which standardize on LIFO principle.
Whatever the stack does it maintain the discipline to perform operation.

for example : In array we can access data using index in O(1) operation but in stack we can't do. So here we follow certain order to perform this task in stack in O(n).
Keeping this thing in mind we move to implementation part.

List of the function

Brief introduction which we're going to implement

push(): When we insert an element in a stack then the operation is known as a push. If the stack is full then the overflow condition occurs.

pop(): When we delete an element from the stack, the operation is known as a pop. If the stack is empty means that no element exists in the stack, this state is known as an underflow state.

isEmpty(): It determines whether the stack is empty or not.

isFull(): It determines whether the stack is full or not.'

peek(): It returns the element at the given position.

count(): It returns the total number of elements available in a stack.

display(): It prints all the elements available in the stack.

Implementation Using Array

Initialize the class
Declare variable array as 'arr' and integer with index 0;
Note:- Behind the scene, Array work as stack. So, don't be amazed. Just know these thing.

public static class Stack {
        int[] arr = new int[5];
        int idx = 0;
}

Defining Methods in class Stack

Push Method

1- The push method takes an integer parameter x, representing the element to be pushed onto the stack.
2- It checks if the stack is full by calling a method isFull().
3- If the stack is full, it prints "Stack is Full" to the console and returns, indicating that the push operation cannot be performed.
4- If the stack is not full, it assigns the value of x to the next available position in the stack array (arr) at index idx.
5- The index idx is then incremented, possibly pointing to the next available position for the next push operation.

void push(int x){
     if(isFull()){
         System.out.println("Stack is Full");
         return;
     }
     arr[idx] = x;
     idx++;
}

Peek Method

1- The peek method takes no parameters but uses the instance variable idx to determine the top of the stack.
2- It checks if the stack is empty by verifying if the index idx is equal to 0.
3- If the stack is empty, it prints "Stack Empty" to the console and returns -1, indicating that there is no valid element to peek.
4- If the stack is not empty, it returns the value of the element at the top of the stack. The index idx-1 is used because the top element is at one position below the current value of idx.

int peek(){
    if(idx == 0){
        System.out.println("Stack Empty");
        return -1;
    }
    return arr[idx-1];
}

Pop Method

1- The pop method is used to remove and return the element at the top of the stack.
2- It checks if the stack is empty by verifying if the index idx is equal to 0.
3- If the stack is empty, it prints "Stack is Empty" to the console and returns -1, indicating that there is no valid element to pop.
4- If the stack is not empty:

It retrieves the value of the element at the top of the stack (arr[idx - 1]) and stores it in a variable named top.
Sets the element at the top of the stack to 0, essentially removing it from the stack.
Decrements the index idx to point to the next available position in the stack.
Returns the value of the removed element (top).

int pop() {
  if(idx == 0){
      System.out.println("Stack is Empty");
      return -1;
  }
  int top = arr[idx -1];
  arr[idx-1] = 0;
  idx--;
  return top;
}

Display Method

1- The display method is responsible for printing the contents of the stack to the console.
2- It uses a for loop to iterate over the elements of the stack array (arr) from index 0 to idx-1.
3- Inside the loop, it prints each element followed by a space.
4- After the loop, it prints a newline character (System.out.println()) to move to the next line in the console.

void display(){
     for(int i = 0; i <= idx-1; i++){
         System.out.print(arr[i] + " ");
     }
     System.out.println();
}

isEmpty Method

IsEmpty return boolean.

boolean isEmpty(){
   if(idx == 0) return true;
   else return false;
}

Size/Count Method

int size() {
    return idx;
}

isFull Method

boolean isFull(){
   if(idx == arr.length) return true;
   else return false;
}

Understanding Stack Data Structure and Real-World Use Cases

Ujjwal Sinha — Wed, 08 Nov 2023 16:10:43 +0000

In this Article, we'll explore about Stack & its methods and
Real-life Use Cases of Stack and Best Practice to use.

What is Stack ?

Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first, comes out last.

In other words, a stack can be defined as a container in which insertion and deletion can be done from the one end known as the top of the stack.

Operation on Stack

push(): When we insert an element in a stack then the operation is known as a push. If the stack is full then the overflow condition occurs.
pop(): When we delete an element from the stack, the operation is known as a pop. If the stack is empty means that no element exists in the stack, this state is known as an underflow state.
isEmpty(): It determines whether the stack is empty or not.
isFull(): It determines whether the stack is full or not.'
peek(): It returns the element at the given position.
count(): It returns the total number of elements available in a stack.
change(): It changes the element at the given position.
display(): It prints all the elements available in the stack.

Applications of Stack

Mathematical expression: Stacks are used to evaluate mathematical expressions, such as infix, postfix, and prefix expressions. They are also used to convert one expression to another.
Backtracking: Stacks are used in backtracking algorithms to keep track of the path taken to reach a particular point in the algorithm.
Function call: Stacks are used to keep track of function calls and return addresses in programming languages.
Memory Management: Stacks are used in memory management to allocate and deallocate memory for variables and data structures.

Advantages of Stack

Stacks are simple to implement and can be created using arrays, linked lists, or even dynamic memory allocation.
Stacks are efficient in memory management as they only allocate memory for the elements that are currently in the stack.
The push and pop operations have O(1) time complexity, which means that take constant time regardless of the size of the stack.

Disadvantages of Stack

Static stacks have a fixed size, which means that in a stack we can add limited elements.
Stacks can suffer from overflow when you try to add more elements than the stack size, and underflow when you try to remove an element from an empty stack.
Stacks can only be used to store and retrieve data in a specific order, whereas queues and trees can be used to store and retrieve data in a variety of orders.

Real-World Use Cases of Stack

Web Browsers: Web browsers use stacks to keep track of the history of websites you visit.
Call Logs: Call logs in mobile phones use stacks.

Text Editors: Text editors like Microsoft Word, Excel, or Notepad use stacks for their undo or redo.

Syntax Parsing: Syntaxes in languages are parsed using stacks.

Converting Infix to Postfix Expressions: Stacks are used to convert infix to postfix expressions.

Message Logs: Message logs and all messages you get are arranged in a stack.

Implementation of LinkedList

Ujjwal Sinha — Sun, 05 Nov 2023 12:07:09 +0000

Hey Everyone!!!, Hope! Everyone is doing great.

In this Article, We will see how we can implement our own LinkedList class and use them. In this Article, I'm using java but you can use whatever language you comfortable with.

Prerequisites :- You must be familiar with the Object and class.

We defines a simple implementation of a Node class within an Implementation class. The Node class represents a basic node in a linked list data structure, containing an integer data value and a reference to the next node in the sequence.

Here the term Reference means address of next node in the sequence. As you can see below

Defining a Node Class (Important)

It is mandatory to Remember this every time we use node type to create node variable. The above code is basic building block of LinkedList Implementation.

1 -The code defines a Node class within an Implementation class, representing a basic unit for a linked list data structure.

2-The Node class consists of an integer data field to store data and a next field to hold the reference to the next node in the linked list.

3-It includes a single-line constructor that initializes the data field of the Node with the value passed as an argument. The next field is not explicitly initialized and defaults to null.

This Node class forms the foundation for implementing linked lists in Java and can be extended for various data structure and algorithm implementations.

Defining a LinkedList class

As we define the child node class above after that we define another child named LinkedList.

Initialization

Initialize then node head, tail with null and size with integer.

Initialize value with null means when there is a single node in the list it always point to the null and last node of list also always point to the null. If node is not pointing anywhere then it is point to null.

Defining Methods in LinkedList

InsertAtEnd Method

1- A method called insertAtEnd in a linked list implementation that adds a new node at the end of the list.

2- It creates a new node with the provided value and checks if the linked list is empty.

3- If the list is empty, the new node becomes the head of the list; otherwise, it is appended to the current tail node.

4- The tail pointer is then updated to the newly added node, ensuring it always points to the last node. Additionally, the size of the linked list is incremented to reflect the addition of the new element.

display Method

1- Method named display within a linked list implementation that prints the elements of the linked list.

2- It initializes a temporary node temp with the reference to the head of the linked list for traversal.

3- The method employs a while loop to iterate through the linked list until the temporary node temp becomes null, ensuring all elements are printed.

4- Within the loop, it prints the data of the current node followed by a space, allowing the elements to be displayed horizontally.

This display method facilitates the visualization and confirmation of the elements stored in the linked list, enabling users to verify the list's content and structure.

getAt Method

1- A method named getAt within a linked list implementation, allowing retrieval of the data value of a node at a specified index.

2- It includes a check to ensure that the provided index is within the valid range of the linked list. If the index is outside the valid range, it prints a "wrong index" message and returns -1.

3- The method initializes a temporary node temp with the reference to the head of the linked list.

4- It employs a for loop to traverse the linked list, moving from the head node to the node at the specified index, determined by the loop counter.

5- The method returns the data value of the node at the specified index if the index is valid, enabling the retrieval of specific data from the linked list.

insertAtHead Method

1- Method called insertAtHead in a linked list implementation, used to add a new node with the specified value at the beginning of the linked list.

2- It creates a new node with the provided value, initializing the temp variable.

3- If the linked list is empty (i.e., head is null), the new node becomes both the head and the tail of the list, signifying the first and only node in the list.

4- If the list is not empty, the new node is inserted at the head, with its next pointer referencing the previous head node, ensuring the continuity of the list.

This insertAtHead method effectively adds a new node at the beginning of the linked list, updating the necessary pointers and maintaining the list's integrity and size.

insertAt Method

1- The insertAt method is used to insert a new node with the specified value at the given index in the linked list.

2- It begins by creating a new node t with the provided value and initializes a temporary node temp with the reference to the head of the linked list.

3- If the index is equal to the size of the list, the method delegates the task to insertAtEnd to add the new node at the end of the list, and if the index is 0, it delegates the task to insertAtHead to add the new node at the beginning of the list.

4- If the index is outside the valid range of the list, the method prints a "wrong index" message and returns.

5- If the index is valid and not at the beginning or end, the method traverses the list to the node just before the specified index.

6- It then inserts the new node t at the specified index, adjusting the pointers to maintain the list's integrity, and increments the size of the list.

This insertAt method enables the insertion of a new node at the specified index in the linked list, handling various edge cases and updating the necessary pointers to ensure the list remains intact.

deleteAt Method

1- The deleteAt method is used to remove the node at the specified index in the linked list.

2- It initializes a temporary node temp with the reference to the head of the linked list.

3- If the index is 0, indicating the deletion of the first node, the method updates the head to point to the next node, effectively removing the current head. It also decrements the size of the list and then returns.

4- If the index is not 0, the method traverses the list to the node just before the specified index.

5- It adjusts the pointers of the nodes to skip over the node at the specified index, removing it from the linked list. The tail is also updated to point to the new last node.

6- The size of the list is decremented to reflect the removal of the node.

This deleteAt method effectively removes the node at the specified index from the linked list, updating the necessary pointers and adjusting the size of the list accordingly.

Understanding LinkedList Data Structure and Real-life Use Cases

Ujjwal Sinha — Fri, 03 Nov 2023 13:24:38 +0000

In this Article, we'll explore about LinkedList & its types and
Real-life Use Cases of LinkedList and Best Practice to use.

What is LinkedList ?

LinkedList as a linear data structure where elements are stored in nodes that are linked together by pointers, each containing the data and a reference to the next node. Unlike Arrays, Linked List elements are not stored at a contiguous location.
In a Node, there is data and address/reference of next node and last node always point to null.
As you can see in image below-

Types of linked lists

1- Singly-linked list :-In Singly-linked list, We can say that traversal of items can be done in the forward direction only due to the linking of every node to its next node.

Operation on Singly-Linked list

Insertion
Deletion
Search
Display

Below you can see representations-

Node Creation-

struct node {
    int data;           // Data 
    struct node * next; // Address 
};

2- Doubly-linked list :- In Doubly-linked list, We can say that Traversal of items can be done in both forward and backward directions as every node contains an additional prev pointer that points to the previous node.

Operation on Doubly-Linked list

Insertion
Deletion
Display

Representation of Doubly linked list-

Node Creation-

// Class for Doubly Linked List
public class DLL {
    Node head; // head of list

    /* Doubly Linked list Node*/
    class Node {
        int data;
        Node prev;
        Node next;

        // Constructor to create a new node
        // next and prev is by default initialized as null
        Node(int d) { 
           data = d; 
        }
    }
}

3- Circular linked lists :- In Circular linked list, We can say that A circular linked list is a type of linked list in which the first and the last nodes are also connected to each other to form a circle, there is no NULL at the end.

Operation on Circular Linked list

Insertion
Deletion
Display

Representation of Circular linked list-

Real-life Use Cases of LinkedList

find various applications in real-life scenarios due to their dynamic memory allocation and efficient insertion and deletion operations. Here are some real-life use cases of LinkedLists:

Music and Video Playlists

In music and video streaming services, playlists are commonly implemented using LinkedLists. Each song or video is represented as a node, allowing users to easily add, remove, or rearrange the sequence of media items in their playlists.

Browser History in Web Browsers

Web browsers use LinkedLists to maintain a user's browsing history. Each visited web page is stored as a node, enabling users to navigate backward and forward through their browsing history, facilitating a seamless browsing experience.

Task Management Applications

Task management applications often utilize LinkedLists to manage to-do lists. Each task is stored as a node, enabling users to add new tasks, mark tasks as complete, or reorder tasks based on priority or due dates.

Scheduling Systems

In transportation systems, such as train or flight or Bus scheduling, LinkedLists can be used to manage the sequence of upcoming departures. Each departure schedule is stored as a node, allowing for easy rearrangement and adjustment of the schedule based on real-time changes or delays.

Check out the Implementation of Linked list

What are Packages and How we can use it?

Ujjwal Sinha — Wed, 01 Nov 2023 10:29:14 +0000

In this article, We will learn about packages and What is the hierarchy and learn about how Packages contains different class and methods. This term packages used in every programming languages, so I though to share my knowledge and some examples to related to topic.

With term Packages what comes in our mind. Just think once and let me know in the comment. So, what you think that's right!!!

Example :- Packages is same as you might think in general wrapper or box.

But What we say in technical term, What are Packages?

Something that's Packed Right!!!

Packages is set of programs files and data files which developer by programmers to perform specific task and include information regarding installation of packages.

Or We can say...

A package is a container of a group of related classes where some of the classes are accessible are exposed and others are kept for internal purpose.
We can reuse existing classes from the packages as many time as we need it in our program.

Here is the hierarchy of Packages -> Sub-Packages-> classes
You can visualize how it is structured inside single package java.

Now, You had a Clear understanding of the what are packages and how it is structured. Now, We move forward and go deep down in packages and it's type? How it works?

Types of Packages:-

User Defined Packages

These are the packages that are defined by the user. First we create a directory myPackage (name should be same as the name of the package). Then create the MyClass inside the directory with the first statement being the package names.

for Example :-

// Name of the package must be same as the directory
// under which this file is saved
package myPackage;

public class MyClass
{
    public void getNames(String s)
    {        
        System.out.println(s);        
    }
}

Now, we can use above MyClass class in our program.

/* import 'MyClass' class from 'names' myPackage */
import myPackage.MyClass;

public class PrintClass 
{
   public static void main(String args[]) 
   {       
      // Initializing the String variable with a value 
      String name = "Casto";

      // Creating an instance of class MyClass in the package.
      MyClass obj = new MyClass();

      obj.getNames(name);
   }
}

Note :- MyClass.java must be saved inside the myPackage directory since it is a part of the package.

Builtin Packages

BuiltIn Packages consist of large number of classes which is defined by java or certain programming language to perform necessary operations.
Built-in packages in Java consist of classes that are part of the Java API.

Some of the commonly used built-in packages used in java are:-

1) java.lang:- Contains language support classes.This package is automatically imported.
2) java.io:- Contains classed for supporting input / output operations.
3) java.util:- Contains utility classes which implement data structures like Linked List, Dictionary and support,for Date / Time operations.
4) java.applet:- Contains classes for creating Applets.
5) java.awt:- Contain classes for implementing the components for graphical user interfaces (like button , ;menus etc).
6) java.net:- Contain classes for supporting networking operations.

Using Static import

Static import is a feature introduced in Java programming language ( versions 5 and above ) that allows members ( fields and methods ) defined in a class as public static to be used in Java code without specifying the class in which the field is defined.

import static java.lang.System.*; 

class ImportDemo 
{ 
public static void main(String args[]) 
{    
        // We don't need to use 'System.out' 
        // as imported using static. 
        out.println("GeeksforGeeks"); 
} 
}

Handling Name Conflicts

The only time we need to pay attention to packages is when we have a name conflict . For example both, java.util and java.sql packages have a class named Date. So if we import both packages in program as follows:

import java.util.*;
import java.sql.*;

//And then use Date class, then we will get a compile-time error :

Date today ; //ERROR-- java.util.Date or java.sql.Date?

The compiler will not be able to figure out which Date class do we want.
This problem can be solved by using a specific import statement:

import java.util.Date;
import java.sql.*;

If we need both Date classes then, we need to use a full package name every time we declare a new object of that class.
For Example:

java.util.Date deadLine = new java.util.Date();
java.sql.Date today = new java.sql.Date();

Important Points to Remember :-

1- Every class is part of some package.
2- If no package is specified, the classes in the file goes into a special unnamed package (the same unnamed package for all files).
3- All classes/interfaces in a file are part of the same package. Multiple files can specify the same package name.
4- If package name is specified, the file must be in a subdirectory called name (i.e., the directory name must match the package name).
5- We can access public classes in another (named) package using: package-name.class-name