How about converting a bespoke object into a JSON format and then reverting it back to its

Question

How about converting a bespoke object into a JSON format and then reverting it back to its

While I have come across similar inquiries before, I am still unclear on whether they were answered satisfactorily - perhaps I'm just not grasping it well enough, my apologies.

I am aiming for the convenience and clarity of having my own object named CardboardBox(). This object will solely contain data without any code. My goal is to be able to store this object in a database and retrieve it later, while understanding that it will be classified as type Object() when retrieved. The only method I can think of to determine its original form is:

Include a member variable type that denotes CARDBOARD_BOX
Create a new instance of CarbardBox() and utilize a function within the box to transfer the properties from Object() to the new CardboardBox() object

Is there a more efficient approach to accomplish this task? I believe there might be a way to modify the actual type.

function CardboardBox() { 
  this.type = "CARDBOARD_BOX"
  this.name = "No set";
  this.populate = new function(obj) {
    // populate this object with obj properties 
}

var box = new CarboardBox();  // CarboardBox
box.name = "My Box";
send = JSON.stringyfy(box);   
.
.
.
obj = JSON.parse(send);    // Object

if (obj.type == "CARDBOARD_BOX") {
  savedBox = new CardboardBox();
  savedBox.populate(obj);
}

Thank you in advance... Steve

[edit] Testing Code Below.

function CardboardBox(n) {
  this.name = n;
}

var box = new CardboardBox("My Box");
send = JSON.stringify(box); // JSON CarboardBox()

obj = JSON.parse(send, function fn(obj) { // Object() returned
  log("OB: "+obj.type);
  return obj.type === 'CardboardBox' ? new CardboardBox(obj) : CardboardBox; 
});     
console.log(obj);

Output displayed:

OB: undefined utils.js:40
OB: undefined utils.js:40
function CardboardBox(n) {
    this.name = n;
}

javascript json object

Answer 1

Answer №1

Here is a potential solution that you can use:

function CardboardBox(n) {
  if(typeof(n) == 'string') {
    //build from name string
    this.name = n;
  } else {
    //build from object
    this.name = n.name;
  }

  //add in this object's "type" in a place
  //that is unlikely to exist in other JSON strings
  this.__type = 'CardboardBox';
}

var box = new CardboardBox("My Box");
send = JSON.stringify(box), // JSON CarboardBox()
obj = JSON.parse(send, function(key, val) {
  //if this is an object, and is CardboardBox
  if(typeof(val) === 'object' && val.__type === 'CardboardBox')
      return new CardboardBox(val);

  return val;

  //or if your object is in a context (like window), and there are many of
  //them that could be in there, you can do:
  //
  //if(typeof(val) === 'object' && context[val.__type])
  //    return new context[val.__type](val);
});


console.log(obj);

This method involves storing the object type in a specific location within the JSON so that it can be easily identified during parsing. If you have multiple objects that need to be instantiated within the same scope, the second parse method provided may be more suitable. It also handles cases where objects in the JSON data are not instances of CarboardBox.

Edit To see this method in action, check out this jsFiddle.

Answer 2

Here is a potential solution that you can use:

function CardboardBox(n) {
  if(typeof(n) == 'string') {
    //build from name string
    this.name = n;
  } else {
    //build from object
    this.name = n.name;
  }

  //add in this object's "type" in a place
  //that is unlikely to exist in other JSON strings
  this.__type = 'CardboardBox';
}

var box = new CardboardBox("My Box");
send = JSON.stringify(box), // JSON CarboardBox()
obj = JSON.parse(send, function(key, val) {
  //if this is an object, and is CardboardBox
  if(typeof(val) === 'object' && val.__type === 'CardboardBox')
      return new CardboardBox(val);

  return val;

  //or if your object is in a context (like window), and there are many of
  //them that could be in there, you can do:
  //
  //if(typeof(val) === 'object' && context[val.__type])
  //    return new context[val.__type](val);
});


console.log(obj);

This method involves storing the object type in a specific location within the JSON so that it can be easily identified during parsing. If you have multiple objects that need to be instantiated within the same scope, the second parse method provided may be more suitable. It also handles cases where objects in the JSON data are not instances of CarboardBox.

Edit To see this method in action, check out this jsFiddle.

Answer 3

Answer №2

Indeed, it is true that Javascript lacks a built-in mechanism for serializing anything beyond plain objects. As a result, the process of converting data to and from JSON does not maintain class information upon deserialization. Therefore, developers are required to handle serialization and deserialization on their own or utilize a third-party library for assistance.

In my experience, I have found Backbone.js to be quite effective in managing serialization and deserialization tasks. With Backbone.js, one can define a model class with methods for saving data to a server in serialized form and reconstructing the model from serialized data. The crucial aspect here is that deserialization is carried out with knowledge of the specific model being targeted:

You can retrieve data from the server based on the model ID by invoking myModel.fetch().
To create a new model instance from serialized data, you can use new Model(serializedData).
If dealing with multiple models, an array of serialized data can be passed to a collection that understands the model type:
```
new ModelCollection(arrayOfSerializedData)
```
.

However, Backbone does not offer direct support for casting data of unknown types. In cases where this is necessary, a common approach involves utilizing an intermediary such as a proxy model or factory function, similar to the methodology mentioned in @Chad's response:

var classes = {
    CardboardBox: ...,
    AluminumBox: ...
}

function Deserializer(json) {
    var data = JSON.parse(json),
        type = data.type,
        Cls = classes[type] || DefaultType;
    return new Cls(data);
}

var obj = new Deserializer(send);
obj instanceof CardboardBox; // should yield expected results

It remains essential to incorporate a custom type flag for switching between different data types during deserialization.

Answer 4

Indeed, it is true that Javascript lacks a built-in mechanism for serializing anything beyond plain objects. As a result, the process of converting data to and from JSON does not maintain class information upon deserialization. Therefore, developers are required to handle serialization and deserialization on their own or utilize a third-party library for assistance.

In my experience, I have found Backbone.js to be quite effective in managing serialization and deserialization tasks. With Backbone.js, one can define a model class with methods for saving data to a server in serialized form and reconstructing the model from serialized data. The crucial aspect here is that deserialization is carried out with knowledge of the specific model being targeted:

You can retrieve data from the server based on the model ID by invoking myModel.fetch().
To create a new model instance from serialized data, you can use new Model(serializedData).
If dealing with multiple models, an array of serialized data can be passed to a collection that understands the model type:
```
new ModelCollection(arrayOfSerializedData)
```
.

However, Backbone does not offer direct support for casting data of unknown types. In cases where this is necessary, a common approach involves utilizing an intermediary such as a proxy model or factory function, similar to the methodology mentioned in @Chad's response:

var classes = {
    CardboardBox: ...,
    AluminumBox: ...
}

function Deserializer(json) {
    var data = JSON.parse(json),
        type = data.type,
        Cls = classes[type] || DefaultType;
    return new Cls(data);
}

var obj = new Deserializer(send);
obj instanceof CardboardBox; // should yield expected results

It remains essential to incorporate a custom type flag for switching between different data types during deserialization.

How about converting a bespoke object into a JSON format and then reverting it back to its

Answer №1

Answer №2

Similar questions

assign classes to elements with ids falling within a specified range

When you click on one checkbox, the angular2-multiselect dropdown automatically selects all the boxes

What is the best way to test chained function calls using sinon?

Stop initiating the HTTP fetch() requests

Dealing with unwanted sorting of x-axis in Plot.ly for R

MongoDB's conditional aggregation function allows users to manipulate and aggregate data based

Can the value of the currently selected option in a select box be obtained without needing to submit the form?

Querying mongoose with $near or other fields

Using the 'onended' audio event emitter in Angular 2 along with a local member of the Component

"Utilizing MongoDB NodeJS Query Logic for Seamless Data Retrieval

Manipulating CSS styles through Javascript with passed parameters

What is the best way to store objects containing extensive binary data along with additional values?

NextJS 13 causes tailwind to malfunction when route group is utilized

Resetting input fields that are not associated with a form in React involves manually setting the values of

WebPack bundling causing issues with Knockout Validation

The node path.relative function is providing inaccurate path information

Creating a collapsible navbar using JavaScript

Navigation menu with submenus containing buttons

What are some ways I can incorporate modular constants into my Firebase Functions?

JQuery experiencing compatibility issues in both Firefox and Chrome