# Serialization and it's Challenges in JavaScript

# Serialization

Serialization is the process of converting a data structure, such as JavaScript object or array, into a format that can be easily stored.

In JavaScript, the most common serialization format is JSON (JavaScript Object Notation). The JSON format is easy for both human and machine to read and write.

# Deserialization

Deserialization is the opposite process of Serialization. It converts data in its serialized format into its original data structure, such as a JavaScript object or array, to make the data usable and accessible in the application.

# Types of Serialization formats

1. JSON Serialization
    
2. BSON Serialization
    
3. URL Encoding
    

## JSON Serialization

This is most widely used method for serializing and deserializing objects. `JSON.stringify()` method is used to convert the Object/array into a string and `JSON.parse()` is used to convert them back to array or object format.

```javascript
const obj = {
name: "abhay",
age: 25,
gender: "male",
}

const seializedObj = JSON.stringify(obj) //output : "{"name":"abhay","age":25,"gender":"male"}"
const deserialedObj = JSON.parse(seializedObj) // output : { name: 'abhay', age: 25, gender: 'male' }
```

## BSON Serialization

BSON (binary-encoded data interchange) is more efficient in terms of storage and transmission in compared to JSON. It extends JSON with additional data types and is typically used in context of MongoDB.

```javascript
import { BSON, ObjectId } from 'bson';

const data = { _id: new ObjectId(), name: "John", age: 30 }

// serialization

const bytes = BSON.serialize(data);
// Output: <Buffer 2e 00 00 00 07 5f 69 64 00 64 ca 53 01 9d 14 77 b6 a1 a2 89 e4 02 6e 61 6d 65 00 05 00 00 00 4a 6f 68 6e 00 10 61 67 65 00 1e 00 00 00 00>

// deserialization

const doc = BSON.deserialize(bytes);
// Output: {
//  _id: new ObjectId("64ca53019d1477b6a1a289e4"),
//  name: 'John',
//  age: 30
// }
```

## URL Encoding

This is most widely used method for serializing and deserializing data in URL’s. `encodeURI()` is used to encode the data and `decodeURI()` is used to decode the data passed in URL.

```javascript
const uri = 'https://xyx.org/?x=шелы';
const encoded = encodeURI(uri);
console.log(encoded);
// output: "https://xyx.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B"

console.log(decodeURI(encoded));
// output: "https://xyx.org/?x=шеллы"
```

# Challenges in Serialization

1. Data Loss
    
2. Data Corruption
    
3. Format Incompatibility
    

## Data Loss

When data is too large, `JSON.stringify` can cause **performance issues** and even **data loss** in extreme cases.

Example:

1. Serializing a huge object can freeze the main thread, causing UI lag in the browser.
    
2. If the serialized string is too big, it may exceed memory limits, leads to memory overflow and system crash.
    
3. If an object has circular references (where two properties reference each other), `JSON.stringify` will throw an error.
    

## Data Corruption

When dealing with deeply nested objects or large arrays of objects, serialization can lead to data corruption. example If the object is too deep, JavaScript might throw a `RangeError: Maximum call stack size exceeded` error

## Format Incompatibility

When handling **large datasets**, format incompatibility can arise due to several reasons. Example: Floating-Point Precision Issues, Character Encoding Differences etc.

### Reference

1. **Muhammad A Faishal “**[Serialization and Deserialization in JavaScript](https://dev.to/maafaishal/serialization-and-deserialization-in-javascript-3kdd)”