我试图创建一个属性的获取和设置方法:
private _name: string;
Name() {
get:
{
return this._name;
}
set:
{
this._name = ???;
}
}
设置值的关键字是什么?
我试图创建一个属性的获取和设置方法:
private _name: string;
Name() {
get:
{
return this._name;
}
set:
{
this._name = ???;
}
}
设置值的关键字是什么?
当前回答
根据您所展示的示例,您希望通过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>
其他回答
如果你正在寻找在任何对象(不是类)上使用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使用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
下面是如何添加getter和setter的示例
class Person {
private _age: number;
private _firstName: string;
private _lastName: string;
public get age() {
return this._age;
}
public set age(theAge: number) {
if (theAge <= 0 || theAge >= 200) {
throw new Error('The age is invalid');
}
this._age = theAge;
}
public getFullName(): string {
return `${this._firstName} ${this._lastName}`;
}
}
我想我大概知道为什么这么令人困惑了。在您的示例中,我们需要_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;
}
}