Typescript 是'；这是'；构造函数中导入的成员数量过多？_Typescript_Angular5

Typescript 是'；这是'；构造函数中导入的成员数量过多？

typescript

Typescript 是'；这是'；构造函数中导入的成员数量过多？,typescript,angular5,Typescript,Angular5,在Angular2+示例中，我经常看到在构造函数中作为参数传递的导入模块被“this.”符号引用。这对我来说是有意义的，因为他们是班级的成员，因此应该可以通过班级的“自我”访问他们。一般来说，代码是这样的： import { Component } from '@angular/core'; import { SomeModule } from '@somewhere'; @Component({ ... }) export class SomeComponent { construct

在Angular2+示例中，我经常看到在构造函数中作为参数传递的导入模块被“this.”符号引用。这对我来说是有意义的，因为他们是班级的成员，因此应该可以通过班级的“自我”访问他们。一般来说，代码是这样的：

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   this._importedModule.doesSmethingSpecial();
  }
}

new_member_from_outside = is_something_external;

class SomeClass extends Something { 
        some_variable: some_type; 

        constructor( new_member_from_outside ) {
            this.some_variable = new_member_from_outside.doingSomethingSpecial();
        }
    }

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   _importedModule.doesSomethingSpecial();
  }
}

constructor(foo: string)

然而，在TypeScript示例中，我经常看到使用“self”引用。我的意思是这样的：

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   this._importedModule.doesSmethingSpecial();
  }
}

new_member_from_outside = is_something_external;

class SomeClass extends Something { 
        some_variable: some_type; 

        constructor( new_member_from_outside ) {
            this.some_variable = new_member_from_outside.doingSomethingSpecial();
        }
    }

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   _importedModule.doesSomethingSpecial();
  }
}

constructor(foo: string)

因此，我开始在Angular2+代码中使用它，如下所示：

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   this._importedModule.doesSmethingSpecial();
  }
}

new_member_from_outside = is_something_external;

class SomeClass extends Something { 
        some_variable: some_type; 

        constructor( new_member_from_outside ) {
            this.some_variable = new_member_from_outside.doingSomethingSpecial();
        }
    }

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   _importedModule.doesSomethingSpecial();
  }
}

constructor(foo: string)

代码运行正常，没有错误，我的IDE中没有linter blood，但我的代码的审阅者将其重写为使用“this”，并评论说我没有正确使用范围。我想知道。我的方法有缺陷吗？这是不礼貌吗？如果是的话，我的方法到底是如何影响范围的？我问我的评论者，答案是->研究范围（有用：D）。从我读到的内容来看，我真的不能说这很糟糕，有多糟糕。

你很困惑，你的审稿人似乎也很困惑。首先，构造函数参数不是“导入”。它们是争论

如果您有这样的构造函数：

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   this._importedModule.doesSmethingSpecial();
  }
}

new_member_from_outside = is_something_external;

class SomeClass extends Something { 
        some_variable: some_type; 

        constructor( new_member_from_outside ) {
            this.some_variable = new_member_from_outside.doingSomethingSpecial();
        }
    }

import { Component  } from '@angular/core';
import { SomeModule } from '@somewhere';

@Component({ ... })
export class SomeComponent {
  constructor( private _importedModule: SomeModule ) {
   _importedModule.doesSomethingSpecial();
  }
}

constructor(foo: string)

然后

foo

是一个参数，并且只是一个参数。它不是对象的属性。因此，使用

this.foo

将是一个错误。它只是一个常规参数，仅在构造函数内部可见（即局部变量）

如果在参数前面添加可见性修饰符（private、protected、public），则它也将成为属性。即此代码

constructor(private foo: string) {}

等同于此代码：

private foo: string;

constructor(private foo: string) {
  this.foo = foo;
}

因此，在这样的构造函数中，

foo

既是一个局部变量，可用于

foo

，也是一个私有属性，可用于

this.foo

。两个变量引用相同的值，因此使用

foo.length

（例如）或

这个.foo.length

是等效的。

您感到困惑，您的审阅者似乎也感到困惑。首先，构造函数参数不是“导入”。它们是争论