Javascript

JavaScript (JS) est un langage de programmation interprété, dynamique et orienté prototype, créé en 1995 par Brendan Eich chez Netscape en seulement 10 jours. C’est aujourd’hui le seul langage natif des navigateurs web et l’un des plus utilisés au monde.

Caractéristiques principales

Dynamiquement typé – pas besoin de déclarer le type des variables
Interprété – exécuté directement sans compilation
Orienté prototype – l’héritage se fait via des prototypes (pas de classes au sens strict)
Multiparadigme – supporte la POO, la programmation fonctionnelle et impérative
Asynchrone – gestion native de l’asynchronisme (callbacks, Promises, async/await)
Single-threaded – un seul fil d’exécution, mais non bloquant grâce à l’Event Loop

Les versions (ECMAScript)

JavaScript est standardisé sous le nom ECMAScript (ES) :

Version	Année	Nouveautés clés
ES5	2009	strict mode, JSON natif
ES6 / ES2015	2015	let/const, classes, arrow functions, Promises, modules
ES2017	2017	async/await
ES2020	2020	optional chaining ?., nullish coalescing ??
ES2022+	2022+	top-level await, méthodes de classe privées

Les types de données

// Primitifs
let nom = "Alice";        // String
let age = 30;             // Number
let actif = true;         // Boolean
let rien = null;          // Null
let inconnu = undefined;  // Undefined
let id = Symbol();        // Symbol
let big = 9007199254740991n; // BigInt

// Référence
let tableau = [1, 2, 3];          // Array
let objet = { nom: "Alice" };     // Object
let fn = function() {};            // Function

Concepts fondamentaux

Fonctions

// Déclaration classique
function saluer(nom) {
  return `Bonjour ${nom}`;
}

// Arrow function (ES6)
const saluer = (nom) => `Bonjour ${nom}`;

Asynchronisme

// Avec async/await
async function fetchData() {
  try {
    const response = await fetch("https://api.example.com/data");
    const data = await response.json();
    return data;
  } catch (err) {
    console.error(err);
  }
}

Destructuring

const { nom, age } = utilisateur;
const [premier, ...reste] = tableau;

Spread / Rest

const fusion = { ...obj1, ...obj2 };
const somme = (...nombres) => nombres.reduce((a, b) => a + b, 0);

L’Event Loop

C’est le mécanisme qui permet à JS d’être non bloquant malgré son thread unique :

Call Stack  Web APIs  Callback Queue  Event Loop  Call Stack

Le code synchrone s’exécute dans la Call Stack
Les opérations async (setTimeout, fetch…) sont déléguées aux Web APIs
Une fois terminées, leurs callbacks rejoignent la Queue
L’Event Loop les réinjecte dans la Stack quand elle est vide

Où s’exécute JavaScript ?

Environnement	Moteur	Usage
Navigateur	V8 (Chrome), SpiderMonkey (Firefox)	Frontend, DOM
Serveur	Node.js (V8)	Backend, APIs
Mobile	React Native, Expo	Apps mobiles
Desktop	Electron	Apps desktop
Edge	Cloudflare Workers, Deno	Edge computing

Les points délicats à connaître

// Coercition de type (piège classique)
"5" + 3      // "53" (concaténation)
"5" - 3      // 2   (soustraction)

// Égalité
0 == false   // true  (== avec coercition)
0 === false  // false (=== strict, recommandé)

// Hoisting
console.log(x); // undefined (pas d'erreur !)
var x = 5;

// this (contexte variable)
const obj = {
  nom: "Alice",
  saluer() { console.log(this.nom); } // 
  saluerArrow: () => console.log(this.nom) //  this != obj
};

TypeScript

TypeScript est un sur-ensemble de JavaScript développé par Microsoft qui ajoute le typage statique :

function saluer(nom: string): string {
  return `Bonjour ${nom}`;
}

Il se compile en JavaScript et est aujourd’hui très largement adopté en production.

En résumé

Atout	Limite
Universel (front + back)	Typage dynamique = bugs subtils
Grande communauté	Coercition de type déroutante
Asynchronisme natif	(this) parfois confus
Écosystème immense (npm)	Fatigue des frameworks
Facile à démarrer	Difficile à maîtriser