Explore JavaScript: elegant encapsulation or execution efficiency? (1)

An elegantly encapsulated program looks so beautiful: after each property is hidden in an object, what you can see is what this object shows you, and how it operates, you don't need to worry about this.

The execution efficiency is another thing. It is like the difference between C language and object-oriented C ++: C ++ is elegant, but the execution efficiency, whether it is the binary code after compilation or the memory usage during runtime, it is more than a simple C language.

This problem is more important in the scripting language, because JavaScript is simply an interpreted language, and the execution efficiency of the interpreted language is much lower than that of the compiled language.

1. Elegant Encapsulation

Let's take a look at variable encapsulation. The variables here are not only attributes, but also functions. As mentioned above, JavaScript does not have the class concept. It is an elegant implementation that uses the variable scope and closure to "cleverly simulate" it. Let's take a look at the previous Code:

 
 

  
  
function Person() {     
  
  
    var id;     
  
  
    var showId = function() {     
  
  
        alert("My id is " + id);     
  
  
    }     
  
  
    this.getId = function() {     
  
  
        return id;     
  
  
    }     
  
  
    this.setId = function(newId) {     
  
  
        id = newId;     
  
  
    }     
  
  
}     
  
  
var p = new Person();     
  
  
p.setId(1000);     
  
  
alert(p.id); // undefined     
  
  
// p.showId(); error: function not defined     
  
  
var p2 = new Person();     
  
  
alert(p.getId == p2.getId); // false    
  
  
 
  
  
function Person() {  
  
  
    var id;  
  
  
    var showId = function() {  
  
  
        alert("My id is " + id);  
  
  
    }  
  
  
    this.getId = function() {  
  
  
        return id;  
  
  
    }  
  
  
    this.setId = function(newId) {  
  
  
        id = newId;  
  
  
    }  
  
  
}  
  
  
var p = new Person();  
  
  
p.setId(1000);  
  
  
alert(p.id); // undefined  
  
  
// p.showId(); error: function not defined  
  
  
var p2 = new Person();  
  
  
alert(p.getId == p2.getId); // false  
 
 

We elegantly implement private variables-although opportunistic. But what is the problem with this code? Why are the functions of two objects different?

Think about it. We use the scope of variables to simulate private variables and the closure to simulate public variables. That is to say, in fact, each created object will have a copy of the same code! Not only that id, but also those functions such as showId and getId will be created multiple times. Note that JavaScript Functions are just objects, so they won't be so strange.

But there is no doubt that this is a waste: each variable is different from its own data domain, and the function code is the same, because we perform the same operation. Other languages generally do not encounter this problem, because the functions and object concepts of those languages are different. For example, Java, the methods of each object actually point to copying the same code, instead, each object will have its own code copy.