Question

例如：

function Constructor() {
  this.peoperty = 1;
  this.myMethod1 = function() {
    //do something
  };
  this.myMethod2 = function() {
    let a = myMethod3();
  }
  
  /*no 'this' keyword for myFunction3,because 
    I am not going to call myFunction3 anywhere else,
    except inside this particular Constructor*/
  myMethod3 = function() {
    let b = 0;
    return b;
  };
}

var hello = new Constructor();

我假设使用this关键字创建变量时，new关键字引用实例。

问题是，如果仅在该构造函数中调用myMethod3，我可以不使用this关键字作为{{1 }}，因为我不会在代码中的任何地方使用myMethod3。这样运行时是否会节省一些内存，因为我猜只有与hello.myMethod3绑定的属性/方法会占用每个由this关键字创建的实例的内存空间？

Answer 1

在当前代码中，您并未声明myFunction3，因此该函数将处于全局范围内，并且Constructor的每个新实例都将覆盖先前的myFunction3：

 const instance = new Constructor();
 myFunction3 = () => alert("whoops");
 instance.myFunction2(); // "whoops"

因此，一次只有一个myFunction3，可以节省内存，但是在构造函数中重新声明它就没有意义了（不声明变量永远没有意义）。

假设您使用以下命令正确声明了它：

 function myFunction3() {
   let b = 0;
   return b;
};

那么您根本不会保存任何内存，因为对myFunction3的引用一直保留在您分配给this的其他函数的结尾处，因此myFunction3将必须保持与实例this所指代的内存一样长的时间。如果你这样做

 this.myFunction3 = function() { /*...*/ };

只要this存在，它也将保留在内存中，因此从内存角度来看，它们实际上是相等的。但是myFunction3有点“私有”，因为无法通过this访问。

Answer 2

是的，您的猜测是正确的，如果您在构造函数中声明一个方法，则每个实例都有其自己的定义：

function Cat() {
  this.meow = function() {
    console.log('meow');
  }
}

const cat1 = new Cat();
const cat2 = new Cat();

cat1.meow();
cat2.meow();

console.log(cat1.meow === cat2.meow);

如果使用prototype关键字，则不会发生相同的情况。在这种情况下，两个对象都将具有指向相同定义的指针：

    function Cat() {
    }
    
    Cat.prototype.meow = function() {
      console.log('meow');
    }

    const cat1 = new Cat();
    const cat2 = new Cat();
    
    cat1.meow();
    cat2.meow();

    console.log(cat1.__proto__.meow === cat2.__proto__.meow);

在构造函数中使用'this'关键字是否会整体上增加内存使用量？

2 个答案: