我想我大概知道为什么这么令人困惑了。在您的示例中，我们需要_name的getter和setter。但我们通过为不相关的类变量Name创建getter和setter来实现这一点。

考虑一下:

class Car {
    private tiresCount = 4;
    get yourCarTiresCount(){
        return this.tiresCount;
    }
    set yourCarTiresCount(count) {
        alert('You shouldn\'t change car tire count')
    }
}

上面的代码如下:

get和set为yourCarTiresCount创建getter和setter(不是为tiresCount)。

getter是:

function () {
    return this.tiresCount;
}

setter是:

function (count) {
    alert('You shouldn\'t change car tire count');
}

意思是，每次执行new Car()。yourCarTiresCount, getter运行。并且对于每一个新的Car(). yourcartirescount ('7') setter运行。

间接地为私有ti复述创建getter，而不是setter。

如果你正在使用TypeScript模块，并试图添加一个导出的getter，你可以这样做:

// dataStore.ts
export const myData: string = undefined;  // just for typing support
let _myData: string;  // for memoizing the getter results

Object.defineProperty(this, "myData", {
    get: (): string => {
        if (_myData === undefined) {
            _myData = "my data";  // pretend this took a long time
        }

        return _myData;
    },
});

然后，在另一个文件中:

import * as dataStore from "./dataStore"
console.log(dataStore.myData); // "my data"

下面是一个工作示例，可以为你指明正确的方向:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

    set Name(val) {
        this._name = val;
    }
}

JavaScript中的getter和setter只是普通的函数。setter是一个接受参数的函数，该参数的值就是被设置的值。

我想我大概知道为什么这么令人困惑了。在您的示例中，我们需要_name的getter和setter。但我们通过为不相关的类变量Name创建getter和setter来实现这一点。

考虑一下:

class Car {
    private tiresCount = 4;
    get yourCarTiresCount(){
        return this.tiresCount;
    }
    set yourCarTiresCount(count) {
        alert('You shouldn\'t change car tire count')
    }
}

上面的代码如下:

get和set为yourCarTiresCount创建getter和setter(不是为tiresCount)。

getter是:

function () {
    return this.tiresCount;
}

setter是:

function (count) {
    alert('You shouldn\'t change car tire count');
}

意思是，每次执行new Car()。yourCarTiresCount, getter运行。并且对于每一个新的Car(). yourcartirescount ('7') setter运行。

间接地为私有ti复述创建getter，而不是setter。

你可以这样写

class Human {
    private firstName : string;
    private lastName : string;

    constructor (
        public FirstName?:string, 
        public LastName?:string) {

    }

    get FirstName() : string {
        console.log("Get FirstName : ", this.firstName);
        return this.firstName;
    }
    set FirstName(value : string) {
        console.log("Set FirstName : ", value);
        this.firstName = value;
    } 

    get LastName() : string {
        console.log("Get LastName : ", this.lastName);
        return this.lastName;
    }
    set LastName(value : string) {
        console.log("Set LastName : ", value);
        this.lastName = value;
    } 

}

根据您所展示的示例，您希望通过get()传递一个数据对象并获取该对象的属性。为此需要使用泛型类型，因为数据对象是泛型的，可以是任何对象。

export class Attributes<T> {
    constructor(private data: T) {}
    get = <K extends keyof T>(key: K): T[K] => {
      return this.data[key];
    };
    set = (update: T): void => {
      //   this is like spread operator. it will take this.data obj and will overwrite with the update obj
      // ins tsconfig.json change target to Es6 to be able to use Object.assign()
      Object.assign(this.data, update);
    };
    getAll(): T {
      return this.data;
    }
  }

< T >指泛型类型。让我们初始化一个实例

 const myAttributes=new Attributes({name:"something",age:32})

 myAttributes.get("name")="something"

注意这个语法

<K extends keyof T>

为了能够使用这个，我们应该注意两件事:

1- in typestring字符串可以是一个类型。

2- javascript中所有对象属性本质上都是字符串。

当我们使用get()时，它接收的参数类型是传递给构造函数的对象属性，由于对象属性是字符串，并且字符串在typescript中允许是类型，我们可以使用这个<K extends keyof T>