ottenere e impostare in TypeScript

Sto provando a creare il metodo get e set per una proprietà:

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

Qual è la parola chiave per impostare un valore?

Typescript utilizza la syntax getter / setter simile a ActionScript3.

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

Questo produrrà questo Javascript, usando la funzione Object.defineProperty () di Ecmascript.

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

Quindi, per usarlo,

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

Tuttavia, per poterlo utilizzare, è necessario accertarsi che il compilatore TypeScript abbia come target ECMAScript5. Se stai eseguendo il compilatore da riga di comando, usa flag –target come questo;

tsc –target ES5

Se si utilizza Visual Studio, è necessario modificare il file di progetto per aggiungere il flag alla configurazione per lo strumento di compilazione TypeScriptCompile. Lo puoi vedere qui :

Come suggerisce @DanFromGermany di seguito, se stai semplicemente leggendo e scrivendo una proprietà locale come foo.bar = true, allora avere un setter e una coppia getter è eccessivo. È sempre ansible aggiungerli in un secondo momento se è necessario fare qualcosa, come la registrazione, ogni volta che la proprietà viene letta o scritta.

Ezward ha già fornito una buona risposta, ma ho notato che uno dei commenti chiede come viene utilizzato. Per le persone come me che si imbattono in questa domanda, ho pensato che sarebbe utile avere un link alla documentazione ufficiale su getter e setter sul sito web di Typescript che lo spieghi bene, si spera che restino sempre aggiornati man mano che le modifiche fatto e mostra l’utilizzo di esempio:

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

In particolare, per coloro che non hanno familiarità con esso, si noti che non si incorpora la parola ‘get’ in una chiamata a un getter (e in modo simile per setter):

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

Dovresti semplicemente fare questo:

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

dato una class come:

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

quindi verrà chiamato il getter ‘bar’ per la proprietà privata ‘_bar’.

Ecco un esempio funzionante che dovrebbe indirizzarti nella giusta direzione:

 class Foo { _name; get Name() { return this._name; } set Name(val) { this._name = val; } } 

Getter e setter in JavaScript sono solo funzioni normali. Il setter è una funzione che accetta un parametro il cui valore è il valore impostato.

Puoi scrivere questo

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

È molto simile alla creazione di metodi comuni, semplicemente mettendo la parola chiave get o set riservata all’inizio.

 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(); 

In questo caso puoi saltare il tipo restituito get getMethod1() {

  get getMethod1() { return this._name; } 

Penso che probabilmente capisco perché è così confuso. Nel tuo esempio, volevamo getter e setter per _name . Ma otteniamo ciò creando getter e setter per una variabile di class non correlata Name .

Considera questo:

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

Il codice sopra riportato segue:

  1. get e set creare getter e setter per il yourCarTiresCount ( non per tiresCount ).

Il getter è:

 function() { return this.tiresCount ; } 

e il setter è:

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

Significa, ogni volta che facciamo la new Car().yourCarTiresCount , getter corre. E per ogni new Car().yourCarTiresCount('7') eseguito il setter new Car().yourCarTiresCount('7') .

  1. Crea indirettamente getter, ma non setter, per tireCount private.

Se stai lavorando con i moduli TypeScript e stai provando ad aggiungere un getter che viene esportato, puoi fare qualcosa di simile a questo:

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

Quindi, in un altro file hai:

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