Maîtrise des Objets Fondamentaux en JavaScript : Wrappers, Date, RegExp et Objets Uniques

JavaScript met à disposition une panoplie d'objets intégrés, essentiels pour la gestion des tâches quotidiennes de développement. Cet article propose une exploration approfondie des objets wrappers (empaquetage) et de leurs méthodes, de la manipulation des dates avec l'objet Date, de l'utilisation des expressions régulières (RegExp), et des objets built-in uniques. Des exemples de code détaillés illustreront ces concepts centraux.

  1. Les Objets Wrappers (Objets d'Empaquetage)

1.1. Comprendre le Mécanisme des Wrappers

Les types de données primitifs en JavaScript (String, Number, Boolean) ne possèdent ni propriétés ni méthodes. Cependant, grâce au mécanisme d'auto-empaquetage (autoboxing), le moteur JavaScript crée temporairement un objet wrapper correspondant chaque fois qu'une méthode est appelée sur une valeur primitive :

let phrase = 'bonjour le monde';
console.log(phrase.length); // 16 (un objet String temporaire est créé)

// Ce processus est conceptuellement similaire à :
const tempString = new String(phrase);
const taille = tempString.length;
// tempString est ensuite détruit

Il existe trois types d'objets wrappers :

  • String : pour les opérations sur les chaînes de caractères.
  • Number : pour les opérations sur les valeurs numériques.
  • Boolean : pour les opérations sur les valeurs booléennes.

Il est crucial de distinguer les valeurs primitives de leurs objets wrappers correspondants :

const valeurPrimitive = 'test';
typeof valeurPrimitive; // 'string'

const objetWrapper = new String('test');
typeof objetWrapper; // 'object'
valeurPrimitive instanceof String; // false
objetWrapper instanceof String; // true

1.2. Méthodes Courantes des Objets Wrappers

a. Méthodes de l'objet String

const description = "JavaScript et ses objets wrappers";

// Extraction de sous-chaînes
console.log(description.slice(0, 10)); // "JavaScript"
console.log(description.substring(4, 10)); // "Script"

// Changement de casse
console.log('exemple'.toUpperCase()); // "EXEMPLE"

// Vérification de contenu et position
console.log(description.includes("objets")); // true
console.log(description.indexOf("wrappers")); // 20

// Utilisation de RegExp (voir section dédiée)
console.log(description.match(/s\s(\w+)/)); // ["s ses", "ses", index: 11, ...]

b. Méthodes de l'objet Number

const montant = 42.12345;

// Contrôle de la précision
console.log(montant.toFixed(2)); // "42.12" (chaîne de caractères)
console.log(montant.toPrecision(3)); // "42.1" (chaîne de caractères)

// Représentations spécifiques
console.log(montant.toExponential(1)); // "4.2e+1"

c. Piège avec l'objet Boolean

Un objet Boolean, même créé avec false, est toujours considéré comme "truthy" (vrai) dans un contexte booléen. C'est une erreur fréquente :

const boolObjet = new Boolean(false);

if (boolObjet) {
  console.log('Ce bloc s\'exécute toujours !'); // S'exécute
}

// Pour obtenir la valeur primitive, utilisez valueOf()
if (boolObjet.valueOf()) {
  console.log('Ce bloc ne s\'exécute pas.');
}

1.3. Principe d'Empaquetage et de Désempaquteage

  • Empaquetage (Boxing) : Transformation d'une valeur primitive en un objet wrapper temporaire pour accéder à ses méthodes.
  • Désempaquetage (Unboxing) : Récupération de la valeur primitive à partir d'un objet wrapper (souvent implicite, ou via .valueOf()).
// Empaquetage explicite (rarement recommandé)
const monNumObj = new Number(25);

// Désempaquetage explicite
console.log(monNumObj.valueOf()); // 25
  1. Manipulation des Dates et Heures avec l'Objet Date

2.1. Création d'Instances de Date

L'objet Date permet de travailler avec les dates et heures. Voici les principales façons de l'instancier :

// 1. Date et heure actuelles
const maintenant = new Date();
console.log(maintenant);

// 2. À partir d'un horodatage (nombre de millisecondes depuis le 1er janv. 1970 UTC)
const epochTime = new Date(1678886400000); // Ex: 15 mars 2023
console.log(epochTime);

// 3. À partir d'une chaîne de date/heure (format ISO 8601 recommandé)
const dateChaine = new Date("2024-11-20T10:30:00Z");
console.log(dateChaine);

// 4. À partir de composants individuels (attention : le mois est basé sur 0, Janvier = 0)
const dateSpecifique = new Date(2024, 9, 26, 14, 45, 0); // 26 octobre 2024, 14h45
console.log(dateSpecifique);

2.2. Opérations et Calculs sur les Dates

a. Accéder ou Modifier les Composants d'une Date

const maDate = new Date(); // Aujourd'hui

// Récupérer l'année (méthode complète)
console.log(`Année : ${maDate.getFullYear()}`);

// Récupérer le mois (0-11)
console.log(`Mois (0-11) : ${maDate.getMonth()}`);

// Changer le jour du mois (ajouter 7 jours)
maDate.setDate(maDate.getDate() + 7);
console.log(`Date dans 7 jours : ${maDate.toLocaleDateString()}`);

b. Formatage et Conversion des Dates

const dateEvenement = new Date(2025, 0, 1); // 1er janvier 2025

// Formatage localisé
console.log(dateEvenement.toLocaleDateString('fr-FR')); // "01/01/2025"

// Formatage UTC (temps universel coordonné)
console.log(dateEvenement.toUTCString()); // "Wed, 01 Jan 2025 00:00:00 GMT"

// Horodatage en millisecondes
console.log(dateEvenement.getTime());

c. Comparaison de Dates

Les objets Date peuvent être comparés directement, car ils sont implicitement convertis en horodatages numériques.

const dateLimite = new Date(2025, 11, 31); // 31 décembre 2025
const aujourdHui = new Date();

if (dateLimite > aujourdHui) {
  const diffMs = dateLimite.getTime() - aujourdHui.getTime();
  const joursRestants = Math.ceil(diffMs / (1000 * 60 * 60 * 24));
  console.log(`Il reste ${joursRestants} jours avant la date limite.`);
} else {
  console.log("La date limite est passée.");
}
  1. Les Expressions Régulières (RegExp)

3.1. Création d'Expressions Régulières

Deux méthodes principales pour définir des expressions régulières :

// 1. Littéral de RegExp (recommandé pour les motifs statiques)
const motifStatique = /abc\d+/i; // 'i' pour ignorer la casse

// 2. Constructeur RegExp (utile pour les motifs dynamiques)
const termeRecherche = "utilisateur_\\d+"; // Notez le double échappement du backslash
const motifDynamique = new RegExp(termeRecherche, "g"); // 'g' pour recherche globale

3.2. Drapeaux (Flags) Communs

Les drapeaux modifient le comportement de l'expression régulière :

Drapeau Signification Exemple
g Global (toutes les correspondances, pas seulement la première) /mot/g
i Insensible à la casse /Hello/i
m Multiligne (^ et $ correspondent au début/fin de chaque ligne) /^ligne/m
u Support Unicode complet /\p{Emoji}/u
y Adhérent (recherche uniquement à partir de lastIndex) /\w+/y

3.3. Méthodes Clés et Applications

a. test() : Vérification Simple de Correspondance

Retourne true si une correspondance est trouvée, false sinon.

const emailValide = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
console.log(emailValide.test("mon.email@domaine.com")); // true
console.log(emailValide.test("invalide-email")); // false

b. exec() : Extraction des Groupes de Capture

Retourne un tableau d'informations sur la correspondance ou null. Très utile pour extraire des parties spécifiques du texte.

const motifDate = /(\d{4})-(\d{2})-(\d{2})/;
const resultat = motifDate.exec("Date de naissance: 1990-03-15.");

if (resultat) {
  console.log(`Année: ${resultat[1]}, Mois: ${resultat[2]}, Jour: ${resultat[3]}`);
  // Année: 1990, Mois: 03, Jour: 15
}

c. Utilisation avec les Méthodes de String

Plusieurs méthodes de l'objet String acceptent une RegExp en argument :

const article = "HTML, CSS, JavaScript sont essentiels pour le web.";

// split() : Diviser une chaîne par un motif
console.log(article.split(/,\s*/)); // ["HTML", "CSS", "JavaScript sont essentiels pour le web."]

// replace() : Remplacer des correspondances
console.log(article.replace(/web/i, "développement web"));
// "HTML, CSS, JavaScript sont essentiels pour le développement web."

// search() : Trouver l'index de la première correspondance
console.log(article.search(/java/i)); // 9

3.4. Groupes de Capture et Non-Capture

// Groupe de capture : Les parenthèses ( ) créent un groupe capturé
const motifRepete = /(\w+) \1/; // Trouve un mot suivi du même mot
console.log(motifRepete.test("bonjour bonjour")); // true

// Groupe de non-capture : (?: ) crée un groupe qui ne sera pas capturé
const motifNoCapture = /(?:préfixe-)(\d+)/;
const matchNC = motifNoCapture.exec("préfixe-12345");
console.log(matchNC[1]); // "12345" (le groupe "préfixe-" n'est pas inclus dans les captures)
  1. Objets Built-in Uniques (Singletons)

4.1. L'Objet Math pour les Opérations Mathématiques

L'objet Math est un objet singleton qui fournit des fonctions et des constantes mathématiques. Il n'a pas de constructeur et toutes ses propriétés et méthodes sont statiques.

Propriétés Utiles

console.log(Math.PI);    // 3.141592653589793
console.log(Math.E);     // 2.718281828459045 (base des logarithmes naturels)

Méthodes de Traitement Numérique

// Fonctions d'arrondi
console.log(Math.floor(5.9));  // 5 (arrondi vers le bas)
console.log(Math.ceil(5.1));   // 6 (arrondi vers le haut)
console.log(Math.round(5.5));  // 6 (arrondi au plus proche)
console.log(Math.trunc(5.8));  // 5 (tronque la partie décimale)

// Min/Max
console.log(Math.max(10, 30, 5)); // 30
console.log(Math.min(...[2, 7, 1])); // 1 (avec l'opérateur spread)

Nombres Aléatoires et Fonctions Trigonométriques

// Génération de nombre aléatoire (entre 0 inclus et 1 exclus)
console.log(Math.random());

// Fonction utilitaire pour un entier aléatoire dans une plage [min, max]
function obtenirEntierAleatoire(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(obtenirEntierAleatoire(1, 10)); // Un entier entre 1 et 10

// Fonctions trigonométriques (les angles sont en radians)
console.log(Math.sin(Math.PI / 2)); // 1 (sin(90°))
console.log(Math.cos(0));          // 1 (cos(0°))

4.2. Implémentation du Motif Singleton

Le motif de conception Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci. En JavaScript, il peut être implémenté via des fermetures (closures) ou des classes avec une propriété statique.

class ConfigurationGlobale {
  constructor() {
    if (ConfigurationGlobale.instance) {
      return ConfigurationGlobale.instance;
    }
    this.parametres = {
      langue: 'fr',
      theme: 'sombre'
    };
    ConfigurationGlobale.instance = this;
  }

  getParam(cle) {
    return this.parametres[cle];
  }

  setParam(cle, valeur) {
    this.parametres[cle] = valeur;
  }
}

// L'instance de singleton peut être gelée pour la rendre immuable
const configApp = Object.freeze(new ConfigurationGlobale());

// Accès et test du singleton
const conf1 = new ConfigurationGlobale();
const conf2 = new ConfigurationGlobale();

console.log(conf1 === conf2); // true (elles sont la même instance)
console.log(configApp.getParam('langue')); // 'fr'

conf1.setParam('theme', 'clair');
console.log(configApp.getParam('theme')); // 'clair' (modifié via conf1, visible par tous)

Étiquettes: JavaScript RegExp Date Math WrapperObjects

Publié le 20 juin à 23h58

Étiquettes Populaires

©2026 L'Atelier Monstre