obtener y establecer a máquina de escribir

Ezward ya ha proporcionado una buena respuesta, pero me di cuenta de que uno de los comentarios se pregunta cómo se utiliza. Para la gente como yo, que tropiezan a través de esta pregunta, pensé que sería útil disponer de un enlace a la documentación oficial sobre captadores y definidores en el sitio web de imprenta, como lo explica así, se espera siempre mantenerse al día ya que los cambios son hecho, y muestra el uso de ejemplo:

http://www.typescriptlang.org/docs/handbook/classes.html

En particular, para aquellos que no están familiarizados con ella, tenga en cuenta que no incorporan la palabra 'conseguir' en una llamada a un captador (y lo mismo para los emisores):

var myBar = myFoo.getBar(); // wrong    
var myBar = myFoo.get('bar');  // wrong

Usted simplemente debe hacer esto:

var myBar = myFoo.bar;  // correct (get)
myFoo.bar = true;  // correct (set) (false is correct too obviously!)

dada una clase como:

class foo {
  private _bar:boolean = false;

  get bar():boolean {
    return this._bar;
  }
  set bar(theBar:boolean) {
    this._bar = theBar;
  }
}

a continuación, se llamará el getter 'bar' para la propiedad privada '_bar'.

Aquí está un ejemplo de trabajo que tiene que introducir en la dirección correcta:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Captadores y definidores en JavaScript son simplemente funciones normales. El colocador es una función que toma un parámetro cuyo valor es el valor que se está establecido.

Es muy similar a la creación de métodos comunes, en pocas palabras la palabra clave reservada geto setal principio.

class Name{
    private _name: string;

    getMethod(): string{
        return this._name;
    }

    setMethod(value: string){
        this._name = value
    }

    get getMethod1(): string{
        return this._name;
    }

    set setMethod1(value: string){
        this._name = value
    }
}

class HelloWorld {

    public static main(){

        let test = new Name();

        test.setMethod('test.getMethod() --- need ()');
            console.log(test.getMethod());

        test.setMethod1 = 'test.getMethod1 --- no need (), and used = for set ';
            console.log(test.getMethod1);
    }
}
HelloWorld.main();

En este caso se puede omitir el tipo de devolución de get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Puede escribir este

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;
    } 

}

TS ofrece captadores y definidores, que permitan a las propiedades del objeto para tener más control de cómo se accede a ellos (captador) o actualizada (setter) fuera del objeto. En lugar de acceder directamente o actualizar la propiedad una función proxy se llama.

Ejemplo:

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';  

Creo que probablemente entiendo por qué es tan confuso. En su ejemplo, queríamos captadores y definidores para _name. Pero lo logramos mediante la creación de captadores y definidores para una variable de clase no relacionada Name.

Considera esto:

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

código hace lo siguiente:

1. gety setcrear getter y setter para yourCarTiresCount( no paratiresCount ).

El comprador es:

function() {
    return this.tiresCount ;
}

y el colocador es:

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

Es decir, cada vez que hacemos new Car().yourCarTiresCount, captador funciona. Y para cada new Car().yourCarTiresCount('7')carreras setter.

2. Indirectamente crear getter, pero no el organismo, para su uso privado tireCount.

Si está trabajando con módulos mecanografiado y está intentando añadir un captador que se exporta, se puede hacer algo como esto:

// 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;
    },
});

Luego, en otro archivo que tiene:

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