Validation d'adresses électroniques

Vérifie si une chaîne de caractères est un format d'adresse électronique valide.

export const estAdresseEmailValide = (chaine) => {
 return /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/.test(chaine);
};

Validation de numéros de téléphone mobile

Vérifie si une chaîne correspond à un format de numéro de téléphone mobile français (commençant par 06 ou 07).

export const estMobileFrance = (chaine) => {
 return /^(0|\+33)[67]\d{8}$/.test(chaine);
};

Validation de numéros de téléphone fixe

Valide un format de numéro de téléphone fixe français (incluant les indicatifs régionaux).

export const estTelephoneFixeFrance = (chaine) => {
 return /^(0)\d{9}$/.test(chaine);
};

Vérification d'URL

Détermine si une chaîne est une URL valide.

export const estURL = (chaine) => {
 return /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/.test(chaine);
};

Vérification de type de données

Fonctions utilitaires pour vérifier le type d'une variable (String, Number, Boolean, Function, Null, Undefined, Object, Array, Date, RegExp, Error, Symbol, Promise, Set).

export const estChaine = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'String';
};

export const estNombre = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Number';
};

export const estBooleen = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Boolean';
};

export const estFonction = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Function';
};

export const estNull = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Null';
};

export const estUndefined = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Undefined';
};

export const estObjet = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Object';
};

export const estTableau = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Array';
};

export const estDate = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Date';
};

export const estRegExp = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'RegExp';
};

export const estErreur = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Error';
};

export const estSymbol = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Symbol';
};

export const estPromise = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Promise';
};

export const estSet = (variable) => {
 return Object.prototype.toString.call(variable).slice(8, -1) === 'Set';
};

Détection de navigateur

Détermine si le visiteur utilise un navigateur basé sur WebKit, ou s'il s'agit d'un appareil mobile.

export const estNavigateurWebKit = () => {
 const agentUtilisateur = navigator.userAgent.toLowerCase();
 return /webkit|applewebkit/i.test(agentUtilisateur);
};

export const estAppareilMobile = () => {
 const agentUtilisateur = navigator.userAgent.toLowerCase();
 return /android|webos|iphone|ipad|ipod|blackberry|windows phone/i.test(agentUtilisateur);
};

export const estSurIos = () => {
 const agentUtilisateur = navigator.userAgent;
 return /iphone|ipad|ipod/i.test(agentUtilisateur);
};

export const estSurPC = () => {
 const agentUtilisateur = navigator.userAgent;
 return !/android|webos|iphone|ipad|ipod|blackberry|windows phone/i.test(agentUtilisateur);
};

Manipulation de chaînes de caractères

Fonctions pour supprimer les balises HTML, extraire des paramètres d'URL, et formater des chaînes.

export const supprimerBalisesHtml = (chaine) => {
 return chaine.replace(/<[^>]*>/g, '');
};

export const obtenirParametreUrl = (nomParametre) => {
 const regex = new RegExp('(^|&)' + nomParametre + '=([^&]*)(&|$)');
 const resultat = window.location.search.substr(1).match(regex);
 return resultat ? decodeURIComponent(resultat[2]) : null;
};

export const insererChaine = (chaineSource, index, nouvelleChaine) => {
 return chaineSource.slice(0, index) + nouvelleChaine + chaineSource.slice(index);
};

export const formaterTexte = (chaine, typeFormattage) => {
 switch (typeFormattage) {
   case 1: // Première lettre en majuscule
     return chaine.replace(/\b\w+\b/g, word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase());
   case 2: // Première lettre en minuscule
     return chaine.replace(/\b\w+\b/g, word => word.charAt(0).toLowerCase() + word.slice(1).toUpperCase());
   case 3: // Inverser la casse
     return chaine.split('').map(char => /[a-z]/.test(char) ? char.toUpperCase() : char.toLowerCase()).join('');
   case 4: // Tout en majuscules
     return chaine.toUpperCase();
   case 5: // Tout en minuscules
     return chaine.toLowerCase();
   default:
     return chaine;
 }
};

export const supprimerEspaces = (chaine, type) => {
 switch (type) {
   case 1: // Tous les espaces
     return chaine.replace(/\s+/g, "");
   case 2: // Espaces avant et après
     return chaine.replace(/(^\s*)|(\s*$)/g, "");
   case 3: // Espaces avant
     return chaine.replace(/(^\s*)/g, "");
   case 4: // Espaces après
     return chaine.replace(/(\s*$)/g, "");
   default:
     return chaine;
 }
};

Manipulation de tableuax

Fonctions pour trier, dédupliquer, trouver des unions et intersections, supprimer des éléments, et convertir des tableaux quasi-listes.

export const estContenuDansTableau = (tableau, valeur) => {
 return tableau.includes(valeur);
};

export const trierTableau = (tableau, typeTri = 1) => {
 const tableauCopie = [...tableau]; // Crée une copie pour ne pas modifier l'original
 switch (typeTri) {
   case 1: // Croissant
     return tableauCopie.sort((a, b) => a - b);
   case 2: // Décroissant
     return tableauCopie.sort((a, b) => b - a);
   case 3: // Aléatoire
     return tableauCopie.sort(() => Math.random() - 0.5);
   default:
     return tableauCopie;
 }
};

export const dedupliquerTableau = (tableau) => {
 if (Array.from) {
   return Array.from(new Set(tableau));
 } else {
   const unique = {};
   const resultats = [];
   for (let i = 0; i < tableau.length; i++) {
     if (!unique[tableau[i]]) {
       unique[tableau[i]] = true;
       resultats.push(tableau[i]);
     }
   }
   return resultats;
 }
};

export const unionTableaux = (tableauA, tableauB) => {
 return dedupliquerTableau(tableauA.concat(tableauB));
};

export const intersectionTableaux = (tableauA, tableauB) => {
 const tableauAUnique = dedupliquerTableau(tableauA);
 return tableauAUnique.filter(element => tableauB.includes(element));
};

export const supprimerElementTableau = (tableau, elementASupprimer) => {
 const index = tableau.indexOf(elementASupprimer);
 if (index > -1) {
   tableau.splice(index, 1);
 }
 return tableau;
};

export const convertirTableauQuasiListe = (objetQuasiListe) => {
 if (Array.isArray(objetQuasiListe)) {
   return objetQuasiListe;
 } else {
   return Array.prototype.slice.call(objetQuasiListe);
 }
};

export const trouverMaximum = (tableau) => {
 return Math.max(...tableau);
};

export const trouverMinimum = (tableau) => {
 return Math.min(...tableau);
};

export const calculerSomme = (tableau) => {
 return tableau.reduce((accumulateur, courant) => accumulateur + courant, 0);
};

export const calculerMoyenne = (tableau) => {
 if (tableau.length === 0) return 0;
 return calculerSomme(tableau) / tableau.length;
};

Utilitaires divers

Fonctions pour manipuler le DOM, gérer les promesses, et formater des nombres.

export const injecterScript = (src) => {
 const script = document.createElement('script');
 script.type = 'text/javascript';
 script.async = true;
 script.src = src;
 const premierScript = document.getElementsByTagName('script')[0];
 premierScript.parentNode.insertBefore(script, premierScript);
};

export const telechargerFichier = (url) => {
 const lien = document.createElement('a');
 lien.href = url;
 lien.download = url.substring(url.lastIndexOf('/') + 1);
 document.body.appendChild(lien);
 lien.click();
 document.body.removeChild(lien);
};

export const ajouterClasse = (element, nomClasse) => {
 if (element.classList) {
   element.classList.add(nomClasse);
 } else {
   const regex = new RegExp('(^|\\s)' + nomClasse + '(\\s|$)', 'g');
   if (!regex.test(element.className)) {
     element.className += ' ' + nomClasse;
   }
 }
};

export const supprimerClasse = (element, nomClasse) => {
 if (element.classList) {
   element.classList.remove(nomClasse);
 } else {
   const regex = new RegExp('(^|\\s)' + nomClasse + '(\\s|$)', 'g');
   element.className = element.className.replace(regex, ' ');
 }
};

export const contientClasse = (element, nomClasse) => {
 if (element.classList) {
   return element.classList.contains(nomClasse);
 } else {
   const regex = new RegExp('(^|\\s)' + nomClasse + '(\\s|$)', 'g');
   return regex.test(element.className);
 }
};

export const obtenirPositionScroll = (element = window) => ({
 x: element.pageXOffset !== undefined ? element.pageXOffset : element.scrollLeft,
 y: element.pageYOffset !== undefined ? element.pageYOffset : element.scrollTop
});

export const faireDefilerVersHaut = () => {
 const position = obtenirPositionScroll();
 if (position.y > 0) {
   window.requestAnimationFrame(faireDefilerVersHaut);
   window.scrollTo(0, position.y - position.y / 8);
 }
};

export const estElementVisibleDansViewport = (element, visibilitePartielle = false) => {
 const rect = element.getBoundingClientRect();
 const estVisible = (
   rect.top >= 0 &&
   rect.left >= 0 &&
   rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
   rect.right <= (window.innerWidth || document.documentElement.clientWidth)
 );
 if (visibilitePartielle) {
   return estVisible || (rect.top < (window.innerHeight || document.documentElement.clientHeight) && rect.bottom > 0) || (rect.left < (window.innerWidth || document.documentElement.clientWidth) && rect.right > 0);
 }
 return estVisible;
};

export const melangerTableau = (tableau) => {
 const resultat = [];
 const tableauCopie = [...tableau];
 while (tableauCopie.length > 0) {
   const indexAleatoire = Math.floor(Math.random() * tableauCopie.length);
   resultat.push(tableauCopie.splice(indexAleatoire, 1)[0]);
 }
 return resultat;
};

export const copierTexteDansPressePapiers = (texte) => {
 const textarea = document.createElement("textarea");
 textarea.style.height = "0";
 textarea.style.position = "absolute";
 textarea.style.opacity = "0";
 textarea.value = texte;
 document.body.appendChild(textarea);
 textarea.select();
 try {
   document.execCommand('copy');
 } catch (err) {
   console.error('Erreur lors de la copie du texte:', err);
 }
 document.body.removeChild(textarea);
};

export const verifierFormatChaine = (chaine, type) => {
 const formats = {
   telephone: /^1[3456789]\d{9}$/,
   fixe: /^(0\d{2,3}[- ]?\d{7,8})$/,
   carteIdentite: /(^\d{15}$)|(^\d{17}(\d|x|X)$)/,
   motDePasse: /^[a-zA-Z0-9_]{6,18}$/,
   codePostal: /^[1-9]\d{5}$/,
   qq: /^[1-9][0-9]{4,9}$/,
   email: /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/,
   montant: /^\d+(\.\d{1,2})?$/,
   url: /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/,
   ip: /((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)/,
   date: /^(\d{4})-(\d{2})-(\d{2})$/,
   nombre: /^[0-9]+$/,
   anglais: /^[a-zA-Z]+$/,
   chinois: /^[\u4E00-\u9FA5]+$/,
   minuscules: /^[a-z]+$/,
   majuscules: /^[A-Z]+$/,
   html: /<(\w+)[^>]*>(.*?)<\/\1>/
 };
 const regex = formats[type.toLowerCase()];
 return regex ? regex.test(chaine) : false;
};

export const estCarteIdentiteValide = (numero) => {
 if (!/(^\d{15}$)|(^\d{17}(\d|x|X)$)/.test(numero)) {
   console.error("Format de carte d'identité invalide.");
   return false;
 }

 const codesRegions = {
   11: "Beijing", 12: "Tianjin", 13: "Hebei", 14: "Shanxi", 15: "Inner Mongolia",
   21: "Liaoning", 22: "Jilin", 23: "Heilongjiang", 31: "Shanghai", 32: "Jiangsu",
   33: "Zhejiang", 34: "Anhui", 35: "Fujian", 36: "Jiangxi", 37: "Shandong",
   41: "Henan", 42: "Hubei", 43: "Hunan", 44: "Guangdong", 45: "Guangxi",
   46: "Hainan", 50: "Chongqing", 51: "Sichuan", 52: "Guizhou", 53: "Yunnan",
   54: "Tibet", 61: "Shaanxi", 62: "Gansu", 63: "Qinghai", 64: "Ningxia",
   65: "Xinjiang", 71: "Taiwan", 81: "Hong Kong", 82: "Macau", 91: "Others"
 };
 if (!codesRegions[parseInt(numero.substr(0, 2))]) {
   console.error("Code région de carte d'identité invalide.");
   return false;
 }

 const annee = parseInt(numero.substr(6, 4));
 const mois = parseInt(numero.substr(10, 2));
 const jour = parseInt(numero.substr(12, 2));
 const dateNaissance = new Date(annee, mois - 1, jour);
 if (dateNaissance.getFullYear() !== annee || dateNaissance.getMonth() !== mois - 1 || dateNaissance.getDate() !== jour) {
   console.error("Date de naissance invalide dans la carte d'identité.");
   return false;
 }

 const poids = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
 const codesVerification = "10X98765432";
 let somme = 0;
 for (let i = 0; i < numero.length - 1; i++) {
   somme += numero[i] * poids[i];
 }
 const dernierCaractere = codesVerification[somme % 11];
 if (numero[numero.length - 1].toUpperCase() !== dernierCaractere) {
   console.error("Le caractère de vérification de la carte d'identité est invalide.");
   return false;
 }

 return true;
};

export const genererNombreAleatoire = (min, max) => {
 if (arguments.length === 2) {
   return Math.floor(min + Math.random() * (max - min + 1));
 } else {
   console.warn("La fonction genererNombreAleatoire nécessite deux arguments.");
   return null;
 }
};

export const nombreEnChiffresArabes = (nombre) => {
 const unites = ["", "Dix", "Cent", "Mille"];
 const chiffres = ["Zéro", "Un", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf"];
 const fractions = ["", "Dix", "Cent", "Mille", "Dix Mille", "Cent Mille", "Million", "Dix Millions", "Cent Millions", "Milliard"];

 const chaineNombre = String(nombre).replace(/,/g, ""); // Supprime les virgules
 const partie = chaineNombre.split('.');
 let resultat = "";

 // Partie entière
 let partieEntiere = partie[0];
 if (partieEntiere === "0") {
   resultat = "Zéro";
 } else {
   let bloc = '';
   let k = 0;
   for (let i = partieEntiere.length - 1; i >= 0; i--) {
     const chiffre = parseInt(partieEntiere.charAt(i));
     if (chiffre !== 0) {
       bloc = chiffres[chiffre] + (k % 4 === 0 ? unites[k / 4] : "") + bloc;
     }
     if (k % 4 === 0 && chiffre !== 0 && i > 0 && parseInt(partieEntiere.charAt(i - 1)) === 0) {
       bloc = chiffres[0] + bloc; // Ajoute zéro si nécessaire
     }
     k++;
     if (k % 4 === 0) {
       resultat = bloc + unites[k / 4] + resultat;
       bloc = '';
     }
   }
   resultat = bloc + resultat;
 }

 // Partie décimale
 if (partie.length > 1) {
   resultat += " Point ";
   for (let i = 0; i < partie[1].length; i++) {
     resultat += chiffres[parseInt(partie[1].charAt(i))] + (i === 0 ? " Dix" : i === 1 ? " Cent" : "");
   }
 }

 // Nettoyage final
 resultat = resultat.replace(/ZéroDix/g, "Dix");
 resultat = resultat.replace(/ZéroCent/g, "Cent");
 resultat = resultat.replace(/ZéroMille/g, "Mille");
 resultat = resultat.replace(/ZéroMillion/g, "Million");
 resultat = resultat.replace(/ZéroMilliard/g, "Milliard");
 resultat = resultat.replace(/([Un|Deux|Trois|Quatre|Cinq|Six|Sept|Huit|Neuf])Dix/g, '$1Dix');
 resultat = resultat.replace(/([Un|Deux|Trois|Quatre|Cinq|Six|Sept|Huit|Neuf])Cent/g, '$1Cent');
 resultat = resultat.replace(/([Un|Deux|Trois|Quatre|Cinq|Six|Sept|Huit|Neuf])Mille/g, '$1Mille');
 resultat = resultat.replace(/([Un|Deux|Trois|Quatre|Cinq|Six|Sept|Huit|Neuf])Million/g, '$1Million');
 resultat = resultat.replace(/([Un|Deux|Trois|Quatre|Cinq|Six|Sept|Huit|Neuf])Milliard/g, '$1Milliard');
 resultat = resultat.replace(/DixDix/g, "Vingt"); // Cas spécifique pour 20
 resultat = resultat.replace(/DixCent/g, "DeuxCents"); // Cas spécifique pour 200
 resultat = resultat.replace(/DixMille/g, "VingtMille"); // Cas spécifique pour 20000

 return resultat;
};

export const convertirMontantEnLettres = (montant) => {
 if (typeof montant === "number") {
   montant = String(montant);
 }
 montant = montant.replace(/,/g, "").replace(/ /g, "").replace(/€/g, "");
 if (isNaN(montant)) {
   return "Montant invalide";
 }

 const unitesMaj = ["", "Un", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf"];
 const dizainesMaj = ["", "Dix", "Vingt", "Trente", "Quarante", "Cinquante", "Soixante", "Soixante-dix", "Quatre-vingt", "Quatre-vingt-dix"];
 const centainesMaj = ["", "Cent", "Deux-Cents", "Trois-Cents", "Quatre-Cents", "Cinq-Cents", "Six-Cents", "Sept-Cents", "Huit-Cents", "Neuf-Cents"];
 const grandeUnites = ["", "Mille", "Million", "Milliard"];

 const parties = montant.split(".");
 let partieEntiere = parties[0];
 let partieDecimale = parties.length > 1 ? parties[1] : "";

 let resultat = "";

 // Conversion de la partie entière
 let i = partieEntiere.length;
 let indexGrandeUnite = 0;
 while (i > 0) {
   let bloc = partieEntiere.substring(Math.max(0, i - 3), i);
   let blocConverti = "";
   let k = bloc.length;

   if (k > 0) {
     const centaine = parseInt(bloc.charAt(0)) || 0;
     const dizaine = parseInt(bloc.charAt(1)) || 0;
     const unite = parseInt(bloc.charAt(2)) || 0;

     if (centaine > 0) {
       blocConverti += centainesMaj[centaine];
     }
     if (dizaine === 1) {
       blocConverti += (blocConverti ? "-" : "") + dizainesMaj[10 + unite];
     } else if (dizaine === 7) {
       blocConverti += (blocConverti ? "-" : "") + dizainesMaj[6] + "-" + unitesMaj[unite];
     } else if (dizaine === 9) {
       blocConverti += (blocConverti ? "-" : "") + dizainesMaj[8] + "-" + unitesMaj[unite];
     } else if (dizaine > 1) {
       blocConverti += (blocConverti ? "-" : "") + dizainesMaj[dizaine];
       if (unite > 0) {
         blocConverti += "-" + unitesMaj[unite];
       }
     } else if (unite > 0) {
       blocConverti += unitesMaj[unite];
     }
   }

   if (blocConverti && indexGrandeUnite > 0) {
     resultat = blocConverti + " " + grandeUnites[indexGrandeUnite] + " " + resultat;
   } else if (blocConverti) {
     resultat = blocConverti + " " + resultat;
   }

   i -= 3;
   indexGrandeUnite++;
 }

 // Ajout de "Euros" et gestion des centimes
 if (!resultat.trim()) resultat = "Zéro";
 resultat += " Euros";

 if (partieDecimale) {
   if (partieDecimale.length > 2) {
     partieDecimale = partieDecimale.substring(0, 2);
   }
   let centimesConvertis = "";
   const d1 = parseInt(partieDecimale.charAt(0)) || 0;
   const d2 = parseInt(partieDecimale.charAt(1)) || 0;

   if (d1 === 1) {
     centimesConvertis = dizainesMaj[10 + d2];
   } else if (d1 === 7) {
     centimesConvertis = dizainesMaj[6] + "-" + unitesMaj[d2];
   } else if (d1 === 9) {
     centimesConvertis = dizainesMaj[8] + "-" + unitesMaj[d2];
   } else if (d1 > 1) {
     centimesConvertis = dizainesMaj[d1];
     if (d2 > 0) {
       centimesConvertis += "-" + unitesMaj[d2];
     }
   } else if (d2 > 0) {
     centimesConvertis = unitesMaj[d2];
   }
   if (centimesConvertis) {
     resultat += " et " + centimesConvertis + " Centimes";
   }
 }

 // Nettoyage final des espaces multiples
 resultat = resultat.replace(/\s+/g, ' ').trim();
 return resultat;
};

export const comparerObjets = (objA, objB) => {
 const propsA = Object.getOwnPropertyNames(objA);
 const propsB = Object.getOwnPropertyNames(objB);

 if (propsA.length !== propsB.length) {
   return false;
 }

 for (let i = 0; i < propsA.length; i++) {
   const nomProp = propsA[i];
   if (objA[nomProp] !== objB[nomProp]) {
     return false;
   }
 }
 return true;
};

export const couleurHexVersRgb = (valeurHex, opacite = null) => {
 const pattern = /^(#?)([a-fA-F0-9]{6})$/;
 if (!pattern.test(valeurHex)) {
   return '';
 }

 const hex = valeurHex.replace('#', '');
 const rgb = [];
 for (let i = 0; i < 3; i++) {
   const partie = hex.substring(i * 2, i * 2 + 2);
   rgb.push(parseInt(partie, 16));
 }

 if (opacite !== null && typeof opacite === 'number') {
   return `rgba(${rgb.join(',')},${opacite})`;
 } else {
   return `rgb(${rgb.join(',')})`;
 }
};

export const ajouterParametresUrl = (url, parametres) => {
 const urlObj = new URL(url);
 constSearchParams = urlObj.searchParams;

 if (typeof parametres === 'object') {
   for (const cle in parametres) {
     if (Object.hasOwnProperty.call(parametres, cle)) {
       searchParams.append(cle, parametres[cle]);
     }
   }
 } else if (typeof parametres === 'string') {
   // Si c'est une chaîne, on suppose qu'elle est déjà formatée (ex: "cle=valeur&autre=val")
   const paires = parametres.split('&');
   paires.forEach(paire => {
     const [cle, valeur] = paire.split('=');
     if (cle && valeur) {
       searchParams.append(cle, valeur);
     }
   });
 }

 urlObj.search = searchParams.toString();
 return urlObj.toString();
};

export const controleIntensiteMotDePasse = (motDePasse) => {
 let niveau = 0;
 if (motDePasse.length < 6) return niveau;
 if (/[0-9]/.test(motDePasse)) niveau++;
 if (/[a-z]/.test(motDePasse)) niveau++;
 if (/[A-Z]/.test(motDePasse)) niveau++;
 if (/[\.|-|_]/.test(motDePasse)) niveau++;
 return niveau;
};