JavaScript Object Copy Method

In the previous JavaScript article tutorial - Some Essential JavaScript Prototype Functions to Enhance your JavaScript Applications - jsB@nk presented to you one JavaScript prototype function to copy/clone a JavaScript object, but in this post, there's only JavaScript source code to make it without detailed instructions and comments.

Therefore, in this JavaScript article tutorial, jsB@nk will show you a full detailed instructions and guides in copying JavaScript objects with many JavaScript example codes and many ways to use.


Sampled by © JavaScriptBank.com

Everyone knows Javascript doesn’t have classes. Thankfully most Javascript programmers are very good at playing pretend.

Because so many people attempt to introduce a classical structure to their Javscript code, I figure I’ll share some of my findings. Below is one way of allowing a base class function to copy an instance of a subclass while maintaining proper type.

Let’s say we have an Animal class and we subclass it to create a Cat class. We also want the Animal class to have a clone() method that will return work with its subclasses. That is, if I clone a Cat, I want “instanceof Cat” and “instanceof Animal” to both be true.

Let’s make the classes real quick. Here’s an Animal:

function Animal() {

  // animal stuff
}
 
// All of Animal's methods will go into its prototype
Animal.prototype = {
  saySomething: function() {

    return "I am an animal!";
  },
 
  copy: function() {

    var newcopy;
    if (this.subConstructor) {

      newcopy = new this.subConstructor;
    } else {

      newcopy = new Animal();
    }
 
    // maybe copy over other values

 
    return newcopy;
  }
};

And then the Cat. Typically the easiest way to make a Javascript function be a “subclass” of another function is to set the prototype of the subclass equal to “new baseclass.” With cat we’ll go a little further and also save the constructor.

Cat:

function Cat() {
  this.constructor(); // call animal's constructor

  // cat stuff
}
 
// Save the cat's constructor, replace Cat's prototype and constructor
// Then restore cat's constructor as subConstructor
var con = Cat.prototype.constructor;

Cat.prototype = new Animal();
Cat.prototype.constructor = Animal;

Cat.prototype.subConstructor = con
 
// override the saySomething function
Cat.prototype.saySomething = function() {

  return "Meow!";
};

There you have it. Cats created this way will be “instanceof Cat” and “instanceof Animal”, and so will their clones. We should of course make tests to see, and lucky for us all of them check out OK:

// some tests and their results in the comment
 
var c = new Cat();

console.log(c instanceof Animal);   // true
console.log(c instanceof Cat);      // true

console.log(c.saySomething());      // "Meow!"
 
var a = new Animal();

console.log(a instanceof Animal);   // true
console.log(a instanceof Cat);      // false

console.log(a.saySomething());      // "I am an animal!"
 
var copyCat = c.copy();

console.log(copyCat instanceof Animal); // true
console.log(copyCat instanceof Cat);    // true

console.log(copyCat.saySomething());    // "Meow!"
 
var copyAnimal = a.copy();

console.log(copyAnimal instanceof Animal); // true
console.log(copyAnimal instanceof Cat);    // false

console.log(copyAnimal.saySomething());    // "I am an animal!"

You might want to use the four lines needed for subclassing elsewhere so its a good idea to stuff them into a function that you’d put in a utility class/var somewhere. So we could make:

function derive(base, sub) {

  var con = sub.prototype.constructor;
  sub.prototype = new base();

  sub.prototype.constructor = base;
  sub.prototype.subConstructor = con

}

And then making a clone-able subclass would be as easy as calling derive after each constructor:

function Cat() {
  this.constructor(); // call animal's constructor

  // cat stuff
}
 
derive(Animal, Cat);
 
// override the saySomething function

Cat.prototype.saySomething = function() {
  return "Meow!";

};

Language
Translate this page to English Translate this page to French Translate this page to Vietnamese

Recent articles
Migrate to Angular: why and how you should do it
The Possible Working Methods of Python Ideology
JavaScript Research Paper: 6 Writing Tips to Craft a Masterpiece
Learning How to Make Use of New Marketing Trends
5 Important Elements of an E-commerce Website
How To Create A Successful Prototype For Your PCB
WordPress Landing Page Conversion Essentials to Convert More
Lifeasapa and Neurosphere
4 Development Hacks To Make Your Website Launch A Success
Why Data Recovery Software and Services are Important


Top view articles
Top 10 Beautiful Christmas Countdown Timers
65 Free JavaScript Photo Gallery Solutions
Best Free Linux Web Programming Editors
Top 50 Most Addictive and Popular Facebook mini games
Top 10 Free Web Chat box Plug-ins and Add-ons
Top 10 Best JavaScript eBooks that Beginners should Learn
50+ Beautiful Resources of HTML Form using CSS and JavaScript
The Ultimate JavaScript Tutorial in Web Design
HTML5 Web Workers Multithreading in JavaScript
Learn more about JavaScript Inheritance with Tiny JavaScript Example Codes


Free JavaScript Tutorials & Articles
at www.JavaScriptBank.com