TS提供了getter和setter，使对象属性能够更好地控制如何在对象外部访问(getter)或更新(setter)。不是直接访问或更新属性，而是调用代理函数。

例子:

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

    private _name: string;

    get name() {
        return this._name;
    }

    // first checks the length of the name and then updates the name.
    set name(name: string) {
        if (name.length > 10) {
            throw new Error("Name has a max length of 10");
        }

        this._name = name;  
    }

    doStuff () {
        this._name = 'foofooooooofoooo';
    }


}

const person = new Person('Willem');

// doesn't throw error, setter function not called within the object method when this._name is changed
person.doStuff();  

// throws error because setter is called and name is longer than 10 characters
person.name = 'barbarbarbarbarbar';  

如果你正在寻找在任何对象(不是类)上使用get和set的方法，代理可能是有用的: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy

const target = {
  message1: "hello",
  message2: "everyone"
};

const handler3 = {
  get: function (target, prop, receiver) {
    if (prop === "message2") {
      return "world";
    }
    return Reflect.get(...arguments);
  },
};

const proxy3 = new Proxy(target, handler3);

console.log(proxy3.message1); // hello
console.log(proxy3.message2); // world

注意:请注意，这是不支持的新api，旧浏览器需要polifill

尽管TypeScript会分析属性的初始化，但如果你总是想自己处理这种情况，你可以在ts.config.json中将此设置设置为false。

{  
  "compilerOptions": {    
    "strict": true,
    "strictPropertyInitialization": false       
  }  
}

严格属性初始化- strictPropertyInitialization设置时 为true时，当类属性为时，TypeScript将引发错误 在构造函数中声明但未设置。

在这种情况下，您还应该考虑其他情况，您将在下面的链接中看到。

class UserAccount {
  name: string;
  accountType = "user";
 
  email: string;//Property 'email' has no initializer and is not definitely assigned in the constructor.
  address: string | undefined;
 
  constructor(name: string) {
    this.name = name;
    // Note that this.email is not set
  }
}

This.name是专门设置的。 这一点。默认设置为accountType。 这一点。未设置电子邮件并引发错误。 这一点。地址声明为潜在未定义，这意味着它不需要设置。

如果我们将strictPropertyInitialization设置为false，编译器不会引发错误

  private _name : string;
  public get name() : string {
    return this._name;
  }
  public set name(v : string) {
    this._name = v;
  }

https://www.typescriptlang.org/docs/handbook/2/classes.html#--strictpropertyinitialization https://www.typescriptlang.org/tsconfig#strictPropertyInitialization

TypeScript使用getter/setter语法，类似于ECMAScript4/ActionScript3。

class foo {
    private _bar: boolean = false;
    get bar(): boolean {
        return this._bar;
    }
    set bar(value: boolean) {
        this._bar = value;
    }
}

然而，为了使用它，你必须确保TypeScript编译器的目标是ECMAScript5或更高。如果你正在运行命令行编译器，使用——target标志，像这样;

tsc --target ES5

如果你正在使用Visual Studio，你必须编辑你的项目文件，为TypeScriptCompile构建工具的配置添加标志。你可以在这里看到:

这将使用ECMAScript 5 Object.defineProperty()特性生成这个JavaScript。

var foo = (function () {
    function foo() {
        this._bar = false;
    }
    Object.defineProperty(foo.prototype, "bar", {
        get: function () {
            return this._bar;
        },
        set: function (value) {
            this._bar = value;
        },
        enumerable: true,
        configurable: true
    });
    return foo;
})();

最新版本的EcmaScript将生成更像原始TypeScript的代码。例如，针对EcmaScript2017将产生:

"use strict";
class foo {
    constructor() {
        this._bar = false;
    }
    get bar() {
        return this._bar;
    }
    set bar(value) {
        this._bar = value;
    }
}

所以要使用它，

var myFoo = new foo();
if(myFoo.bar) {         // calls the getter
    myFoo.bar = false;  // calls the setter and passes false
}

正如下面@DanFromGermany所建议的，如果你只是读写一个本地属性，比如foo。Bar = true，则setter和getter对是多余的。如果以后需要做一些事情，比如在读取或写入属性时，您总是可以添加它们。

getter可以用来实现只读属性。下面的示例还展示了getter如何与只读类型和可选类型交互。

//
// type with optional readonly property.
// baz?:string is the same as baz:string|undefined
//
type Foo = {
    readonly bar: string;
    readonly baz?: string;
}
const foo:Foo = {bar: "bar"}
console.log(foo.bar) // prints 'bar'
console.log(foo.baz) // prints undefined

//
// interface with optional readonly property
//
interface iFoo {
    readonly bar: string;
    readonly baz?: string;
}

const ifoo:iFoo = {bar: "bar"}
console.log(ifoo.bar)  // prints 'bar'
console.log(ifoo.baz)  // prints undefined


//
// class implements bar as a getter, 
// but leaves off baz.
//
class iBarClass implements iFoo {

    get bar() { return "bar" }
}
const iBarInstance = new iBarClass()
console.log(iBarInstance.bar) // prints 'bar'
console.log(iBarInstance.baz) // prints 'undefined'
// accessing baz gives warning that baz does not exist 
// on iBarClass but returns undefined
// note that you could define baz as a getter
// and just return undefined to remove the warning.


//
// class implements optional readonly property as a getter
//
class iBazClass extends iBarClass {
    private readonly _baz?: string

    constructor(baz?:string) {
        super()
        this._baz = baz
    }

    get baz() { return this._baz; }
}

const iBazInstance = new iBazClass("baz")
console.log(iBazInstance.bar)  // prints bar
console.log(iBazInstance.baz)  // prints baz

如果你正在使用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 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;
    } 

}