TypeScript

| public | Les variables, méthodes ou classes publiques sont accessibles par tout objet. | | :---- | :---- | | | Les variables, méthodes ou classes définies sans modificateur sont accessibles par toute classe appartenant au même package. | | protected | Les variables, méthodes ou classes définies comme protégées ne sont accessibles que par les classes filles et classes du même package. | | private | Les variables, méthodes ou classes définies comme privées ne sont accessibles que par la classe dans laquelle elles sont définies. |

Héritage

L'héritage consiste à organiser les classes entre « mère » et « filles » en utilisant le mot clé « extends ».

• Polymorphisme

Polymorphisme

Polymorphisme permet de manipuler des objets sans vraiment connaître leur type ou c'est la définition des méthodes de plusieurs manières par exemple : la méthode Compte() est définit dans les classes filles par CompteEpargne(), CompteSimple(), ComptePayant() ; Classe Object qui sont (très) souvent redéfinies pour bénéficier des avantages du polymorphisme : equals(), toString() et hashCode()

Remarque : L'héritage désigne l'utilisation de la structure et du comportement d'une super classe dans une sous-classe. Bien que le polymorphisme se réfère à la modification du comportement d'une super-classe dans une sous-classe.

Encapsulation

Encapsulation est implémenté en combinant les méthodes et les attributs dans une classe.

En utilisant les accesseurs modificateurs pour avoir accès aux variables déclarées private hors de la classe.

Abstraction

L'abstraction est un processus consistant à masquer les détails de la mise en œuvre et à afficher uniquement les fonctionnalités de l'utilisateur.

Par exemple, l'envoi de SMS à l'endroit où vous tapez le texte et envoyez le message.

Vous ne connaissez pas le traitement interne relatif à la livraison du message.

L'abstraction vous permet de vous concentrer sur ce que fait l'objet au lieu de savoir comment il le fait.

Il y a deux façons de réaliser l'abstraction :

• Classe abstrait
• Interface

Classe abstraite Une classe abstraite est une classe qui ne peut pas être instanciée mais rien ne l'empêche d'avoir des méthodes, un constructeur et tout autre chose que la classe normale peut avoir.

Interface

Interface est une classe 100% abstraite permettant de créer un nouveau super type et jouir du polymorphisme.

Une classe abstraite utilise le mot clé « abstract » et aussi peut contenir des méthodes abstraites et des méthodes avec leur traitement au contraire de l'interface qui contient sauf les entêtes ou signatures des méthodes. Une interface est une classe entièrement abstraite.

| Abstraite | Interface | | :---- | :---- | | Sert à factoriser du code | Sert à définir des contrats de services | | le nombre de classes mères d'une sous-classe est limité, l'implémentation d'une classe abstraite impose d'hériter de cette classe | il est généralement possible d'implémenter plusieurs interfaces dans une classe |

La surcharge survient lorsque deux méthodes ou plus dans une classe ont le même nom de méthode mais des paramètres différents.

Redéfinition signifie avoir deux méthodes avec le même nom de méthode et les mêmes paramètres, l'une des méthodes est dans la classe parente et l'autre dans la classe fille.

![Résultat de recherche d'images pour "difference entre surcharge de methode et redefinition en java"][image1]

TypeScript est un langage de programmation. Il s'agit d'un sur-ensemble de JavaScript qui ajoute des fonctionnalités de typage statique et de compilation statique optionnelle. TypeScript permet aux développeurs d'écrire du code JavaScript de manière plus structurée en utilisant des types, ce qui facilite la détection précoce d'erreurs et améliore la maintenabilité du code.

Avantage de Typescript

L'un des principaux avantages de l'utilisation de TypeScript par rapport à JavaScript est la vérification statique des types. TypeScript permet de définir des types pour les variables, les paramètres de fonction, les propriétés d'objet, etc. Cela aide à détecter les erreurs de typage dès la phase de développement, avant l'exécution du code.

Le compilateur TypeScript lui-même est responsable de la détection des erreurs de typage.

• tsc nom de file .ts
• Intégration avec les IDE

Principale caractéristique de Typescript

Les principales caractéristiques de TypeScript comprennent le typage statique, l'inférence de type, la compatibilité ECMAScript, les outils de développement avancés, la facilité d'intégration, la gestion avancée des modules et l'écosystème dynamique.

Les principales différences entre TypeScript et JavaScript résident dans le typage statique, les extensions du langage, la nécessité de compilation,

JavaScript, est un langage de script dynamique et interprété

Les types permettent de spécifier les types des variables, des paramètres de fonction, des valeurs de retour et des propriétés d'objets. Ils permettent de définir le comportement attendu des données.

L'inférence de type (Type Inference) qui permet au compilateur de déduire automatiquement les types des variables lorsque les annotations de type ne sont pas spécifiées.

Lorsque on déclare une variable et qu'on lui affecte une valeur lors de sa création, le compilateur TypeScript analyse la valeur assignée et infère le type approprié en se basant sur cette valeur. Il déduit le type de la variable en fonction de la forme et de la structure de la valeur assignée.

Les types conditionnels permettent de définir des types en fonction de conditions sur d'autres types. Ils sont utilisés pour effectuer des branches conditionnelles basées sur les types. Par exemple, le type Exclude\<T, U> exclut les types de U d'un union de types T. Les types conditionnels peuvent être utilisés pour créer des types génériques flexibles et pour effectuer des opérations de filtrage sur les types.

Les types génériques permettent de créer des composants et des fonctions réutilisables qui peuvent travailler avec différents types de données. Ils permettent de définir des paramètres de type génériques qui sont résolus lors de l'utilisation du composant ou de la fonction. Par exemple, Array\<T> est un type générique qui représente un tableau contenant des éléments de type T. Les types génériques offrent une flexibilité et une réutilisabilité

Literal Type permet de définir des types spécifiques en utilisant des valeurs littérales. Par exemple, type MyBoolean \= true | false; définit un type MyBoolean qui peut avoir uniquement les valeurs true ou false.

Une type assertion sert à informer le compilateur du type exact d'une valeur. Je l'utilise pour affiner l'inférence quand TypeScript ne peut pas le déduire tout seul, par exemple pour caster un Element en HTMLInputElement. Je reste prudent, car une assertion ne fait aucune vérification runtime — c'est donc à moi de garantir que le type est correct.

Intersection permet de combiner plusieurs types en un seul.

Union permet de spécifier qu'une variable peut avoir plusieurs types possibles.

https://www.typescriptlang.org/fr/docs/handbook/2/everyday-types.html

| Utility Type | Description | | :---- | :---- |

Rend toutes les propriétés de T optionnelles.

Generic permettent d'écrire des fonctions ou composants réutilisables tout en conservant un typage fort. Le type est injecté au moment de l'utilisation.

Ainsi TypeScript connaît automatiquement les colonnes disponibles, l'autocomplétion fonctionne et les erreurs sont détectées à la compilation. On gagne en réutilisabilité sans perdre en sécurité.

Rend toutes les propriétés de T obligatoires (opposé de Partial).

Rend toutes les propriétés de T en lecture seule (immuables). rend toutes les propriétés optionnelles.

Construit un type en sélectionnant certaines clés K de T.

IL permet de garder seulement certaines propriétés.

Construit un type en excluant certaines clés K de T. il permet d'enlever certaines propriétés.

Crée un objet avec des clés K et des valeurs de type T.

Retire de T les membres qui sont assignables à U.

Garde dans T seulement les membres qui sont assignables à U.

Supprime null et undefined d'un type.

Extrait le type de retour d'une fonction.

Extrait les types des paramètres d'une fonction sous forme de tuple.

Extrait les types des paramètres du constructeur d'une classe.

Extrait le type de l'instance créée par un constructeur.

Extrait le type résolu d'une Promise (y compris nested Promises).

L'intersection nous permet de combiner plusieurs types en un seul type. Pour créer un type d'intersection, nous devons utiliser le mot- & clé :

type Name \= { name: "string" };

type Age \= { age: number };

type Person \= Name & Age;

interface Name { name: "string" };

interface Age { age: number };

type Person \= Name & Age;

Les types d'union nous permettent de créer un nouveau type qui peut avoir une valeur d'un ou de plusieurs types. Pour créer un type d'union, on devra utiliser le mot-|clé |.

type Man \= { name: "string" };

type Woman \= { name: "string" };

type Person \= Man | Woman;

interface Man { name: "string" };

interface Woman { name: "string" };

type Person \= Man | Woman;

Un tuple est un tableau à longueur fixe avec des types prédéfinis pour chaque position.

Contrairement à un tableau classique où tous les éléments sont du même type, un tuple permet d'avoir des éléments hétérogènes mais ordonnés.

never, unknown et any sont trois types distincts en TypeScript, et chacun a une utilité différente :

Any : Elle peut être utilisée pour représenter n'importe quel type, et permet d'effectuer n'importe quelle opération sur elle. quand on utilise any, elle désactive la vérification de type de TypeScript pour cette valeur, c'est déconseillée en général car elle peut conduire à des erreurs d'exécution et rendre le code plus difficile à maintenir.

unknown c'est un type qui est utilisé pour représenter des valeurs dont le type n'est pas connu. Contrairement à any, unknown est une alternative sûre, sur le plan des types qui peut aider à détecter les erreurs de type à la compilation. On peut affecter une valeur unknown à n'importe quel autre type, mais on ne peut pas effectuer d'opérations sur elle sans d'abord en affiner le type. On peut le faire en utilisant une garde de type ou une assertion de type.

Never c'est un type qui représente des valeurs qui ne peuvent jamais se produire. Il est utilisé pour indiquer qu'une fonction ne retournera pas ou qu'une variable n'est pas initialisée ou a une valeur inaccessible. Par exemple, une fonction qui lance une erreur ou entre dans une boucle infinie a un type de retour never.

Any désactive TypeScript. Avec any, je peux faire n'importe quoi, même appeler une méthode qui n'existe pas.

Unknown, au contraire, oblige à vérifier le type avant de l'utiliser.

Les deux permettent de décrire la forme d'un objet.

• j'utilise souvent interface pour représenter des contrats objets extensibles, par exemple un modèle métier ou les props d'un composant.
• J'utilise plutôt type quand j'ai besoin de composer des types plus avancés : unions, intersections, mapped types, utility types.

L'interfaces est un moyen de décrire des formes de données, par exemple, un objet.

Le type est une définition d'un type de données, par exemple, une union, une primitive, une intersection, un tuple ou tout autre type.

L'interface fonctionne mieux avec les objets et les objets de méthode, et les types fonctionnent mieux avec les fonctions, les types complexes, etc.

Pour définir les props d'un composant, je peux utiliser type ou interface, mais je choisis en fonction du besoin :

• Si je veux juste décrire la forme d'un objet et pouvoir l'étendre ailleurs, j'ai tendance à utiliser une interface.
• Si j'ai besoin de combiner plusieurs types avec des unions (|) ou intersections (&), ou que mes props incluent d'autres formes comme des tuples ou des alias complexes, je préfère type.

En pratique, pour des props simples et extensibles, j'utilise souvent interface par convention, car elle supporte l'extension déclarative (on peut la merger). Pour des types plus composés ou avancés, type est plus puissant.

Différences fondamentales

• Merging: interface peut être fusionnée (declaration merging), type non.

• Unions: type gère | nativement; interface non.

• Extends: interface → extends; type → intersection &.

extends est une relation de héritage entre interfaces, idéale pour modéliser des hiérarchies et des contrats extensibles.

& crée un type intersection, plus flexible car il fonctionne sur n'importe quel type, mais il peut produire des types impos

Type guard est une technique utilisée pour affiner ou vérifier le type d'une variable dans une partie donnée du code. Cela permet à TypeScript de savoir, à l'exécution, qu'une variable est d'un type spécifique, ce qui permet d'accéder en toute sécurité aux propriétés ou méthodes propres à ce type. Les type guards s'appuient sur des conditions logiques (comme les opérateurs typeof, instanceof, ou des fonctions personnalisées) pour aider TypeScript à déduire le type exact d'une variable

Avec typeof Utilisé pour vérifier les types primitifs comme string, number, boolean, etc.

Avec instanceof Utilisé pour vérifier si un objet est une instance d'une classe.

Avec des fonctions personnalisées La fonction doit utiliser une assertion de type sous la forme : variable is Type

As est une assertion de type : on dit au compilateur « considère cette valeur comme ce type ».

Elle ne change rien au runtime et peut forcer un type même si le compilateur n'est pas sûr — à utiliser seulement quand on est certain du type réel.

Satifies c'est un opérateur de vérification : il s'assure qu'une valeur respecte un type tout en gardant son type précis et en signalant les clés en trop.

C'est plus sûr que as car ça ne masque pas les erreurs et garde l'inférence intacte.

As Vs Satifies

as force un type (même si c'est risqué) et peut masquer des erreurs, alors que satisfies vérifie que la valeur respecte le type sans perdre l'inférence et signale les propriétés en trop.

StrictNullChecks est une option du compilateur TypeScript qui empêche d'utiliser null ou undefined comme si c'était des valeurs valides d'un type sans les déclarer explicitement.

Autrement dit, si elle est activée, string signifie vraiment "jamais null ou undefined", et on doit gérer ces cas de façon explicite. Cela réduit fortement les bugs à l'exécution.

symbol est un type primitif qui sert à créer des identifiants uniques.

Chaque Symbol() est garanti unique, même si on lui donne la même description.

On l'utilise pour créer des clés d'objet impossibles à écraser par accident, ou pour des concepts spéciaux comme les well-known symbols (ex. Symbol.iterator)

Narrowing c'est le processus par TypeScript qui permet de réduire un type plus large (union, unknown, any) à un type plus précis grâce à des vérifications de code.

Cela permet d'avoir une autocomplétion correcte et d'éviter les erreurs au runtime

Cinq techniques font partie des moyens de narrowing

Utilisé pour affiner un type en fonction de son type primitif à l'exécution.

Affiner un type en vérifiant si l'objet est instance d'une classe.

Comparer une valeur avec null ou undefined pour affiner.Très utile avec strictNullChecks activé pour éviter les erreurs.

Tester la présence d'une propriété pour savoir quel type est actif.

Créer ta propre fonction de narrowing.

TypeScript reconnaît les fonctions qui retournent un type prédicat (x is Type).

keyof me permet d'obtenir l'union des noms de propriétés d'un type pour créer des fonctions et des utilitaires génériques 100 % type-safe. Par exemple, je peux forcer qu'une clé passée en paramètre existe réellement sur l'objet, ce qui élimine toute une classe d'erreurs.

Utilisation

• Créer des fonctions génériques type-safe
• Créer des types dynamiques

Mapped Types permettent de transformer un type existant en itérant sur ses clés (keyof) pour produire un nouveau type.

C'est un peu comme faire un map sur les propriétés d'un objet, mais au niveau du système de type.

Key Remapping(TypeScript 4.1) permet de renommer, filtrer ou transformer les clés d'un type lors d'un mapped type.

On utilise la syntaxe as dans la clause [K in keyof T as ...].

Un decorator est une fonction spéciale qui peut être appliquée à une classe, une méthode, une propriété ou un paramètre pour ajouter du comportement ou des métadonnées.

C'est comme un "middleware" au niveau du code : il intercepte et enrichit la définition.

C'est un feature expérimentale (TS doit être configuré avec experimentalDecorators: true)

Types de decorators

• Class Decorator: Agit sur une classe entière.
• Property Decorator: Appliqué sur une propriété.
• Method Decorator: Appliqué sur une méthode pour modifier son comportement.
• Parameter Decorator: Appliqué sur un paramètre d'une méthode pour stocker des infos.

CONST

• Const a besoin d'être déclaré avec une valeur initiale. La portée de const est celle du bloc
• On ne peut pas changer sa valeur après déclaration
• Avec const pour objet, on peut changer les propriétés d'un objet existant mais ne pas Réassigner un nouvel objet
• Const n'est pas hosting

LET

• Il n'est pas obligatoire de déclarer une variable avec sa valeur initiale.
• On peut modifier sa valeur après sa déclaration
• Elle est limitée à celle du bloc courant
• LET n'est pas hosting

VAR : permet de déclarer des variables qui ont une portée globale ou de fonction, c'est-à-dire qu'elles peuvent être utilisées partout dans le code à l'intérieur de leur portée. Les variables var peuvent être réaffectées avec une nouvelle valeur. Si une variable var est déclarée sans être initialisée, elle aura la valeur undefined.

Les triple-slash directives sont des commentaires spéciaux comme /// \<reference types="node" /> qui indiquent au compilateur d'inclure certains fichiers ou définitions de type. Je les utilise surtout dans les .d.ts ou pour inclure les types globaux d'une lib (Node, Jest) dans un projet qui n'a pas d'import explicite.

Un module en TypeScript est simplement un fichier avec un scope propre qui exporte et importe explicitement ses symboles. Cela permet d'avoir un code isolé, maintenable et tree-shakable. J'utilise systématiquement les ES Modules (import/export) et j'évite les scripts globaux pour prévenir les collisions et améliorer la lisibilité.