The way that ll work in all browsers is to either augment each item in the array with the properties and methods you want, or pass the object to a constructor and create a new object based on the old object s properties and methods.

Or if you don t care about IE:

var obj = {
    name : "Jeremy"
};

function CustomType() {
    this.name = this.name || "someValue";
    this.greeting = "Hi";
}

CustomType.prototype.sayHi = function() {
    alert(this.greeting + ", " + this.name);
};

obj.__proto__ = CustomType.prototype;
obj.constructor.call(obj);

obj.sayHi();

I do not believe that there is any way to change the type of an object once it is created. Fortunately, you probably don t actually need to change the class, of your objects -- you will probably be satisfied with giving the objects some new methods and other functionality. (The only real difference is what would happen if you CHANGED the class, and most people don t change classes while code is running.)

I ll work an example for you. First, I ll create a simple object to represent the JSON objects you have:

var myobj = new Object()
myobj.name = "Fred"

Then I will create some class that you would like to be able to assign to myobj:

function Speaker() {
    this.speak = function() {
        window.alert("Hello, " + this.name);
    }
}

This new Speaker class has some useful functionality: it can use the method speak() to output useful information:

var s = new Speaker()
s.name = "Sally"
s.speak()

Executing that gave me the message "Hello, Sally". Unfortunately, you don t want a NEW object (like s) with this functionality, you want the existing object (myobj) to have it. Here is how you do that:

myobj.speak = s.speak

Now when I execute this:

myobj.speak()

I see the message "Hello, Fred".

To summarize: create an object that does what you want. Copy all the methods (and any helper variables) into your new object. Except for some unusual uses of inheritance, this will make your new object behave as desired.

If you don t need constructor, you can do as:

Object.assign(new CustomType, {});

If you want to use a specific method on them you can use apply/call.

Or you can copy the methods for your custom object.

function Object1() {
  this.aValue = "10";
}

function CustomObject() {
  this.customValue = "6";
}

function convertToCustom(obj) {
  var custom = new CustomObject();
  for( var key in obj ) {
    custom[key] = obj[key];
  }
  return custom;
}

var obj = new Object1();
var custom = convertToCustom(obj);

console.log(custom.customValue); // <- 6
console.log(custom.aValue);      // <- 10

As a complement to Jeremy s answer, you could use Object.create instead of directly playing with proto. You ll also need an "extend" function.

So, given Jeremy s example, you could have something like this:

var obj = {
name : "Jeremy"
};


function CustomType() {
}

CustomType.prototype.init = function(){
    this.name = this.name || "someValue";
    this.greeting = "Hi";
    return this; //let s make it fluent
}

CustomType.prototype.sayHi = function() {
    console.log(this.greeting + ", " + this.name);
};

function extend(obj, props) { 
    for(prop in props) { 
        if(props.hasOwnProperty(prop)) { 
            obj[prop] = props[prop]; 
        } 
    }
    return obj; //let s make it fluent
}

obj = extend(Object.create(CustomType.prototype), obj).init();

obj.sayHi();