Types par références

Références

Types primitifs

• boolean : true ou false.
• number : tous les nombres, y compris les entiers et les flottants.
• string : chaînes de caractères.
• symbol : (introduit en ES6) : un type unique et immuable utilisé souvent pour les clés d'objet.
• bigInt : pour représenter des entiers très grands.
• null : représente l'absence intentionnelle de valeur.
• undefined : une variable déclarée mais non assignée.

Les caractéristiques clés des types primitifs sont :

• Immutabilité : Les valeurs des types primitifs ne peuvent pas être modifiées une fois créées.
• Copie par valeur : Lorsque vous affectez ou passez une primitive à une fonction, ce qui est copié est la valeur elle-même. Cela signifie que si vous modifiez la nouvelle variable, l'original reste inchangé.

Exemples

function modifyPrimitive(value: number) {
    value = 100; // Modification de la valeur locale à la fonction
    console.log("Valeur dans la fonction : ", value); // Affiche 100
}
 
let originalValue = 50; // Déclaration d'une variable primitive
console.log("Valeur originale avant modification : ", originalValue); // Affiche 50
 
modifyPrimitive(originalValue); // Passage de la primitive à la fonction
console.log("Valeur originale après modification : ", originalValue); // Affiche 50, reste inchangée

Types par référence

Un type par référence est un type qui fait référence à un objet.
Les types par référence, souvent appelés objets, incluent tout ce qui n'est pas un type primitif. En JavaScript et TypeScript, cela comprend :

• object
• array
• function

Les caractéristiques clés des types par référence sont :

Mutabilité : Les objets peuvent être modifiés après leur création, c'est-à-dire que leurs propriétés ou éléments peuvent être changés. Copie par référence : Lorsque vous affectez ou passez un objet à une fonction, ce qui est copié est la référence (ou le pointeur) vers l'objet original, pas l'objet lui-même. Ainsi, si vous modifiez l'objet via cette nouvelle référence, les modifications seront visibles via toutes les autres références à cet objet.

let num1 = 42;         // Type primitif
let num2 = num1;       // Copie par valeur
num2 = 50;             // Modifie num2, num1 reste 42
 
let obj1 = { value: 42 };  // Type par référence
let obj2 = obj1;           // Copie par référence
obj2.value = 50;           // Modifie la propriété 'value' via obj2, obj1.value est aussi 50
 
console.log(obj1); // Affiche 50

Array

const cities: string[] = [”Paris”, “Lille”, “Marseille”]

On a bien l'autocompletion de l'IDE.

Tuples

Les tuples sont des tableaux de taille fixe où chaque élément a un type spécifique.

Exemple

let city: [string, number, string] = [“Paris”, 75, “France”]

Les tuples sont utiles pour représenter des données structurées, comme une adresse ou des coordonnées géographiques.