## Questions théoriques fréquentes
**Q:** Qu'est-ce que TypeScript ?
TypeScript est un langage de programmation open source développé par Microsoft. C'est une version typée du langage JavaScript, qui ajoute des fonctionnalités supplémentaires pour améliorer les capacités de développement d'applications.
```typescript
// Exemple basique de déclaration de variable en TypeScript avec type
let message: string = "Hello, World!";
Q: Quelle est la différence entre var, let et const en TypeScript ?
var: Déclare une variable globale ou locale à l'ensemble de la fonction dans laquelle elle est déclarée.let: Déclare une variable limitée au bloc, instruction ou expression où elle est utilisée.const: Déclare une constante qui ne peut pas être redéfinie après sa première initialisation.
// Exemple d'utilisation de var, let et const
var x = 10;
let y = 20;
const z = 30;
x = 40; // Valide
y = 50; // Valide
z = 60; // Erreur: Cannot assign to 'z' because it is a constant or a read-only property.
Exercices de code classiques
Exercice 1: Écrivez une fonction qui retourne la somme de deux nombres.
function add(a: number, b: number): number {
return a + b;
}
console.log(add(5, 3)); // Output: 8
Exercice 2: Créez un tableau d'objets et filtrez-le pour obtenir tous les objets où la propriété age est supérieure à 18.
interface Person {
name: string;
age: number;
}
const people: Person[] = [
{ name: "Alice", age: 25 },
{ name: "Bob", age: 17 },
{ name: "Charlie", age: 30 }
];
const adults = people.filter(person => person.age > 18);
console.log(adults); // Output: [{ name: "Alice", age: 25 }, { name: "Charlie", age: 30 }]
Exercice 3: Implémentez une fonction qui prend un tableau de nombres et retourne le plus grand nombre.
function findMax(numbers: number[]): number {
return Math.max(...numbers);
}
console.log(findMax([1, 5, 2, 8, 4])); // Output: 8
Exercice 4: Écrivez une fonction qui prend une chaîne de caractères et retourne la chaîne inversée.
function reverseString(str: string): string {
return str.split('').reverse().join('');
}
console.log(reverseString("hello")); // Output: "olleh"
Exercice 5: Implémentez une fonction qui prend un tableau de nombres et retourne le nombre d'éléments pairs.
function countEvenNumbers(numbers: number[]): number {
return numbers.filter(number => number % 2 === 0).length;
}
console.log(countEvenNumbers([1, 2, 3, 4, 5])); // Output: 2
Pieges courants en entretien
Piege 1: Ignorer les types de retour
function foo(): void {
console.log("This is a void function");
}
const result = foo(); // Erreur: 'void' function returning value is disallowed.
Piege 2: Utiliser any sans raison
let myVar: any = "Hello, World!";
myVar = 123; // Pas d'erreur car myVar est de type any
Piege 3: Oublier les imports
// Fonctionne sans erreur mais peut causer des problèmes si un module n'est pas correctement importé
function greet(name: string): void {
console.log(`Hello, ${name}!`);
}
greet("World");
Piege 4: Utiliser == au lieu de ===
if (5 == "5") { // Vrai en JavaScript mais Faux en TypeScript
console.log("They are equal");
}
Piege 5: Ignorer la gestion des erreurs
function divide(a: number, b: number): number {
return a / b; // Erreur si b est 0
}
console.log(divide(10, 0)); // Infinity (pas d'erreur)
Complexité algorithmique
Complexité O(n):
- Parcours un tableau ou une chaîne de caractères une seule fois.
function linearSearch(arr: number[], target: number): boolean {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === target) {
return true;
}
}
return false;
}
Complexité O(n^2):
- Parcours un tableau en imbriquant deux boucles.
function bubbleSort(arr: number[]): void {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < arr.length - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
}
}
}
}
Complexité O(log n):
- Utilise des structures de données comme les arbres binaires pour effectuer une recherche.
function binarySearch(arr: number[], target: number, start: number, end: number): boolean {
if (start > end) {
return false;
}
const mid = Math.floor((start + end) / 2);
if (arr[mid] === target) {
return true;
} else if (arr[mid] < target) {
return binarySearch(arr, target, mid + 1, end);
} else {
return binarySearch(arr, target, start, mid - 1);
}
}
Concepts avancés à connaitre
Concept 1: Types personnalisés
type Point = { x: number; y: number };
let p: Point = { x: 10, y: 20 };
Concept 2: Interfaces et héritage
interface Animal {
name: string;
makeSound(): void;
}
class Dog implements Animal {
constructor(public name: string) {}
makeSound() {
console.log("Woof!");
}
}
const myDog = new Dog("Buddy");
myDog.makeSound(); // Output: Woof!
Concept 3: Decorateurs
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function(...args: any[]) {
console.log(`Calling ${propertyKey} with arguments`, args);
return originalMethod.apply(this, args);
};
return descriptor;
}
class Calculator {
@log
add(a: number, b: number): number {
return a + b;
}
}
const calc = new Calculator();
calc.add(5, 3); // Output: Calling add with arguments [5, 3]
Concept 4: Generics
function identity<T>(arg: T): T {
return arg;
}
let output1 = identity<string>("Hello");
let output2 = identity<number>(123);
Concept 5: Modules et namespaces
// file1.ts
export function greet(name: string): string {
return `Hello, ${name}!`;
}
// file2.ts
import { greet } from './file1';
console.log(greet("World")); // Output: Hello, World!
Conseils pratiques
Conseil 1: Suivez le style guide officiel de Microsoft pour TypeScript.
Conseil 2: Apprenez et utilisez des outils comme ESLint pour vérifier votre code.
Conseil 3: Pratiquez régulièrement sur des problèmes de codage en TypeScript.
Conseil 4: Utilisez le mode strict du compilateur TypeScript ("strict": true) pour prévenir les erreurs courantes.
Conseil 5: Étudiez les exemples de code open source pour comprendre les bonnes pratiques. ```