Questions d'entretien dactylographiées

Question : Qu'est-ce que TypeScript ?

• TypeScript est un sur-ensemble de Javascript
• Ajoute des types statiques, permettant d'améliorer la qualité du code et la vérification des erreurs avant l'exécution.
• Il prend en charge des fonctionnalités telles que les interfaces, les énumérations, les génériques, etc.
• Fournit une meilleure vérification des erreurs, des outils améliorés et une meilleure lisibilité du code.

---

Question - Qu'est-ce que l'affectation de type explicite et implicite ?

• Explicite signifie écrire le type. Comme ci-dessous -

let firstName: string = "Rutvik";

• Implicite signifie que TypeScript devinera le type, en fonction de la valeur. Le type ci-dessous sera considéré comme un nombre

let age = 23;

---

Question - Différence entre any, inconnu et jamais dans TypeScript ?

• Le type de any est utilisé pour attribuer n'importe quel type de variable.
• Cela ne donnera pas d'erreur même si vous réattribuez un autre type.

let x: any = 10;
x = 'hello'; // No TypeScript error
console.log(x.toUpperCase()); // No TypeScript error

• Le type inconnu est meilleur que le type n'importe lequel, car il nous oblige à vérifier le type avant d'effectuer des opérations sur la valeur.

let y: unknown = 10;
// Type assertion needed before using y as number
if (typeof y === 'number') {
    console.log(y.toFixed(2));
}

• Le type ne représente jamais une valeur qui n'apparaît jamais.
• Il est généralement utilisé pour les instructions return d'une fonction qui ne renvoie pas correctement.

function throwError(message: string): never {
    throw new Error(message);
}

---

Question - Comment donnez-vous le type de tableaux ?

• Pour saisir un tableau, nous devons donner le type comme ci-dessous. Dans l'exemple ci-dessous, le tableau ne peut contenir que le type de chaîne.

const names: string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // no error

• Nous pouvons également utiliser un mot-clé en lecture seule, qui empêche la modification du tableau.

const names: readonly string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // Error: Property 'push' does not exist on type 'readonly string[]'.

---

Question - Qu'est-ce que l'inférence de type dans un tableau ?

• Si nous ne donnons aucun type à un tableau, il déduira automatiquement le type.

const numbers = [1, 2, 3]; // inferred to type number[]
numbers.push(4); // no error

---

Question : Que sont les tuples ?

• Il s'agit d'un tableau de types avec une longueur et des types prédéfinis.
• C'est très utile pour donner des types de tableaux mixtes avec différents types.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];

---

Question : Que sont les tuples en lecture seule ?

• Si nous ne créons pas de tuple en lecture seule, nous pouvons ajouter plus d'éléments à celui défini et TypeScript ne générera aucune erreur.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
//No safety in indexes from 3
ourTuple.push('This is wrong');

• Maintenant, pour résoudre ce problème, nous utilisons le mot-clé readonly avant le type.

let ourTuple: readonly [number, boolean, string];
// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
// throws error as it is readonly
ourTuple.push('Coding Hero took a day off');

---

Question - Comment donner les types des objets ?

• Nous pouvons donner le type d'objet en créant un autre objet comme structure et en spécifiant les clés et le type des clés dans l'objet.

interface CarTypes {
    brand: string,
    model: string,
    year: number
}


const car: CarTypes = {
  brand: "Tata",
  model: "Punch",
  year: 2020
};

---

Question - Comment avoir des propriétés facultatives dans les objets ?

• Pour donner une propriété ou une clé facultative, nous devons ajouter le ? après la clé.

let firstName: string = "Rutvik";

---

Question - Expliquez l'énumération en TypeScript ?

• Une énumération est un type de variables qui sont des constantes. Vous devez utiliser uniquement les valeurs qu'il contient.
• Les valeurs sont numériques par défaut et commencent par 0 et s'incrémentent de 1.
• Ils peuvent être numériques ou basés sur des chaînes

let age = 23;

let x: any = 10;
x = 'hello'; // No TypeScript error
console.log(x.toUpperCase()); // No TypeScript error

---

Question : Que sont les alias de type ?

• Ils permettent de définir un type avec un nom personnalisé et peuvent être utilisés pour tous les types primitifs comme les chaînes et les nombres ainsi que pour les types complexes comme les objets et les tableaux.

let y: unknown = 10;
// Type assertion needed before using y as number
if (typeof y === 'number') {
    console.log(y.toFixed(2));
}

---

Question - Que sont les interfaces ?

• Les interfaces sont comme le type mais ne peuvent être utilisées que pour les objets.

function throwError(message: string): never {
    throw new Error(message);
}

---

Question - Comment étendre les interfaces ?

• Les interfaces peuvent être étendues avec le mot-clé extend.

const names: string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // no error

---

Question : Que sont les types d'union et d'intersection ?

Syndicat :-

• Les types d'union sont utilisés lorsque la propriété peut contenir plusieurs valeurs, comme une chaîne ou un nombre.
• Pour cette raison, ils sont également appelés OR et sont utilisés en utilisant | symbole.

const names: readonly string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // Error: Property 'push' does not exist on type 'readonly string[]'.

Intersection :-

• Les types d'intersection sont utilisés lorsque plusieurs types sont combinés en un seul.
• Pour cette raison, ils sont également appelés AND et sont utilisés en utilisant le symbole &.

const numbers = [1, 2, 3]; // inferred to type number[]
numbers.push(4); // no error

---

Question - Que sont les fonctions dans Typescript ?

Comment donner le type de retour en fonction ?

• Nous pouvons donner les types de retour des fonctions avec le symbole : après le nom de la fonction.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];

Comment donner le type de paramètres en fonction ?

• On peut donner le type de paramètres en les mentionnant après chaque paramètre avec le symbole :.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
//No safety in indexes from 3
ourTuple.push('This is wrong');

Comment donner des paramètres facultatifs, par défaut et de repos en fonction ?

• Avec le paramètre par défaut, nous pouvons marquer un paramètre comme facultatif. Comme ça, où c est facultatif et noté ?.

let ourTuple: readonly [number, boolean, string];
// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
// throws error as it is readonly
ourTuple.push('Coding Hero took a day off');

• Les valeurs par défaut (une fonctionnalité ES6) suivent le type.

interface CarTypes {
    brand: string,
    model: string,
    year: number
}


const car: CarTypes = {
  brand: "Tata",
  model: "Punch",
  year: 2020
};

• Les autres paramètres (une fonctionnalité ES6) reçoivent le type de tableau, car ils convertissent les éléments passés dans le tableau.

interface CarTypes {
    brand: string,
    model: string,
    year?: number
}

const car: CarTypes = {
  brand: "Tata",
  model: "Punch"
};

---

Question : Qu'est-ce que le casting dans TypeScript ?

• Le casting est le processus de remplacement d'un type de variable.
• Comme dans l'exemple ci-dessous, le type est inconnu mais est transformé en chaîne lors de l'utilisation avec le mot-clé as.

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}
console.log(Direction.Up); // 1
console.log(Direction.Down); // 2

• Nous pouvons également utiliser à la place de as. Les deux signifient la même chose.

let firstName: string = "Rutvik";

---

Question - Que sont les génériques dans TypeScript ?

• Les génériques dans Typeascript vous permettent de créer des composants ou des fonctions réutilisables pouvant fonctionner avec plusieurs types de données.

let age = 23;

---

Question - Types d'utilitaires dans Typescript ?

• TypeScript fournit des types d'utilitaires pour simplifier les transformations de types courantes.
• Ces types facilitent la manipulation et l'interaction avec les types d'objets et d'interfaces.
• Voici une présentation de certains types d'utilitaires couramment utilisés :

1. Partiel

• Rend toutes les propriétés de type T facultatives.
• Cas d'utilisation : Lorsque vous souhaitez créer un objet dont seules certaines propriétés sont requises.

let x: any = 10;
x = 'hello'; // No TypeScript error
console.log(x.toUpperCase()); // No TypeScript error

2. Obligatoire

• Rend toutes les propriétés de type T requises.
• Cas d'utilisation : lorsque vous souhaitez imposer que toutes les propriétés doivent être présentes.

let y: unknown = 10;
// Type assertion needed before using y as number
if (typeof y === 'number') {
    console.log(y.toFixed(2));
}

3. Lecture seule

• Rend toutes les propriétés de type T en lecture seule.
• Cas d'utilisation : Pour garantir que les propriétés d'un objet ne peuvent pas être modifiées.

function throwError(message: string): never {
    throw new Error(message);
}

4. Choisissez

• Crée un type en sélectionnant un ensemble de propriétés K du type T.
• Cas d'utilisation : lorsque vous n'avez besoin que de propriétés spécifiques d'un type.

const names: string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // no error

5. Omettre

• Crée un type en omettant un ensemble de propriétés K du type T.
• Cas d'utilisation : lorsque vous souhaitez toutes les propriétés sauf certaines spécifiques.

const names: readonly string[] = ["Rutvik", "Rohit", "Virat"];
names.push("Bumrah"); // Error: Property 'push' does not exist on type 'readonly string[]'.

6. Enregistrer

• Construit un type avec des clés K et des valeurs de type T.
• Cas d'utilisation : Pour créer un type d'objet avec des clés fixes et des types de valeurs cohérents.

const numbers = [1, 2, 3]; // inferred to type number[]
numbers.push(4); // no error

7. Exclure

• Exclut du type T tous les types attribuables à U.
• Cas d'utilisation : pour filtrer des types spécifiques.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];

8. Extraire

• Extrait du type T uniquement les types attribuables à U.
• Cas d'utilisation : pour affiner les types à un sous-ensemble spécifique.

let ourTuple: [number, boolean, string];

// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
//No safety in indexes from 3
ourTuple.push('This is wrong');

9. Non Nullable

• Exclut null et non défini du type T.
• Cas d'utilisation : Pour garantir qu'une valeur n'est ni nulle ni indéfinie.

let ourTuple: readonly [number, boolean, string];
// initialize correctly
ourTuple = [5, false, 'Coding Hero was here'];
// throws error as it is readonly
ourTuple.push('Coding Hero took a day off');

10. Type de retour

• Déduit le type de retour d'un type de fonction.
• Cas d'utilisation : Pour capturer et utiliser le type de retour d'une fonction.

interface CarTypes {
    brand: string,
    model: string,
    year: number
}


const car: CarTypes = {
  brand: "Tata",
  model: "Punch",
  year: 2020
};

11. Type d'instance

• Construit un type constitué du type d'instance d'une fonction constructeur de type T.
• Cas d'utilisation : Pour obtenir le type d'une instance de classe.

interface CarTypes {
    brand: string,
    model: string,
    year?: number
}

const car: CarTypes = {
  brand: "Tata",
  model: "Punch"
};

12. Paramètres

• Extrait les types de paramètres d'un type de fonction.
• Cas d'utilisation : Réutiliser les types de paramètres d'une fonction.

enum Direction {
  Up = 1,
  Down,
  Left,
  Right,
}
console.log(Direction.Up); // 1
console.log(Direction.Down); // 2

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!