Creación de clases y constructores En TypeScript

Object-oriented programming is one of the most powerful paradigms in software development, and TypeScript provides robust tools to implement it correctly. Classes are fundamental to this approach, providing a clear structure for code inheritance and object creation. Let's explore how to implement classes in TypeScript following best practices.

What are classes in TypeScript and how do they differ from interfaces?

Although interfaces and classes may appear similar at first glance, they have different implementations and purposes. Interfaces, which we have already explored above, define contracts that classes must fulfill. Classes, on the other hand, provide a more square, defined structure for inheriting code and sharing it with other elements of your project.

The basic syntax for creating a class in TypeScript is fairly straightforward:

class Person { name: string; age: number; developer: boolean;
 constructor(name: string, age: number, developer: boolean) { this.name = name; this.age = age; this.developer = developer; }
 greet(): string { return `Hello, my name is ${this.name} and I am ${this.age} years old`; } }}

In this example, we have created a Person class with three properties: name, age and developer. We have also defined a constructor and a greet() method.

What is the constructor and why is it important?

The constructor is a special method that is executed when an instance of the class is created. Its main function is to initialize the properties of the class with the provided values. In our example, the constructor receives three parameters and assigns them to the corresponding properties of the class.

It is important to note the use of this to refer to the properties of the class, distinguishing them from the constructor parameters. By convention, they are usually named the same, which makes it easier to identify which parameters correspond to which properties.

How to implement and use a class in TypeScript?

Once the class is defined, we can create instances of it and use its methods:

let person = new Person("John", 30, true);console.log(person.greet()); // Print: "Hello, my name is John and I'm 30 years old."

Here, we have created a new instance of the Person class with the values "John", 30 and true. Then, we call the greet() method of this instance to get a custom message.

What are the best practices for organizing classes in a project?

A fundamental practice that is often overlooked is to keep each class in its own file. This follows the "one file, one class" principle and makes your code more maintainable and scalable.

To implement this, we need to:

1. Export the class from its file:

// class.tsexport class Person { name: string; age: number; developer: boolean;
 constructor(name: string, age: number, developer: boolean) { this.name = name; this.age = age; this.developer = developer; }
 greet(): string { return `Hello, my name is ${this.name} and I am ${this.age} years old`; } }}

2. Import the class into the file where we want to use it:

// implementation.tsimport { Person } from './class';
let person = new Person("John", 30, true);console.log(person.greet());

This separation allows the class to be agnostic with respect to how it is used, and facilitates its reuse in different parts of your project.

Why is modularization important in class development?

Modularization is key to maintaining clean and organized code. By separating the definition of a class from its implementation, we are following the principle of single responsibility: each file has only one reason to change.

In addition, this practice facilitates:

• Code reuse
• Unit testing
• Team collaboration
• Long-term maintainability

When you define a class in its own file and export it, you can import it in as many places as you need, implementing it in different ways according to the specific requirements of each part of your application.

Classes in TypeScript offer a powerful and structured way to implement object-oriented programming. By following best practices for organization and modularization, you can create cleaner, more maintainable and reusable code. Have you implemented classes in your TypeScript projects? Share your experiences and questions in the comments.