> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript Public Getter
A public getter in TypeScript is an accessor method defined with the `get` keyword and the `public` access modifier that intercepts read operations on a class property. It allows a method to be accessed syntactically as a standard property while executing underlying logic to compute or retrieve the returned value.
```typescript theme={"dark"}
class ClassName {
public get propertyName(): ReturnType {
// execution logic
return value;
}
}
```
## Technical Characteristics
**Visibility and Access**
The `public` modifier exposes the member to the public API of the class instance, meaning it can be accessed externally via class instances, by derived subclasses, and internally within the class. Because TypeScript class members are `public` by default, the explicit `public` keyword is optional but often used for strict stylistic adherence.
**Parameter Constraints**
A getter cannot accept any parameters. Attempting to define a parameter in a `get` accessor will result in a compiler error (`TS1094: A 'get' accessor cannot have parameters`).
**Type Inference and Return Types**
TypeScript automatically infers the type of the exposed property based on the getter's return type. While a getter is conceptually designed to return a value, TypeScript allows getters without a `return` statement (which implicitly infers a return type of `void`), provided the `noImplicitReturns` compiler flag is not enabled. If a corresponding `set` accessor is defined for the same property name, the return type of the getter must be assignable to the parameter type of the setter.
**Readonly Inference**
If a public getter is defined without a corresponding setter, TypeScript automatically infers the property as `readonly` at the type level. Any attempt to assign a value to this property will throw a compilation error (`TS2540: Cannot assign to 'propertyName' because it is a read-only property`).
**Compilation Target**
Getters are an ECMAScript feature. The TypeScript compiler requires the `--target` flag to be set to `ES5` or higher to support accessors. When the compilation target is set to `ES5`, `get` accessors are transpiled into `Object.defineProperty()` calls utilizing the `get` property descriptor. When targeting `ES6` (ES2015) or higher, TypeScript preserves the native ECMAScript class `get` syntax.
## Mechanical Example
```typescript theme={"dark"}
class SensorData {
private _rawInput: number = 25;
// Explicitly typed public getter
public get normalizedInput(): number {
return this._rawInput * 1.5;
}
}
const sensor = new SensorData();
// The getter is accessed via property dot-notation, omitting parentheses
const data = sensor.normalizedInput;
// Error TS2540: Cannot assign to 'normalizedInput' because it is a read-only property.
// sensor.normalizedInput = 50;
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
