Data structures are an essential part of computer science and programming. They are a way to organize and store data in a way that allows efficient access and modification. JavaScript, being a high-level programming language, supports a variety of data structures that can be used for different purposes.

In this blog, we will discuss some of the commonly used data structures in JavaScript and provide example code for each.

1. Arrays

   Arrays are a collection of elements of any data type that can be accessed using an index. Arrays in JavaScript are dynamic, which means that their size can be changed dynamically.

Example code:

let arr = [1, 2, 3];
arr.push(4); // Add an element at the end
arr.pop(); // Remove the last element
arr[1] = 5; // Change the value at index 1
console.log(arr); // [1, 5, 3]

1. Objects

   Objects are collections of key-value pairs. In JavaScript, objects are used to represent real-world entities and are commonly used for storing data in JSON format.

Example code:

let person = {
  name: "John",
  age: 30,
  address: {
    street: "123 Main St",
    city: "Anytown",
    state: "CA"
  }
};
console.log(person.name); // John
console.log(person.address.city); // Anytown

1. Sets

   Sets are collections of unique elements. In JavaScript, sets are implemented using the Set object, which provides methods for adding, removing, and iterating over elements.

Example code:

let set = new Set();
set.add(1);
set.add(2);
set.add(3);
set.add(2); // Adding duplicate element will be ignored
console.log(set.size); // 3
set.delete(2);
console.log(set.has(2)); // false

1. Maps

   Maps are collections of key-value pairs, similar to objects. The difference is that in a map, the keys can be of any data type, not just strings.

Example code:

let map = new Map();
map.set("a", 1);
map.set("b", 2);
map.set("c", 3);
console.log(map.get("b")); // 2
map.delete("c");
console.log(map.has("c")); // false

1. Linked Lists

   A linked list is a data structure that consists of a sequence of nodes, each containing data and a reference to the next node. Linked lists can be used to implement various data structures like stacks, queues, and associative arrays.

Example code:

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.size = 0;
  }

  add(value) {
    let node = new Node(value);
    let current = this.head;

    if (!current) {
      this.head = node;
    } else {
      while (current.next) {
        current = current.next;
      }
      current.next = node;
    }

    this.size++;
  }

  remove(value) {
    let current = this.head;
    let previous = null;

    while (current) {
      if (current.value === value) {
        if (previous) {
          previous.next = current.next;
        } else {
          this.head = current.next;
        }

        this.size--;
        return true;
      }

      previous = current;
      current = current.next;
    }

    return false;
  }
}

let list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.remove

In conclusion, JavaScript offers a variety of data structures that can be used for different purposes. Arrays, objects, sets, maps, and linked lists are some of the most commonly used data structures. Understanding how to use these data structures effectively can help to write efficient and maintainable code. The examples provided in this blog can serve as a starting point for implementing these data structures in your own JavaScript code.