ts中访问修饰符有那些，分别有什么作用

在 TypeScript 中，有三种访问修饰符：public、private 和 protected。

public 默认就是公共的，可以在任何地方访问到该成员。
private 表示私有的，只能在类的内部被访问。
protected 表示受保护的，可以在派生类中被访问。

作用如下：
public：可以在该类及其派生类及其它任何地方访问到。
private：只能在该类内部访问，派生类也无法访问。
protected：只能在该类及其派生类中访问，其它地方都不能访问。

相关问题

ts类的修饰符

TypeScript中类的修饰符有以下几种：

1. public

public是默认修饰符，即不写修饰符时默认为public。public修饰的属性或方法可以在类的内部和外部使用。

2. private

private修饰的属性或方法只能在类的内部使用，无法在类的外部使用。

3. protected

protected修饰的属性或方法可以在类的内部和子类中使用，但无法在类的外部使用。

4. readonly

readonly修饰的属性只能在初始化时或构造函数中赋值，之后就无法再修改。

示例代码：

class Person {
  public name: string; // 公共属性
  private age: number; // 私有属性
  protected gender: string; // 保护属性
  readonly id: number; // 只读属性

  constructor(name: string, age: number, gender: string, id: number) {
    this.name = name;
    this.age = age;
    this.gender = gender;
    this.id = id;
  }

  public sayHello() { // 公共方法
    console.log(`Hello, my name is ${this.name}.`);
  }

  private getAge() { // 私有方法
    return this.age;
  }

  protected getGender() { // 保护方法
    return this.gender;
  }
}

class Student extends Person {
  public getGenderAndAge() {
    console.log(`My gender is ${this.getGender()} and age is ${this.getAge()}.`);
  }
}

const person = new Person('Tom', 18, 'male', 1001);
console.log(person.name); // Tom
// console.log(person.age); // 无法访问
// console.log(person.gender); // 无法访问
// person.id = 1002; // 无法修改
person.sayHello(); // Hello, my name is Tom.

const student = new Student('Jerry', 17, 'female', 1002);
// console.log(student.age); // 无法访问
// console.log(student.gender); // 无法访问
console.log(student.name); // Jerry
console.log(student.id); // 1002
student.getGenderAndAge(); // My gender is female and age is undefined.

在上面的示例代码中，我们定义了一个Person类，其中包含了公共属性、私有属性、保护属性、只读属性、公共方法、私有方法和保护方法。这些属性和方法都有不同的修饰符，可以在不同的场景下使用。同时，我们还定义了一个Student类，继承自Person类，可以访问Person类中的保护属性和保护方法。

ts 装饰器的access

TS 装饰器的 `access` 是一个访问器装饰器，用于修饰类中的 getter 和 setter 方法。它可以接收三个参数：`target`、`propertyKey` 和 `descriptor`，分别表示装饰的目标类、属性名和属性描述符。

当我们使用 `access` 装饰器修饰一个 getter 或 setter 方法时，它会在运行时自动调用，并将目标类的实例、属性名和属性描述符作为参数传入。我们可以在装饰器函数中对这些参数进行处理，从而实现一些特定的功能，比如对属性进行拦截、修改或验证等。

下面是一个使用 `access` 装饰器的示例：

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  @access
  get name() {
    return this._name;
  }

  @access
  set name(value: string) {
    this._name = value;
  }
}

function access(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  console.log(`Accessing ${propertyKey} of ${target.constructor.name}`);
  console.log(`Descriptor:`, descriptor);
}

在上面的示例中，我们定义了一个 `Person` 类，并使用 `access` 装饰器修饰了它的 `name` 属性的 getter 和 setter 方法。当我们创建一个 `Person` 实例并访问它的 `name` 属性时，装饰器函数会自动调用，并输出一些信息。