¿Cómo usar getters/setters en TypeScript?

En TypeScript, hay dos métodos admitidos getter y setter para acceder y establecer los miembros de la clase. En este breve artículo, le mostraré Typescript Accessor que incluye el método getters/setters.

En realidad, getters y setters no son más que una forma de proporcionar acceso a las propiedades de un objeto. A diferencia de otros lenguajes de OOP como Java, C++, etc., donde solo puede acceder a las variables a través del método getter o setter, pero las cosas funcionan de manera diferente en Typescript, donde puede acceder a las variables directamente (Dado en el siguiente ejemplo). Esto se llama Accesorio de TypeScript.

Métodos de la propiedad de acceso de TypeScript: 

• getter: Este método viene cuando quieres acceder a cualquier propiedad de un objeto. Un captador también se denomina accesor.
• setter: Este método viene cuando quieres cambiar cualquier propiedad de un objeto. Un setter también se conoce como mutador.

A continuación, el código dado es una clase de estudiante con 3 propiedades: nombre, semestre y curso.

class Student {
    public name: string;
    public semester: number;
    public course: string;
}

Para acceder a cualquier propiedad de la clase Student :

let student = new Student();

// You can access Student class variables directly
Student.name = "Aman Rathod";

Método de obtención:

Nota: Para extraer el valor de una variable, la propiedad de acceso de getter es el método convencional. Se indica con la palabra clave get, en un objeto literal. Un captador puede ser público, protegido, privado.

Sintaxis:

get accessName() {  
    // getter, the code executed on 
    // getting obj.accessName  
}

Ejemplo:

class Student {
  
    private _name: string = "Aman Rathod";
    private _semester: number;
    private _course: string;
  
    // Getter method to return name of
    // Student class
    public get name() {
        return this._name;
    }
  
}
  
// Access any property of the Student class
let student = new Student();
  
// Getter call
let value = student.name;
  
console.log(value);

Producción:

Aman Rathod

En el ejemplo anterior, puede observar que cuando invocamos el método getter (student.name), no incluimos los paréntesis de apertura y cierre como lo haríamos con una función normal. Por lo tanto, accede a las variables directamente.

Método Setter: para actualizar el valor de una variable, la propiedad de acceso setter es el método convencional que se utiliza. Se indican mediante una palabra clave establecida en un objeto literal.

Sintaxis:

set accessName(value) {  

    // The code executed on setting 
    // obj.accessName = value, from setter  
}  

Ejemplo:

class Student {
  
    private _name: string = "Aman Rathod";
    private _semester: number;
    private _course: string;
  
    // Getter method to return name
    // of Student class
    public get name() {
        return this._name;
    }
  
    // Setter method to set the semester number
    public set semester(thesem: number) {
        this._semester = thesem;
    }
  
    // Setter method
    public set course(thecourse: string) {
        this._course = thecourse;
    }
}
  
// Access any property of the Student class
let student = new Student();
  
// Setter call
student.semester = 5;
student.course = "Web Development";

Del ejemplo anterior, también puede notar que la llamada al método setter no tiene paréntesis como un método normal. Cuando llamas a student.semester o student.course, se invoca el método de establecimiento de semestre o curso y se asigna el valor. 

Manejar el error: también puede agregar una condición en el método setter y, si la condición no es válida, arroja un error. Vamos a entender a través del siguiente ejemplo.

class Student {    
    private _name: string = "Aman Rathod";
    private _semester: number;
    private _course: string;
      
    // Suppose the only 1st to 8th-semester students
    // are allowed to purchase the courses.
    public set semester( thesem: number ) {
          
        if( thesem < 1 || thesem > 8 ){
            throw new Error(
'Sorry, this course is valid for students from 1st to 8th semester');
        }
              
        this._semester = thesem;
    }
}
  
// Access any property of the Student class
let student = new Student();
  
// setter call
student.semester = 9;

Producción:

Constructor: ahora analicemos el método Getter y Setter usando Constructor . En realidad, no hay diferencia en usar o no usar el constructor en una clase para acceder al método getter o setter, pero solo queremos pasar por alto el constructor en TypeScript.

Ejemplo:

class Student {
    name: string;
    semester: number;
    course: string;
      
    constructor(nm: string, sm: number, cs: string) {
        this.name = nm;
        this.semester = sm;
        this.course = cs;
    }
      
    // Getter method 
    public get courses() {
        return this.course;
    }
      
    public set courses( thecourse: string) {
        this.course = thecourse;
    }
}
  
// Access any property of the Student class, 
let student = new Student("Aman Rathod", 4, "Web Development" ); 
  
// Setter call
student.course = "Data structure";
  
// Getter call
console.log("Course purchased is " + student.courses);

Producción: