objetos - typescript official documentation

obtener y establecer en TypeScript

Question

Estoy tratando de crear el método get y set para una propiedad:

private _name: string;

Name() {
    get:
    {
        return this._name;
    }
    set:
    {
        this._name = ???;
    }
}

¿Cuál es la palabra clave para establecer un valor?

Answer 1

Aquí hay un ejemplo práctico que debería apuntarle en la dirección correcta:

class Foo {
    _name;

    get Name() {
        return this._name;
    }

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

Getters y setters en JavaScript son solo funciones normales. El configurador es una función que toma un parámetro cuyo valor es el valor que se establece.

Answer 2

Creo que probablemente entiendo por qué es tan confuso. En su ejemplo, queríamos getters y setters para _name . Pero lo logramos al crear getters y setters 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'')
    }
}

El código anterior hace lo siguiente:

1. get y set crear getter y setter para yourCarTiresCount ( no para tiresCount ).

El captador 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 un new Car().yourCarTiresCount , getter se ejecuta. Y para cada new Car().yourCarTiresCount(''7'') setter new Car().yourCarTiresCount(''7'') ejecuta.

2. Crea indirectamente el getter, pero no el setter, para tireCount privado.

Answer 3

Es muy similar a crear métodos comunes, simplemente coloque la palabra clave reservada get o set al 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, puede omitir el tipo de retorno en get getMethod1() {

    get getMethod1() {
        return this._name;
    }

Answer 4

Ezward ya ha proporcionado una buena respuesta, pero noté que uno de los comentarios pregunta cómo se usa. Para las personas como yo que tropezamos con esta pregunta, pensé que sería útil tener un enlace a la documentación oficial sobre captadores y configuradores en el sitio web de Typescript, ya que eso lo explica bien, y espero que siempre se mantenga actualizado a medida que se realicen los cambios. 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 él, tenga en cuenta que no incorpora la palabra "obtener" en una llamada a un receptor (y de manera similar para los configuradores):

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

Simplemente debes hacer esto:

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

dado una clase como:

class foo {
  private _bar:boolean = false;

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

entonces se llamará al captador ''bar'' para la propiedad privada ''_bar''.

Answer 5

Puedes escribir esto

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

}

Answer 6

Si está trabajando con módulos de TypeScript y está intentando agregar un captador que se exporta, 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 tienes:

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

Answer 7

Typescript utiliza sintaxis getter / setter que es como ActionScript3.

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

Eso producirá este Javascript, utilizando la característica Ecmascript 5 Object.defineProperty ().

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

Así que para usarlo,

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

Sin embargo, para poder utilizarlo, debe asegurarse de que el compilador de TypeScript apunte a ECMAScript5. Si está ejecutando el compilador de línea de comandos, use --target flag como este;

tsc - objetivo ES5

Si está utilizando Visual Studio, debe editar su archivo de proyecto para agregar la bandera a la configuración de la herramienta de compilación TypeScriptCompile. Puedes ver eso here :

Como @DanFromGermany sugiere a continuación, si simplemente está leyendo y escribiendo una propiedad local como foo.bar = true, entonces tener un set setter y getter es una exageración. Siempre puede agregarlos más tarde si necesita hacer algo, como el registro, cada vez que se lea o escriba la propiedad.