github : https://github.com/Jessie-jzn
site Web :https://www.jessieontheroad.com/

1. Pourquoi utiliser TypeScript ?

1. Vérification de type statique

Le principal avantage de TypeScript est sa vérification de type statique, qui permet de détecter les erreurs courantes pendant la phase de compilation plutôt que lors de l'exécution. Cela améliore la fiabilité et la stabilité du code.

2. Expérience améliorée d'édition de code

Le système de types de TypeScript permet des fonctionnalités de complétion de code, de refactorisation, de navigation et de documentation plus précises dans les éditeurs, augmentant ainsi considérablement l'efficacité du développement.

3. Maintenabilité améliorée du code

Les déclarations de type facilitent la compréhension des intentions et de la structure du code, ce qui est particulièrement bénéfique dans les environnements de développement en équipe.

4. Fonctionnalités linguistiques avancées

TypeScript prend en charge des fonctionnalités avancées non présentes dans JavaScript, telles que les interfaces, les énumérations et les génériques, facilitant le développement d'un code plus structuré et évolutif.

5. Meilleure prise en charge des outils

TypeScript propose diverses options de compilateur pour optimiser le code JavaScript généré et prend en charge différents environnements JS en compilant TypeScript en JavaScript compatible.

2. TypeScript contre JavaScript

3. Types de données de base dans TypeScript

• Booléen : représente les valeurs vraies ou fausses.
• Nombre : représente à la fois des nombres entiers et des nombres à virgule flottante.
• String : représente des données textuelles, à l'aide de guillemets simples ou doubles.
• Array : représente une collection de valeurs d'un type spécifié, en utilisant type[] ou Array.
• Tuple : représente un tableau avec un nombre fixe d'éléments avec des types spécifiés.
• Enum : représente un ensemble de constantes nommées.
• Any : représente tout type de valeur. Ne fournit aucune vérification de type.
• Void : représente l'absence de valeur, couramment utilisé comme type de retour des fonctions qui ne renvoient pas de valeur.
• Null et Undefined : représentent respectivement l'absence de valeur et l'état non initialisé.
• Jamais : représente des valeurs qui n'apparaissent jamais, telles que des fonctions qui génèrent des erreurs ou s'exécutent indéfiniment.
• Object : représente les types non primitifs.

4. Que sont les génériques dans TypeScript ? Comment sont-ils utilisés ?

Les génériques permettent aux fonctions, classes et interfaces de fonctionner avec n'importe quel type tout en garantissant la sécurité des types.

Exemple:

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

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

Dans cet exemple, la fonction d'identité utilise un générique, lui permettant d'accepter et de renvoyer des valeurs de n'importe quel type.

5. Différence entre inconnu et tout dans TypeScript

• any Type : représente tout type de valeur et contourne toute vérification de type. N'importe quelle valeur peut lui être attribuée sans vérification de type.
• Type inconnu : représente un type inconnu. Les valeurs de type inconnu doivent être vérifiées avant de pouvoir être utilisées, ce qui constitue un moyen plus sûr de gérer les valeurs dont le type est incertain.

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. Différence entre le modificateur en lecture seule et le mot-clé const

• modificateur en lecture seule : utilisé sur les propriétés des objets pour les rendre immuables après l'initialisation.
• const Keyword : utilisé pour déclarer des variables avec des références immuables. Les propriétés de l'objet peuvent toujours être modifiées.

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. Décorateurs en TypeScript

Les décorateurs sont une fonctionnalité TypeScript spéciale qui permet d'ajouter des métadonnées ou de modifier des classes, des méthodes, des propriétés ou des paramètres.

Types :

• Décorateurs de classe : appliqués aux constructeurs de classe pour modifier le comportement de la classe ou ajouter des métadonnées.
• Décorateurs de méthodes : appliqués aux méthodes pour modifier leur comportement ou ajouter des métadonnées.
• Décorateurs d'accesseurs : appliqués pour obtenir ou configurer les accesseurs afin qu'ils modifient leur comportement.
• Décorateurs de propriétés : appliqués aux propriétés de classe pour ajouter des métadonnées ou modifier leur comportement.
• Décorateurs de paramètres : appliqués aux paramètres de méthode pour ajouter des métadonnées.

Exemples :

• Décorateur de classe :

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}`;
  }
}

• Méthode Décorateur :

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;
  }
}

Usage:

Les décorateurs sont activés en définissant experimentalDecorators sur true dans tsconfig.json.

8. Différence entre l'interface et le type

interface et type sont tous deux utilisés pour définir les types d'objets, mais ils présentent quelques différences :

Ces questions et réponses devraient aider à préparer les entretiens TypeScript en couvrant les concepts fondamentaux et l'utilisation pratique.