2022.7.26 constructor, interview: the role of new, deep copy and shallow copy

One 、 How to write a constructor

1. Fixed parameter （ Not recommended ）

  function Car(name, color, suv) {
    this.name = name;
    this.color = color;
    this.suv = suv;
  }
  var benchi = new Car("benchi", "red", true);
  console.log(benchi);

  When using this method, you need to pay attention to ：

• Know object properties clearly

• The position should be strictly corresponding

2. Object type parameter

    function Car(obj) {
      this.name = obj.name;
      this.size = obj.size;
      this.color = obj.color;
      this.suv = obj.suv;
    }
    var audi = new Car({ size: "big", name: "audi", suv: true, color: "red" });
    console.log(audi);

Even if the transfer order is different, it will not affect and it is convenient to maintain , Easy to use features , Recommended .

Two 、new The role of （ interview ）

1. If not new Call the constructor directly , Will prompt undefined

function Student(obj) {
  this.name = obj.name;
  this.score = obj.score;
  this.grade = obj.grade;
}
var stu1 = Student({
  name: 'Jack',
  score: 88,
  grade: 3,
});
console.log(stu1);

         From this we can determine ,new The first function of is to return the object （ Similar to function without return Will prompt undefined ）.

2. If there is no new In case of printing this , Find out this Point to window .

function Student(obj) {
  this.name = obj.name;
  this.score = obj.score;
  this.grade = obj.grade;
  console.log(this);
}
var stu1 = Student({
  name: 'Jack',
  score: 88,
  grade: 3,
});

        thus it can be seen new The second function of , Put the this Points to the object to be returned .

3. summary new effect ：

• Created a new empty object
• Assign the scope of the constructor to the new object (this Point to a new object )
• Execute constructor code （ Add properties for this new object ）
• Return to new object

  3、 ... and 、 Deep copy and shallow copy （ interview ）

1. Shallow copy

         Definition ： For reference types , Refers to two reference types pointing to the same address , Change one , The other will change with it .

    var person1 = { age: 20 };
    var person2 = person1;
    person1.age = 25;
    console.log("person1:", person1, "person2:", person2);

 2. Deep copy

        Definition ： For reference types , After copying, the reference type points to a new memory address , Two object changes do not affect each other .

    var p1 = { age: 18 };
    //JSON.stringify serialize  JSON.parse Deserialization 
    var p2 = JSON.parse(JSON.stringify(p1));
    p1.age = 20;
    console.log(p2);

          Be careful ： The assignment of basic type data is similar to that of deep copy , But it's not a deep copy .

    var a = 1;
    var b = a;
    a = 10;
    console.log(a, b); // 10 1

         Be careful ： Array of concat、slice Is a deep copy of a layer of objects , If the sub attribute of an object is a reference type , Shallow copy .

    var a = [1, 2, 3];
    var b = [4, 5];
    var ab = a.concat(b);
    a = [2, 3];

    console.log(ab); // [1,2,3,4,5]