## Javascript has two main categories of data types:

**Primitive Types** : are immutable and passed by value: **number**, **string**, **boolean**, **undefined**, **null**, **symbol** and **bigint** .

**Non-Primitive Types**: **Objects** (including **arrays** and **functions**) are non-primitive types. In JavaScript, these are passed by reference


**Primitives can behave like objects temporarily because JavaScript wraps them in object "wrappers"**. For example true.toString() works because Javascript temporarily wraps **true** in a **Boolean** object, allowing access to its methods. Internally, **true.toString()** behaves like **Boolean(true).toString()** using the standard built-in object **Boolean**. You can see more about standar build-in objects here: [MDN Web Docs: Standard Built-in Objects](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects)



**Functions and arrays are technically objects** (special kind of objects), even though **typeof** returns '**function**' for functions and we can demonstrate this with examples showing:

1. They can have properties assigned to them.
2. They inherit from Object.
3. They behave like objects in key ways

Example1: Arrays are Objects

```js
let arr = [1, 2, 3];

// We can add a custom property to the array
arr.customProperty = "Custom property";
console.log(arr.customProperty) // "Custom property"

// Proving Inheritance
console.log(arr instanceof Object);     // true

// Behaves like an object in key ways
arr["anotherCustomProperty"] = "another custom property";
console.log(arr.anotherCustomProperty); //  "another custom property"
```

Example2: Functions are Objects

```js
function example() {
  console.log("Example");
}
// We can add a custom property 
example.customProperty = "Custom property";
console.log(example.customProperty) // "Custom property"

// Proving Inheritance
console.log(example instanceof Object);     // true

// Behaves like an object in key ways
example["anotherCustomProperty"] = "another custom property";
console.log(example.anotherCustomProperty); //  "another custom property"
```

**Primitive Types** :

 These are immutable: once created, their value cannot be changed.
-  When assigning a primitive to a variable, the **value is stored directly** in memory.
-  Assigning one primitive variable to another **copies the value**, not the reference.
-  Modifying the new variable does **not affect** the original.

```js
let a = 5;
let b = a;
b++;
console.log(a); // 5
console.log(b); // 6
```


**Non-Primitive Types** :

**Objects** (including arrays and functions) are **mutable** and stored by reference in memory.
- Assigning an object to another variable copies the **reference**, not the object.
- Changing one variable’s properties affects the other.

```js
let obj1 = { name: "Marko" };
let obj2 = obj1;
obj2.name = "Valentin";
console.log(obj1.password); // "Valentin"

let c = [1, 2, 3];
let d = c;
d.push(4);
console.log(c); // [1, 2, 3, 4]

```
**Cloning Objects** :
To avoid unintended side effects, you may want to clone objects:

**Shallow Clone** :
- Only clones the **top-level** properties.
- Use **Object.assign()** or the spread operato r**(...)**.
- However, if a **nested object** exists, changes will **still affect the original**.

```js
const original = {
  name: "Valentin",
  address: {
    city: "London"
  }
};

// Shallow clone using spread operator
const clone = {...original};

// Modify top-level property
clone.name = "Valentin";

// Modify nested property
clone.address.city = "New York";

console.log(original.name);       // "Marko" (unchanged)
console.log(clone.name);          // "Valentin"

console.log(original.address.city); // "New York" (changed)
console.log(clone.address.city);    // "New York"
```

**Deep Clone** :
- Clones the object **and all nested objects**.
- You can create a deep clone in several ways: using JSON.parse(JSON.stringify(...)) (not recommended due to limitations), writing a manual recursive function, structuredClone() (Modern Browsers/Node), or using a modern library like Lodash with _.cloneDeep.

```js
const original = {
  name: "Valentin",
  address: {
    city: "London"
  }
};

// Deep clone using JSON.stringify() + JSON.parse():
let deepClone = JSON.parse(JSON.stringify(original));

// Modify top-level property
deepClone.name = "Valentin";

// Modify nested property
deepClone.address.city = "New York";

console.log(original.name);       // "Marko" (unchanged)
console.log(deepClone.name);          // "Valentin"

console.log(original.address.city); // "London" (Unchanged)
console.log(deepClone.address.city);    // "New York"
```

Types in Javascript

Javascript data Types: primitives, non-primitives, type cercion, pass by value, pass by reference, shalow and deep copy

Javascript data types

Types in Javascript