Qu'est qu'une expression régulière

Définition
Une expression régulière est une suite de caractères dont chacun a un sens précis. Le motif ou profil est
formé par cette suite de caractères.

Les expressions régulières vont vous permettre de créer des critères de recherche pour faire des
recherches dans des chaînes de caractères ou pour remplacer les occurrences (bout de chaîne) par
d'autres.

Construire une expression régulière

Il existe deux façons de créer une expression régulière.La première consiste à la déclarer comme un objet
String en remplaçant les '"' par des '/'.

var exp_reg = /MOMO/gi;

La seconde consiste à déclarer un objet RegExp.

var exp_reg = new RegExp("MOMO","gi")

Le type

Le type se trouve en fin d'expression régulière. Dans le cas de l'objet javascript string nous le mettons après
le "/"; dans le cas de l'objet RegExp nous le mettons dans le paramètre passé.
Il permet de donner des informations sur la manière dont expression régulière "va être appliquée".
Les types sont :
- g, l'expression régulière recherche toutes les correspondances et pas seulement la première.
- i, l'expression régulière ne doit pas tenir en compte des majuscules et minuscules.
- m, l'expression régulière doit tenir en compte des lignes (voir ^ et $).
- gim les trois types réunis (les options peuvent être utilisées séparément ou ensemble)

Exemples :

Dans ces exemples nous allons afficher toutes les correspondances trouvées.
Exemple avec g :

var momo = "dmc DMC dmc Dmc ";

var exp_reg = /dmc/g;
var liste = momo.match(exp_reg);
console.log(liste);

Exemple sans g :

var momo = "dmc DMC dmc Dmc ";

var exp_reg = /dmc/;
var liste = momo.match(exp_reg);
console.log(liste);

Exemple avec i :
var momo = "dmc DMC dmc Dmc ";
var exp_reg = /dmc/i;
var liste = momo.match(exp_reg);
console.log(liste);

Exemple avec gi :

Caractères interdits

Certains caractères ont une symbolique spécifique dans la construction de l'expression régulière.
Donc, si vous voulez tester ce caractère en tant que caractère d'une chaîne, vous devez utiliser leur
équivalence :
Le \ est donc un caractère spécial.

Attention, si vous déclarer une nouvelle occurrence de RegExp, vous devez doubler le "\".

var exp_reg = /\d_dm[a-d]/gi;

var exp_reg = new RegExp("\d_dm[a-d]","gi");

^ et $ fin et début de chaîne

Définition
Les caractères ^ et $ sont des caractères spéciaux.Le caractère ^ représente un début de chaîne ou
début de ligne.

var momo = "dmc_1 dmc_2 bla bla";

var exp_reg = /^dmc_\d/gi;
/* recherche la chaîne commencant par "dmc_" suivit d'un chiffre.*/
var liste = momo.match(exp_reg);
console.log(liste);

Le caractère $ représente une fin de chaîne ou fin de ligne.

var momo = "dmc_1 dmc dmc_2";

var exp_reg = /dmc_\d$/gi;
/* recherche la chaîne finissant par "dmc_" suivit d'un chiffre.
si vous remplacer "dmc_2" par "dmc_22" pas de résultat
*/
var liste = momo.match(exp_reg);
console.log(liste);

Exemple sans le caractère $ et ^.

var momo = "dmc_1 dmc dmc_2";

var exp_reg = /dmc_\d/gi;
/* recherche la chaîne "dmc_" suivit d'un chiffre.*/
var liste = momo.match(exp_reg);
console.log(liste);

Frontière de mot

Définition
Les caractères b et B sont des caractères spéciaux.

Exemple avec b :

var momo = "admc_0 dmc_1 dmcc_2 DM_3";

var exp_reg = /\bdmc*_\d/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Exemple avec B :

var momo = "0_dmca dmc 2_dmccc";

var exp_reg = /\d_dmc\B/gi;

var liste = momo.match(exp_reg);

console.log(liste);

N'importe quel caractère

Définition
Le caractère point "." est un caractère spécial qui désigne tous les caractères sauf nouvelle ligne(\n).

var momo = "dmcbc dmcac dmccc";

var exp_reg = /c.c/gi;

var liste = momo.match(exp_reg);

console.log(liste);

Chaîne suivit de

L'expression "str(?=b)" permet de trouver une chaîne str uniquement suivie de b.

var momo = "aliasdmc aliasmomo";

var exp_reg = /alias(?=dmc)/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Chaîne pas suivit par

L'expression "a(?!b)" permet de trouver une chaîne a qui n'est pas suivie de b.

var momo = "aliasdmc aliasmomo";

var exp_reg = /alias(?!dmc)/gi
var resultat = momo.replace(exp_reg, "cool");
console.log(resultat);

Les caractères de répétitions

Définitions *, +, ?
Les caractères *, +, ? et {} sont des caractères spéciaux. Ils permettent de spécifier les répétitions des
caractères.
Le caractère * signifie que le caractère qui le précède est répété aucune fois ou plusieurs fois.
"dmc*": chaîne qui contient "dm" suivie d'aucun ou plusieurs "c" ("dm", "dmc", "dmcc",...).
Equivalant à "{0,}".

Exemples :

var momo = "0_dm 1_dmc 2_dmcc 3_dmccc 4_dma";

var exp_reg = /\d_dmc*/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Le caractère + signifie que le caractère qui le précède est répété une fois ou plusieurs fois.
"dmc+": chaîne qui contient "dm" suivie de un ou plusieurs "c" ("dmc", "dmcc", "dmccc",...).
Equivalant à "{1,}".

var momo = "0_dm 1_dmc 2_dmcc 3_dmccc 4_dma";

var exp_reg = /\d_dmc+/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Le caractère ? signifie que le caractère qui le précède est répété aucune fois ou une fois.
"dmc?": chaîne qui contient "dmc" suivie d'aucun ou d'un "c" ("dmc", "dmcc", "dmccc",...).
Equivalant à "{0,1}".

var momo = "0_dm 1_dmc 2_dmcc 3_dmccc 4_dma";

var exp_reg = /\d_dmc?/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Définitions {}
Les accolades {début,fin} est un autre moyen de donner des limites au nombre de répétitions du caractère
qui les précèdes.

- début, peut prendre la valeur de 0 et plus. Valeur obligatoire.

- fin, peut prendre la valeur de 0 et plus. Valeur facultative. Dans ce cas ne rien mettre {0,}

Exemples :

var momo = "0_dm 1_dmc 2_dmcc 3_dmccc 4_dma";

var exp_reg = /\d_dmc{1,3}/gi;
var liste = momo.match(exp_reg);
console.log(liste);
Les regroupements

Les parenthèses
Les parenthèses () vont vous permettre de regrouper un motif.

var momo = "aliasdmc.fr";

var exp_reg = /((a.*)(d.*)\.)(org|fr)/gi;
var liste = momo.match(exp_reg);
console.log(liste);

En utilisant les parenthèses () on pourra ensuite référencer dans le paramètre remplacement par les
caractères $1, $2,...,$9.

var momo = "aliasdmc.fr";

var exp_reg = /((a.*)(d.*)\.)(org|fr)/gi;
console.log(momo.replace(exp_reg,"$9|$8|$7|$6|$5|$4|$3|$2|$1"));

Ingnore ce regroupement
L'exepression "(?:chaîne)" permet d'exclure un regroupement du tableau de résultats ou des propriétés
prédéfinies $1,...

var momo = "aliasdmc.fr";

var exp_reg = /((a.*)(d.*).)(?:org|fr)/gi;
console.log(momo.replace(exp_reg,"$9|$8|$7|$6|$5|$4|$3|$2|$1"));

Opérateur OU
Le caractères spécial | permet d'insérer une condition, il se comporte en tant qu'opérateur OU.

var momo = "aliasdmc.fr aliasdmc.com aliasdmc.org ";

var exp_reg = /(aliasdmc)\.(com|org)/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Liste de caractères

Les crochets [ ]
Les crochets [ ] permettent de spécifier une liste de caractères autorisés.

var momo = "0_dma 1_dmb 2_dmc 3_dmd 4_dme";

var exp_reg = /\d_dm[ab]/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Les crochets [^ ] permettent de spécifier une liste de caractères interdits.

var momo = "0_dma 1_dmb 2_dmc 3_dmd 4_dme";
var exp_reg = /\d_dm[^ab]/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Le caractère spécial -
Le caractères spécial - sert à définir un intervalle dans les crochets [ ].

"[a-z]" correspond aux lettres minuscules de a à z.

"[A-Z]" correspond aux lettres majuscules de A à Z dans ce cas faites attention au type (g,i) que vous avez
mis.
"[a-zA-Z]" correspond aux lettres minuscules et majuscules de a à z.
"[0-9]" correspond aux chiffres de 1 à 9.

var momo = "0_dma 1_dmb 2_dmc 3_dmd 4_dme";

var exp_reg = /\d_dm[a-d]/gi;
var liste = momo.match(exp_reg);
console.log(liste);

Caractère prédéfini

Il existe des caractères spéciaux qui englobent des caractères d'un certain type (numérique, alphanumérique,
...) mais qui ne sont pas des classes.

Méthodes Exp Rég - Cours Javascript

Il existe plusieurs méthodes qui sont utilisées avec les expressions régulières :
- test()
- split()
- match()
- replace()
- search()
- exec()
- compile()

Vocabulaires :
- exp_reguliere , occurrence d'expression régulière (RegExp)
- motif, expression régulière
- chaîne, chaîne de caractères dans laquelle nous allons faire notre recherche.

compile()

Définition
La méthode javascript exp_reguliere.compile(chaîne, modificateur) permet de changer le motif d'une
l'expression régulière déjà créée.

var momo = "ce aliasdmc est un chouette type";

var exp_reg = /MOMO/gi;
console.log(exp_reg.test(momo));//false
exp_reg.compile("DMC", "gi");
console.log(exp_reg.test(momo));//true

La méthode javascript exp_reguliere.compile(chaîne, modificateur) accepte comme paramètre :

- une chaîne de caractères
- modificateur "i", "gi", "g", paramètre facultatif.

exec()

Définition
La méthode javascript exp_reguliere.exec(chaîne) permet de récupérer la première correspondance
trouvée.

var momo = "ce aliasdmc est un chouette type";

var exp_reg = /[a-z]t/gi;
console.log(exp_reg.exec(momo));

La méthode javascript exec(chaîne) accepte comme paramètre une chaîne de caractères.

La méthode javascript exec() renvoie première correspondance trouvée.

search()

Définition
La méthode javascript search(exp_reguliere) permet de trouver une correspondance entre une chaîne de
caractères et une expression régulière.

var momo = "ce aliasdmc est un chouette type";

var exp_reg = /DMC/gi;
console.log(momo.search(exp_reg));
La méthode javascript search(exp_reguliere) accepte comme paramètre une instance d'expression
régulière.

La méthode javascript search() renvoie une valeur de type Number.

- -1, s'il n'y pas de résultat
- l'index de la première correspondance rencontrée.

match()

Définition
La méthode javascript match(exp_reguliere) permet de récupérer toutes les correspondances entre une
chaîne de caractères et une expression régulière sous la forme d'un tableau.

var momo = "ce aliasdmc est un chouette type, ce aliasdmc est un chouette type";
var exp_reg = /[a-z]t/gi;
var liste = momo.match(exp_reg);
console.log(liste);

La méthode javascript match(exp_reguliere) accepte comme paramètre une instance d'expression

régulière.

La méthode javascript match() renvoie une valeur de type :

- Array, tableau avec tous les résultats.
- null, s'il n'y pas de résultat

replace()

Définition
La méthode javascript replace(exp_reguliere, remplacement) permet de remplacer une correspondance
entre une chaîne de caractères et une expression régulière.

var momo = "ce aliasdmc est un chouette type";

var exp_reg = /un/gi;
console.log(momo.replace(exp_reg, "une"));

La méthode javascript replace(exp_reguliere, remplacement) accepte comme paramètre :

- une instance d'expression régulière.
- une String qui correspond à la nouvelle valeur de la correspondance ou $1, $2,..., $9 qui correspond aux 9
premiers groupements .

La méthode javascript replace() renvoie la nouvelle chaîne modifier ou non.

split()

Définition
La méthode javascript split(exp_reguliere, nombreOcccurence) permet de découper une chaîne de
caractères suivant un séparateur (une expression régulière) Le résultat est un tableau.
var momo = "ce aliasdmc est un chouette type";
var exp_reg = /e/gi;
var liste = momo.split(exp_reg);
console.log(liste);

Si on met un paramètre nombreOcccurence de 3:

var momo = "ce aliasdmc est un chouette type";

var exp_reg = /e/gi;
var liste = momo.split(exp_reg,3);
console.log(liste);

La méthode javascript split(exp_reguliere, remplacement) accepte comme paramètre :

- une instance d'expression régulière.
- remplacement valeur de type Number qui limite le nombre de résultats que l'on veut, paramètre facultatif.

La méthode javascript split() renvoie une valeur de type Array.

test()

Définition
La méthode javascript exp_reguliere.test(chaîne) permet de tester une correspondance entre une chaîne
de caractères et une expression régulière.
var momo = "ce aliasdmc est un chouette type";
var exp_reg = /DMC/gi;
console.log(exp_reg.test(momo));

La méthode javascript exp_reguliere.test(chaîne) accepte comme paramètre une chaîne de caractères.

La méthode javascript test() renvoie une valeur de type Boolean.

- true, s'il y correspondance
- false dans le cas contraire.

Manipulation des dates/heures en Javascript

Manipuler les dates et le temps est très utile. Récupérer la date locale d’un visiteur, convertir une date en
temps GMT, extraire les minutes ou les jours à des fins de calcul ou utiliser un délai pour exécuter des
fonctions récursive, et autres manipulations.

L’objet Date
L’objet " date " du Javascript permet d’accéder et de manipuler le format date et heure. Les méthodes sont
très semblables au Java, enregistre en milliseconde depuis le 1er Janvier 1970 00 :00 :00, elles ne seront
plus valides vers 2032 si je me rappelle bien, et ce en raison du nombre limité d’octets !!. Enfin, d’ici là,
amusons-nous un peu. Explications, exemple et une librairie de fonctions utiles.

Pour manipuler une date ou obtenir la date du jour vous devez créer un objet date. Il y a quatre façons de
faire.

 NomObjet = new Date()

 NomObjet = new Date(" mois Jour, année heures:minutes:secondes ")
 NomObjet = new Date(année, mois, jour)
 NomObjet = new Date(année, mois, jour, heures, minutes, secondes)

 La première syntaxe permet d’obtenir la date du jour dans le format (MM/JJ/AA)

 La deuxième permet de forcer une date avec l’heure. chaîne de car. (string)
 Les troisième et quatrième syntaxes en format (integer).

En n’initialisant pas l’heure (heure, minutes, secondes), leur valeur sera à zéro.

Exemples :

var dAujourdhui = new Date();

console.log(dAujourdhui);
var dNoel = new Date("February 5, 2001 18:15:00");
console.log(dNoel);
var dNoel = new Date(97, 12, 25);
console.log(dNoel);
var dNoel = new Date(97, 12, 25, 1, 0, 0);
console.log(dNoel);

Les Méthodes

Une fois votre objet crée ou la date du jour obtenu, vous pouvez utiliser les méthodes suivantes pour
manipuler votre objet.

Exemples

NomObjet.NomMethode(paramètres).
FONCTION : getDate()

Retourne le jour du mois pour une date spécifique. Nombre entre 1 et 31

Syntaxe : NomObjet.getDate()

Paramètres : aucun

var maDate = new Date();

console.log("maDate = "+maDate);
var jour = maDate.getDate();
console.log("getDate = "+jour);

var maDate = new Date();

console.log("maDate = "+maDate);
var nbJour = maDate.getDay();
console.log("getDay = "+nbJour);
FONCTION : getHours()

Retourne l’heure d’une date spécifique. Nombre entre 0 et 23.

Syntaxe : NomObjet.getHours()

Paramètres : aucun

var maDate = new Date();

console.log("maDate = "+maDate);
nHeure = maDate.getHours();
console.log("getHours = "+nHeure);

FONCTION : getMinutes()

Retourne les minutes d’une date spécifique. Nombre entre 0 et 59.

Syntaxe : NomObjet.getMinutes()

Paramètres : aucun

console.log("---------------------------------------------------------");
maDate = new Date();
nMinutes = maDate.getMinutes();

console.log("maDate = "+maDate+"\ngetMinutes = "+nMinutes);

console.log("---------------------------------------------------------");

FONCTION : getMonth()

Retourne le mois d’une date spécifique. Nombre entre 0 et 11.

Syntaxe : NomObjet.getMonth()

Paramètres : aucun

console.log("---------------------------------------------------------");
maDate = new Date();
nMois = maDate.getMonth();

console.log("maDate = "+maDate+"\ngetMonth = "+nMois);

console.log("---------------------------------------------------------");
FONCTION : getSeconds()

Retourne les secondes d’une date spécifique. Nombre entre 0 et 59.

Syntaxe : NomObjet.getSeconds()

Paramètres : aucun

console.log("---------------------------------------------------------");
maDate = new Date();
nSec = maDate.getSeconds();

console.log("maDate = "+maDate+"\ngetSeconds = "+nSec);

console.log("---------------------------------------------------------");

FONCTION : getTime()

Retourne le nombre de milisecondes depuis le 1er janvier 1970.

Syntaxe : NomObjet.getTime()

Paramètres : aucun

console.log("---------------------------------------------------------");
maDate = new Date();
nTemps = maDate.getTime();

console.log("maDate = "+maDate+"\ngetTime = "+nTemps);

console.log("---------------------------------------------------------");
FONCTION : getYear()

Retourne l’année d’une date spécifique. À partir de 1900. En bas de 2000, l’année ne retourne que deux caractères
Ex: 1995 = 95

Syntaxe : NomObjet.getYear()

Paramètres : aucun

console.log("---------------------------------------------------------");
maDate1 = new Date();
maDate2 = new Date("February 5, 1995 23:15:00");
maDate3 = new Date("February 5, 2001 23:15:00");
nAnnee1 = maDate1.getYear();
nAnnee2 = maDate2.getYear();
nAnnee3 = maDate3.getYear();

console.log("maDate1 = "+maDate1+"\ngetYear = "+nAnnee1

+"\nmaDate2 = "+maDate2+"\ngetYear = "+nAnnee2
+"\nmaDate3 = "+maDate3+"\ngetYear = "+nAnnee3);
console.log("---------------------------------------------------------");

FONCTION : setDate()

Change la date d’un mois.

Syntaxe : NomObjet.setDate(valeurJour)

Paramètres : valeurJour = un nombre entre 1 et 31

console.log("---------------------------------------------------------");
maDate1 = new Date("February 2, 2001 18:15:00");
maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setDate(5);

console.log("maDate = "+maDate1+"\nsetDate = "+maDate2);

console.log("---------------------------------------------------------");
FONCTION : setHours()

Change l’heure d’une date spécifique.

Syntaxe : NomObjet.setHours(valeurHeure)

Paramètres : valeurHeure = un nombre entre 0 et 23

console.log("---------------------------------------------------------");
maDate1 = new Date("February 2, 2001 18:15:00");
maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setHours(23);

console.log("maDate = "+maDate1+"\nsetHours = "+maDate2)

console.log("---------------------------------------------------------");

FONCTION : setMinutes()

Change les minute d’une date spécifique.

Syntaxe : NomObjet.setMinutes(valeurMinutes)

Paramètres : valeurMinutes = un nombre entre 0 et 59

console.log("---------------------------------------------------------");
maDate1 = new Date("February 2, 2001 18:15:00");
maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setMinutes(20);

console.log("maDate = "+maDate1+"\nsetMinutes = "+maDate2);

console.log("---------------------------------------------------------");

FONCTION : setMonth()

Change le mois d’une date spécifique.

Syntaxe : NomObjet.setMonth(valeurMois)
Paramètres : valeurMois = un nombre entre 0 et 11

console.log("---------------------------------------------------------");
maDate1 = new Date("February 2, 2001 18:15:00");
maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setMonth(5);

console.log("maDate = "+maDate1+"\nsetMonth = "+maDate2);

console.log("---------------------------------------------------------");

FONCTION : setSeconds()

Change les secondes d’une date spécifique. Entre 0 et 59.

Syntaxe : NomObjet.setSeconds(valeurSecondes)

Paramètres : valeurSecondes = un nombre entre o et 59

console.log("---------------------------------------------------------");
maDate1 = new Date("February 2, 2001 18:15:00");
maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setSeconds(30);

console.log("maDate = "+maDate1+"\nsetSeconds = "+maDate2);

console.log("---------------------------------------------------------");

FONCTION : setTime()

Change la valeur de l’objet Date.

Syntaxe : NomObjet.setTime(valeurMSec)

Paramètres : valeurMSec = le nombre de milliseconde depuis le 1er janvier 1970 00:00:00.

// Exemple qui passe la date de maDate1 à maDate2

// en passant les millisecondes d’une date à l’autre
maDate1 = new Date("February 5, 2001 23:15:00");
maDate2 = new Date();
maDate2.setTime(maDate1.getTime());

console.log("maDate = "+maDate1+"\nsetTime = "+maDate2);

FONCTION : setTimeout()

Évalue une expression après un certain délais en milisecondes.

Syntaxe : DelaisID = setTimeout(expression, msec)

Syntaxe : clearTimeout(DelaisID)

Paramètres :

- DelaisID = Identifiant pour annuler le délais à l’aide de "clearTimeout"

- expression = fonction ou propriété d’un objet.
- msec = nombre ou propriété d’un objet en milisecondes.

FONCTION : setYear()

Change l’année d’une date spécifique. Entre 0 et 23.

Syntaxe : NomObjet.setYear(valeurAnnee)

Paramètres : valeurAnnee = un nombre entre 1900 et (?) 2032.

maDate1 = new Date("February 2, 2001 18:15:00");

maDate2 = new Date("February 2, 2001 18:15:00");
maDate2.setYear(2002);

console.log("maDate = "+maDate1+"\nsetYear = "+maDate2);