## What is Garbage Collection ? 

**Garbage Collection** is the process that **automatically frees up memory** that's no longer needed or accessed by the program. 

When you create variables, objects, or other data structures, memory is automatically allocated to store them. **Primitive variables** (like numbers, strings, and booleans) are stored in the **call stack**, and their memory is automatically managed when they go out of scope. **Non-primitive** data structures (like objects, arrays, and functions) are stored in the **heap**, and when these items are no longer needed — for example, after a function finishes running or an object becomes unreachable — the garbage collector automatically identifies and cleans them up from the heap.

To summarize:
- **Allocation** happens automatically when you create things .
- **Deallocation** (clean-up) happens automatically through garbage collection (only what is saved on the memory Heap)

## How Does JavaScript's Garbage Collector Work?

Javascript enginees typically use **"reachability"** to determine if an object is still needed. An object is considered **reachable**  if:

- It is accesible from the roots of execution, suc as global variable, local variables in function on the stack or active closuers. If an object cannot be **reached** from the roots, it’s considered "garbage" — and eligible for collection.

The most common strategy is **Mark-and-Sweep**, and it works like this:

1. **Mark Phase:** The garbage collector starts from the roots and travels all the references. It **marks** everything it can reach.
2. **Sweep Phase:** Anything not marked is considered unreachable. The garbage collector **sweeps** that from memory space.

## Example


```js

function createProfile(name, gender) {
  const profile = {
    name: name,
    gender: gender
  };

return profile;
}

const userProfile = createProfile('Marko', 'male');

```

- **createProfile()** creates an object and returns it.
-  **userProfile** now holds a reference to the **{ name: 'Alice' }** object.
-  as long as **userProfile** exists and references the object, it stays in memory.
-  If **userProfile** is set to null or goes out of scope, the object becomes unreachable and will eventually be collected.


## Why Understanding Garbage Collection Matters?

**Memory** leaks can still happen if you create references that never get cleaned up — leading to excessive memory usage and slow applications.

Common causes of leaks:
- Global variables
- Closures holding on to objects
- Forgotten event listeners
- built in functions such as setInterval (if it is not cleared)



Garbage Collection in Javascript

How Javascript automatically manages memory and what happens under the hood during Garbage Collection

Memory leaks

Garbage Collection in Javascript