github: https://github.com/Jessie-jzn
sitio web: https://www.jessieontheroad.com/

1. ¿Por qué utilizar TypeScript?

1. Comprobación de tipo estático

La principal ventaja de TypeScript es su verificación de tipos estáticos, que ayuda a detectar errores comunes durante la fase de compilación en lugar del tiempo de ejecución. Esto mejora la confiabilidad y estabilidad del código.

2. Experiencia de edición de código mejorada

El sistema de tipos de TypeScript permite funciones más precisas de finalización de código, refactorización, navegación y documentación en los editores, lo que aumenta significativamente la eficiencia del desarrollo.

3. Mantenibilidad de código mejorada

Las declaraciones de tipo facilitan la comprensión de las intenciones y la estructura del código, lo cual es particularmente beneficioso en entornos de desarrollo en equipo.

4. Funciones avanzadas de idioma

TypeScript admite funciones avanzadas que no están presentes en JavaScript, como interfaces, enumeraciones y genéricos, lo que facilita el desarrollo de código más estructurado y escalable.

5. Mejor soporte de herramientas

TypeScript ofrece varias opciones de compilación para optimizar el código JavaScript generado y admite diferentes entornos JS al compilar TypeScript en JavaScript compatible.

2. TypeScript frente a JavaScript

3. Tipos de datos básicos en TypeScript

• Booleano: Representa valores verdaderos o falsos.
• Número: Representa números enteros y de punto flotante.
• Cadena: Representa datos textuales, utilizando comillas simples o dobles.
• Array: Representa una colección de valores de un tipo específico, usando tipo[] o Array.
• Tupla: Representa una matriz con un número fijo de elementos con tipos específicos.
• Enum: Representa un conjunto de constantes con nombre.
• Cualquiera: Representa cualquier tipo de valor. No proporciona verificación de tipo.
• Nulo: Representa la ausencia de un valor, comúnmente utilizado como tipo de retorno de funciones que no devuelven un valor.
• Nulo y No definido: Representa la ausencia de un valor y el estado no inicializado, respectivamente.
• Nunca: representa valores que nunca ocurren, como funciones que arrojan errores o se ejecutan indefinidamente.
• Objeto: Representa tipos no primitivos.

4. ¿Qué son los genéricos en TypeScript? ¿Cómo se utilizan?

Los genéricos permiten que funciones, clases e interfaces funcionen con cualquier tipo y al mismo tiempo aplican la seguridad de tipos.

Ejemplo:

function identity(arg: T): T {
  return arg;
}

const numberIdentity = identity(42);
const stringIdentity = identity("Hello");

En este ejemplo, la función de identidad utiliza una genérica, lo que le permite aceptar y devolver valores de cualquier tipo.

5. Diferencia entre desconocido y cualquiera en TypeScript

• cualquier tipo: representa cualquier tipo de valor y omite todas las comprobaciones de tipos. Se le puede asignar cualquier valor sin comprobaciones de tipo.
• Tipo desconocido: representa un tipo desconocido. Los valores de tipo desconocido deben verificarse antes de poder usarse, lo que proporciona una forma más segura de manejar valores cuyo tipo es incierto.

let anyVar: any;
let unknownVar: unknown;

anyVar = 5;
anyVar.toUpperCase(); // No compile-time error, but might cause runtime error

unknownVar = "Hello";
if (typeof unknownVar === "string") {
  unknownVar.toUpperCase(); // Type check ensures safety
}

6. Diferencia entre modificador de solo lectura y palabra clave constante

• Modificador de solo lectura: Se utiliza en las propiedades del objeto para hacerlos inmutables después de la inicialización.
• Palabra clave const: Se utiliza para declarar variables con referencias inmutables. Las propiedades del objeto aún se pueden modificar.

const obj = { name: "John" };
obj.name = "Doe"; // Allowed

interface User {
  readonly id: number;
  name: string;
}

const user: User = { id: 1, name: "John" };
user.name = "Doe"; // Allowed
user.id = 2; // Error, `id` is readonly

7. Decoradores en TypeScript

Los decoradores son una característica especial de TypeScript que permite agregar metadatos o modificar clases, métodos, propiedades o parámetros.

Tipos:

• Decoradores de clases: Se aplican a los constructores de clases para modificar el comportamiento de la clase o agregar metadatos.
• Decoradores de métodos: Se aplican a métodos para cambiar su comportamiento o agregar metadatos.
• Decoradores de acceso: se aplican para obtener o configurar accesores para modificar su comportamiento.
• Decoradores de propiedades: Se aplican a las propiedades de clase para agregar metadatos o modificar su comportamiento.
• Decoradores de parámetros: se aplican a los parámetros del método para agregar metadatos.

Ejemplos:

• Decorador de clase:

function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

@sealed
class Greeter {
  greeting: string;
  constructor(message: string) {
    this.greeting = message;
  }

  greet() {
    return `Hello, ${this.greeting}`;
  }
}

• Decorador de métodos:

function logMethod(target: any, propertyName: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  descriptor.value = function (...args: any[]) {
    console.log(`Method ${propertyName} called with args: ${JSON.stringify(args)}`);
    return originalMethod.apply(this, args);
  };
}

class Calculator {
  @logMethod
  add(a: number, b: number): number {
    return a   b;
  }
}

Uso:

Los decoradores se habilitan estableciendo experimentalDecorators en verdadero en tsconfig.json.

8. Diferencia entre interfaz y tipo

interfaz y tipo se utilizan para definir tipos de objetos, pero tienen algunas diferencias:

Estas preguntas y respuestas deberían ayudar a prepararse para las entrevistas de TypeScript al cubrir conceptos fundamentales y uso práctico.