lesanges/tests_paheko
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

suppression fichiers inutiles

Browse Source
This commit is contained in:
Jean-Christophe Engel 2024-11-14 14:32:02 +01:00
parent fcaff4435d
commit 1853382054
2 changed files with 0 additions and 1100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

503
code.js
View File

@ -1,503 +0,0 @@
// ------------------------------------------------------------------------
// fabriquer une chaine aléatoire
const mdp = (length) => {
let chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzàâäéèêëîïôöûüùÀÂÄÉÈÊËÎÏÔÖÛÜÙ&~"#\'{([-|`_@)]=°+}€<>,?;.:/!§«»¿×÷¡';
let str = '';
for (let i = 0; i < length; i++) {
str += chars.charAt(Math.floor(Math.random() * chars.length));
}
return str;
}
// renvoyer une chaine
return mdp(10)
// renvoyer un tableau de chaines
for (let i = 0; i < 3 + Math.floor(Math.random() * 5); ++i) {
${lesnoms} = ${lesnoms}.concat(chaine(10));
}
return ${lesnoms}; // => lesnoms
// ------------------------------------------------------------------------
// fabriquer chaîne avec nom prénom
const upper = (str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
};
const chaine = (length) => {
let chars = 'aàbcdeéèfghijklmnoôpqrstuùvwxyz';
let str = '';
for (let i = 0; i < length; i++) {
str += chars.charAt(Math.floor(Math.random() * chars.length));
}
let debut = upper(str.slice(0, length/2));
let fin = upper(str.slice(length/2));
return debut + ' ' + fin;
};
for (let i = 0; i < 7 + Math.floor(Math.random() * 15); ++i) {
${lesnoms} = ${lesnoms}.concat(chaine(11 + Math.floor(Math.random() * 5)));
}
return ${lesnoms};
// fabriquer adresse courriel
const chaine = (length) => {
let chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
let str = '';
for (let i = 0; i < length; i++) {
str += chars.charAt(Math.floor(Math.random() * chars.length));
}
return str;
};
return chaine(8) + "@" + chaine(5) + ".fr";
// code postal
return Math.random().toString(10).substring(2, 7);
// numéro téléphone
return '0' + Math.random().toString(10).substring(2, 11);
// supprimer espace dans numéro téléphone
return ${telephone}.replace(/\\s/g, "")
// ------------------------------------------------------------------------
// Calculer date réelle à partir d'une date saisie même bizarre
// ex: 95/31/2020 => 03/10/2022
function joursMois (annee, mois) {
return new Date(annee, mois, 0).getDate();
}
function getDate(chaine) {
var ds = chaine.split('/');
var jour=ds[0];
var an = Math.floor(ds[1]/12);
var annee = Number(ds[2]) + an;
var mois = ds[1] - 12 * an;
var dm = joursMois(annee, mois);
while (jour > dm) {
jour -= dm;
++mois;
if (mois > 12) { mois = 1; ++annee; }
dm = joursMois(annee, mois);
}
if (jour < 10) { jour = '0' + jour; }
if (mois < 10) { mois = '0' + mois; }
return(jour + '/' + mois + '/' + annee);
}
return getDate(${date});
// ------------------------------------------------------------------------
// rendre visibles les options de filtres de membre
const nav = document.querySelector(".dropdown");
const li = nav.querySelectorAll("li");
for (const l of li) { l.style.display="block"; }
return;
// rendre visibles les options d'export
const nav = document.querySelector(".tabs");
let span = nav.querySelector("aside > span > span");
span.style.display = "block";
return;
// ------------------------------------------------------------------------
// vérifier la validité d'une date au format JJ/MM/AAAA
// 1. séparer une date JJ/MM/AAAA selon les /
return ${ds}.split('/') // => ts
// 2. faire une date au format MM-DD-YYYY
return ${ts}[1] + '-' + ${ts}[0] +'-' + ${ts}[2] // => dd
// 3. vérifier si on peut créer une date valide
return ! isNaN(Date.parse(${dd})) // => ok
// ------------------------------------------------------------------------
// créer un tableau d'objets {numéro, catégorie}
// le trier par numéro
// renvoyer le tableau des catégories
let tab = [];
for (let i = 0; i < ${lesnumeros}.length; ++i)
{
let o = Object();
o.num=${lesnumeros}[i];
o.cat=${lescategories}[i];
tab.push(o);
}
// trier
tab.sort((a, b) => {
return a.num - b.num;
});
// catégories
let categs = [];
tab.forEach((e) => {
categs.push(e.cat);
});
return categs;
// ------------------------------------------------------------------------
// renvoyer le numéro d'une catégorie donnée
// params :
// - nom d'une catégorie
// - tableau des catégories classé par numéro croissant
function getNumero(cat_name, categories) {
let i = 0;
while (i < categories.length) {
if (categories[i] == cat_name) { return i + 1; }
i += 1;
}
}
return getNumero(${categorie}, ${categories_num});
// ------------------------------------------------------------------------
// trier les membres : voir tri.js
// ------------------------------------------------------------------------
// sélectionner un parent parmi les nb premiers éléments du tableau
// lesnoms ; le choix se fait uniquement sur des personnes qui ne sont
// pas rattachées, donc qui n'ont pas de parent
function selParent(lesnoms, lesparents, nb)
{
while(true) {
let num = Math.floor(Math.random() * nb);
if (lesparents[num].length == 0) { return lesnoms[num]; }
}
}
return selParent(${lesnoms}, ${lesparents}, ${nb_total_membres})
// ------------------------------------------------------------------------
// normaliser une chaîne :
// - mettre en minuscules
// - remplacer les caractères avec accent par leur équivalent sans accent
// ------------------------------------------------------------------------
const accent = "àâäéèêëîïôöùûü";
const normal = "aaaeeeeiioouuu";
function normaliser (chaine) {
let resu = "";
chaine = chaine.toLocaleLowerCase();
for (let i = 0; i < chaine.length; ++i) {
let ind = accent.indexOf(chaine[i]);
if (ind == -1) {
resu += chaine[i];
} else {
resu += normal[ind];
}
}
return resu;
}
// const donnee = "Aèzfoj Rdùxiè";
// let resu = normaliser(donnee.toLocaleLowerCase());
// console.log("donnée = " + donnee + "\nresu = " + resu);
// ------------------------------------------------------------------------
// compter le nb d'occurences d'un élément dans un tableau de chaines
// ------------------------------------------------------------------------
function nbocc(elem, tab) {
let nb = 0;
for (const e of tab) {
if (normaliser(e).localeCompare(elem) == 0) { nb += 1; }
}
return nb;
}
//return nbocc(${nom}.toLocaleLowerCase(), ${lesnoms})
// ------------------------------------------------------------------------
// renvoyer un nom au hasard d'un tableau en s'assurant qu'il n'a pas
// d'homonyme après normalisation
// ------------------------------------------------------------------------
function getNom(tab)
{
while (true) {
let nom = tab.at(Math.floor(Math.random() * tab.length));
let nb = nbocc(normaliser(nom), tab);
if (nb == 1) { return nom; }
}
}
return getNom(${lesnoms})
// ------------------------------------------------------------------------
// vérifier qu'une chaine est présente dans un nom normalisé
// ------------------------------------------------------------------------
function verif(chaine, nom) {
return normaliser(nom).includes(chaine);
}
// ------------------------------------------------------------------------
// faire un tableau d'indice des « homonymes » de chaine
// tab est un tableau d'objets (nom, numero)
// ------------------------------------------------------------------------
function indonymes(chaine, tab) {
let homos = [];
for (let i = 0 ; i < tab.length; ++i) {
if (normaliser(tab[i].nom).includes(chaine)) {
homos.push(i);
}
}
return homos;
}
// fabriquer un nom qui contient une chaîne donnée
const upper = (str) => {
return str.charAt(0).toUpperCase() + str.slice(1);
};
function homonyme(chaine, lg) {
let chars = 'aàbcdeéèfghijklmnoôpqrstuùvwxyz';
let str = '';
for (let i = 0; i < lg; i++) {
str += chars.charAt(Math.floor(Math.random() * chars.length));
}
let debut = upper(str.slice(0, lg/2));
let fin = upper(str.slice(lg/2));
return debut + chaine + fin;
}
return homonyme(${nom_cherche}, 10);
// ------------------------------------------------------------------------
// générer un nouveau nom en s'assurant qu'il n'a pas
// d'homonyme après normalisation
// ------------------------------------------------------------------------
function genererNom(tab)
{
while (true) {
let nom = chaine(12);
let nb = nbocc(normaliser(nom), tab);
if (nb == 0) { return nom; }
}
}
return genererNom(${lesnoms})
// ------------------------------------------------------------------------
// générer une nouvelle adresse de courriel en s'assurant qu'elle est unique
// ------------------------------------------------------------------------
function genererCourriel(tab)
{
while (true) {
let courriel = chaine(8) + "@" + chaine(5) + ".fr";
let nb = nbocc(courriel, tab);
if (nb == 0) { return courriel; }
}
};
return genererCourriel(${lescourriels})
// ------------------------------------------------------------------------
// sélectionner un courriel au hasard dans un tableau en s'assurant
// qu'il est unique et renvoyer son indice
// ------------------------------------------------------------------------
function getCourriel(tab)
{
while (true) {
let ind = Math.floor(Math.random() * tab.length);
let nom = tab.at(ind);
if (nom.length > 0) {
let nb = nbocc(nom, tab);
if (nb == 1) { return ind; }
}
}
}
return getCourriel(${lescourriels})
// fabriquer un courriel qui contient une chaîne (@xxx) donnée
function homonyme(chaine, lg) {
let chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
let str = '';
for (let i = 0; i < lg; i++) {
str += chars.charAt(Math.floor(Math.random() * chars.length));
}
return str + chaine + ".fr";
}
return homonyme(${courriel_cherche}, 9);
// fabriquer une date (pseudo-)aléatoire
function getDate()
{
let date = new Date();
let ms = date.getTime();
ms += 3 + Math.floor(Math.random() * 5 * 24 * 60 * 60 * 1000);
date.setTime(ms);
return date.toLocaleDateString();
}
// ------------------------------------------------------------------------
// cocher toutes les cases du corps de la table quand celle de
// la ligne de titre est cochée
// param idCase : case de la ligne de titre
// ------------------------------------------------------------------------
function cocher(idCase)
{
const table = idCase.closest("table");
const body = table.querySelector("tbody");
const cases = body.querySelectorAll('td[class="check"] > input[type="checkbox"]');
for (let i = 0; i < cases.length; ++i) {
cases[i].checked = true;
}
}
// ------------------------------------------------------------------------
// ajouter tous les membres d'une page au tableau paramètre
// ------------------------------------------------------------------------
function ajouterMembresPage(tmembres)
{
for (const elem of document.querySelectorAll('table[class="list"] > tbody > tr'))
{
let o = Object();
o.numero = elem.querySelector('td[class="num"]').textContent.trim();
o.nom = elem.querySelector('th').textContent.trim();
tmembres.push(o);
}
return tmembres;
}
// ------------------------------------------------------------------------
// ajouter des membres au tableau paramètre
// ------------------------------------------------------------------------
const upper = (str) => { return str.charAt(0).toUpperCase() + str.slice(1);} ; const chaine = (length) => { let chars = 'aàbcdeéèfghijklmnoôpqrstuùvwxyz'; let str = ''; for (let i = 0; i < length; i++) { str += chars.charAt(Math.floor(Math.random() * chars.length));} let debut = upper(str.slice(0, length/2)); let fin = upper(str.slice(length/2)); return debut + ' ' + fin; }
function ajouterMembres(tmembres, num)
{
for (let i = 0; i < 7 + Math.floor(Math.random() * 15); ++i) {
let o = Object();
o.nom = chaine(11 + Math.floor(Math.random() * 5));
o.numero = num;
tmembres.push(o);
++num;
}
return tmembres;
}
// Compter le nombre de membres créés et modifiés
function compter()
{
let o = { cree: 0, modif: 0 };
for (const msg of document.querySelectorAll('summary > h2'))
{
if (msg.textContent.includes('créé')) {
o.cree = Number(msg.textContent.split(' ')[0]);
}
if (msg.textContent.includes('modifié')) {
o.modif = Number(msg.textContent.split(' ')[0]);
}
}
return o;
}
// additionner les codes des nb premiers caractères d'une chaîne
// @pre nb <= chaine.length
function calculer(nb, chaine)
{
let somme = 0;
for (let i = 0; i < nb; ++i) {
somme += chaine.charCodeAt(i);
}
return somme;
}
function mod(courriel)
{
return courriel.substr(0, courriel.indexOf('@')) + "@ici.bzh";
}
// fabriquer chaîne date + heure
return ${valeur_champ_date} + " à " + ${valeur_champ_time}.replace(/:/, "h")
// calculer le nombre d'années entières entre deux dates
// d1 : sous la forme jj/mm/aaaa
// d2 : Date avec d1 <= d2
function diff(d1, d2)
{
let [j1, m1, a1] = d1.split('/').map((x) => Number(x));
let a2 = d2.getFullYear();
let m2 = d2.getMonth() + 1;
let j2 = d2.getDate();
let diffAnnee = a2 - a1;
if ((m2 < m1) || (m2 == m1 && j2 < j1)) { --diffAnnee; }
return diffAnnee;
}
return diff("30/10/2015", new Date());
// cas où la deuxième date est celle du jour
function diff(d1)
{
let [j1, m1, a1] = d1.split('/').map((x) => Number(x));
const d2 = new Date();
let a2 = d2.getFullYear();
let m2 = d2.getMonth() + 1;
let j2 = d2.getDate();
let diffAnnee = a2 - a1;
if ((m2 < m1) || (m2 == m1 && j2 < j1)) { --diffAnnee; }
return diffAnnee;
}
// transformer année mois numérique en texte
// 1977-03 => juillet 1977
// 1977-15 => mars 1978
function toText(chaine)
{
let lesMois = ["janvier", "février", "mars", "avril", "mai", "juin",
"juillet", "août", "septembre", "octobre", "novembre", "décembre"];
let ma = chaine.split('-');
var annee = Number(ma[0]);
var mois = Number(ma[1]);
if (mois > 12) {
annee += Math.floor(mois / 12);
mois = mois % 12;
}
if (mois == 0) {
annee -= 1;
mois = 12;
}
return lesMois[mois - 1] + " " + annee;
}
// variante
function toText(mois, annee)
{
let lesMois = ["janvier", "février", "mars", "avril", "mai", "juin",
"juillet", "août", "septembre", "octobre", "novembre", "décembre"];
var mois = Number(mois);
var annee = Number(annee);
if (mois > 12) {
annee += Math.floor(mois / 12);
mois = mois % 12;
}
if (mois == 0) {
annee -= 1;
mois = 12;
}
return lesMois[mois - 1] + " " + annee;
}
// ------------------------------------------------------------------------
// mettre la liste des libellés des champs de la fiche membre dans le tableau paramètre
// ------------------------------------------------------------------------
function listerLibelles(t)
{
for (const elem of document.querySelectorAll('table.list.drag > tbody > tr'))
{
let o = Object();
o.libelle = elem.querySelector('th').textContent.trim();
o.visible = (elem.querySelector('td > span[title="Visible"]') != null);
t.push(o);
}
return t;
}
// ouvrir la boîte de dialogue de suppression d'un élément dans un onglet
// @param : libellé de l'élément à supprimer
function open(libelle)
{
// lister les champs qui peuvent être supprimés
const elements = document.querySelectorAll('a[href ^= "delete.php"]');
for (var i = 0; i < elements.length; ++i)
{
// trouver la ligne (tr) qui contient l'élément courant
let ligne = elements[i].closest('tr');
if (ligne.querySelector('th').innerText == libelle) { break; }
}
// ouvrir l'url dans une autre fenêtre
const url = elements[i].href;
window.open(url, '_blank').focus();
}

597
tri.js
View File

@ -1,597 +0,0 @@
// trier par numéro
function trierNumeros(tnumeros, tnoms, croissant = true)
{
let tab = [];
for (let i = 0; i < tnumeros.length; ++i)
{
let o = Object();
o.numero = tnumeros[i];
o.nom = tnoms[i];
tab.push(o);
}
ordre = croissant ? 1 : -1;
tab.sort((a, b) => { return ordre * (a.numero - b.numero); });
return tab;
}
// trier par nom puis par numéro
function trierNoms(tnoms, tnumeros, croissant = true)
{
let tab = [];
for (let i = 0; i < tnoms.length; ++i)
{
let o = Object();
o.nom = tnoms[i];
o.numero = tnumeros[i];
tab.push(o);
}
tab.sort((a, b) => {
if (! croissant) { [a, b] = [b, a]; }
let comp = a.nom.localeCompare(b.nom);
if (comp == 0) { comp = a.numero - b.numero; }
return comp;
});
return tab;
}
// afficher un tableau
function afficher(msg, tab)
{
console.log("\n" + msg);
for (let i = 0; i < tab.length; ++i)
{
console.log(tab[i]);
}
}
// trier par ville puis par numéro
// ville (dé)croissant, numéro (dé)croissant
// ville vide en fin(début), numéro (dé)croissant
function trierVilles(tvilles, tnumeros, croissant = true)
{
let tab = [];
for (let i = 0; i < tvilles.length; ++i) {
let o = Object();
o.ville = tvilles[i];
o.numero = tnumeros[i];
tab.push(o);
}
tab.sort((a, b) => {
if (! croissant) { [a, b] = [b, a]; }
// une ville au moins vide ?
if (a.ville == '' && b.ville == '') { return a.numero - b.numero; }
if (a.ville == '') { return 1; }
if (b.ville == '') { return -1; }
// deux villes non vides
let comp = a.ville.localeCompare(b.ville);
if (comp == 0) { comp = a.numero - b.numero; }
return comp;
});
return tab;
}
// trier les membres selon le parent
// - parent (dé)croissant, nom membre (dé)croissant, numéro (dé)croissant
// - parent vide à la fin, nom membre (dé)croissant, numéro (dé)croissant
function trierParents(tparents, tnoms, tnumeros, croissant = true)
{
let tab = [];
for (let i = 0; i < tnumeros.length; ++i) {
let o = Object();
o.numero = tnumeros[i];
o.nom = tnoms[i];
o.parent = tparents[i];
tab.push(o);
}
tab.sort((a, b) => {
ordre = croissant ? 1 : -1;
// un parent au moins est vide ?
if (a.parent == '' && b.parent == '') {
let comp = a.nom.localeCompare(b.nom);
if (comp == 0) { comp = a.numero - b.numero; }
return comp * ordre;
}
if (a.parent == '') { return 1; }
if (b.parent == '') { return -1; }
// deux parents non vides
let comp = a.parent.localeCompare(b.parent);
if (comp == 0) { comp = a.nom.localeCompare(b.nom); }
if (comp == 0) { comp = a.numero - b.numero; }
return comp * ordre;
});
return tab;
}
// trier les membres selon la colonne responsable
// - non vide au début, nom membre (dé)croissant, numéro (dé)croissant
// - vide à la fin, nom membre (dé)croissant, numéro (dé)croissant
function trierResp(tresp, tnoms, tnumeros, croissant = true)
{
let tab = [];
for (let i = 0; i < tnumeros.length; ++i) {
let o = Object();
o.numero = tnumeros[i];
o.nom = tnoms[i];
o.resp = tresp[i];
tab.push(o);
}
tab.sort((a, b) => {
ordre = croissant ? 1 : -1;
// un resp au moins est vide ?
if (a.resp == '' && b.resp == '') {
let comp = a.nom.localeCompare(b.nom);
if (comp == 0) { comp = a.numero - b.numero; }
return comp * ordre;
}
if (a.resp == '') { return 1; }
if (b.resp == '') { return -1; }
// deux resp non vides (forcément = "Oui")
let comp = a.nom.localeCompare(b.nom);
if (comp == 0) { comp = a.numero - b.numero; }
return comp * ordre;
});
return tab;
}
// ------------------------------------------------------------------------
// les données et les tests
// ------------------------------------------------------------------------
const tnumeros = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 110,
111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123
];
const tnoms = [
"Lambert Paul", "Sjqeaz Njguqô", "Gfjkms Ôfyike", "Xnunèp Tmhàxz", "Xhràèk Ùmunyv",
"Jgévxù Wohyrv", "Mèkixt Ùyimtd", "Zhamberlain Luuc", "Ézhaée Ùùpwab", "Éàkhhô Psyauà",
"Lambert Paul", "Zphjéà Irôezqé", "Mpùuky Blégmmz", "Htôtkl Sxgtrô", "Kcfyè Nsvmvq",
"Hdzcpèn Rddpdafx", "Èàrgkx Idèpoù", "Rhocry Dlùvwpq", "Ziùcwe Hpqltrs", "Brkcàg Nigcyi",
"Jtinjôù Wmwiônj", "Cylsx Nzoèwl", "Éxiqnh Fcbwizà"
];
const tvilles = [
"", "Erawvcyfézgrfoi", "Jbqmqeyemdbstcf", "Ùhkfwuvgpcuèùqa", "Yécewxefmepôàeé",
"La Havane", "Fyàwxsbedwanxqt", "", "Sipkàoféuslgiiu", "Psôhègébulaùdzm",
"Pioùôutôeyytùlà", "", "", "", "",
"", "", "", "La Havane", "", "", "La Havane", ""
];
const parents = [
"", "", "", "", "",
"", "Jgévxù Wohyrv", "", "Zhamberlain Luuc", "",
"", "", "", "Xhràèk Ùmunyv", "Xnunèp Tmhàxz",
"", "Jgévxù Wohyrv", "", "Zhamberlain Luuc", "Gfjkms Ôfyike",
"Sjqeaz Njguqô", "Jgévxù Wohyrv", "Sjqeaz Njguqô"
];
const tresp = [
"", "Oui", "Oui", "Oui", "Oui",
"Oui", "", "Oui", "", "",
"", "", "", "", "",
"", "", "", "", "",
"", "", ""
];
// console.log("p.l = " + parents.length + ", nom.l = " + tnoms.length + ", num.l = " + tnumeros.length + ", r.l = " + resp.length);
// trier par nom croissant puis décroissant
let tab_noms = trierNoms(tnoms, tnumeros);
afficher("Tri par nom croissant :", tab_noms);
tab_noms = trierNoms(tnoms, tnumeros, false);
afficher("Tri par nom décroissant :", tab_noms);
// trier par ville croissante puis décroissante
let tab_villes = trierVilles(tvilles, tnumeros);
afficher("Tri par ville croissant :", tab_villes);
tab_villes = trierVilles(tvilles, tnumeros, false);
afficher("Tri par ville décroissant :", tab_villes);
// trier par parent croissant
let tab_parents = trierParents(parents, tnoms, tnumeros);
afficher("Tri par parent croissant :", tab_parents);
tab_parents = trierParents(parents, tnoms, tnumeros, false);
afficher("Tri par parent décroissant :", tab_parents);
// trier par resp croissant
let tab_resp = trierResp(tresp, tnoms, tnumeros);
afficher("Tri par resp croissant :", tab_resp);
tab_resp = trierResp(tresp, tnoms, tnumeros, false);
afficher("Tri par resp décroissant :", tab_resp);
// ------------------------------------------------------------------------
// 1. première ville vide et dernière ville vide
// ==> comparer numéro premier et numéro dernier, inverser si besoin
// 2. première ville vide et dernière ville non vide
// décroissant : inverser si besoin
// 3. première ville non vide et dernière ville vide
// croissant : inverser si besoin
// 4. première ville non vide et dernière ville non vide
// 4.1 première ville < dernière ville : croissant, inverser si besoin
// 4.2 première ville > dernière ville : décroissant, inverser si besoin
// 4.3 première ville = dernière ville
// ==> comparer numéro premier et numéro dernier, inverser si besoin
// ------------------------------------------------------------------------
if (${premiere_ville} == "" && ${derniere_ville} == "")
{
if (${numero_premier} > ${numero_dernier})
{
// décroissant : inverser si besoin
} else {
// croissant : inverser si besoin
}
}
else if (${premiere_ville} == "" && ${derniere_ville} != "")
{
// décroissant : inverser si besoin
}
else if (${premiere_ville} != "" && ${derniere_ville} == "")
{
// croissant : inverser si besoin
}
else if (${premiere_ville} != "" && && ${derniere_ville} != "")
{
if (${premiere_ville}.localeCompare(${derniere_ville}) < 0)
{
// croissant : inverser si besoin
} else if (${premiere_ville}.localeCompare(${derniere_ville}) > 0)
{
// décroissant : inverser si besoin
} else {
if (${numero_premier} > ${numero_dernier})
{
// décroissant : inverser si besoin
} else {
// croissant : inverser si besoin
}
}
}
// simplification ordre croissant
if (${premiere_ville} == "" && ${derniere_ville} == ""
&&
${numero_premier} > ${numero_dernier})
{
// décroissant : inverser
}
else if (${premiere_ville} == "" && ${derniere_ville} != "")
{
// décroissant : inverser
}
else if (${premiere_ville} != "" && && ${derniere_ville} != "")
{
if (${premiere_ville}.localeCompare(${derniere_ville}) > 0
||
(${premiere_ville}.localeCompare(${derniere_ville}) == 0
&&
${numero_premier} > ${numero_dernier}))
{
// décroissant : inverser
}
}
// simplification ordre décroissant
if (${premiere_ville} == "" && ${derniere_ville} == ""
&&
${numero_premier} < ${numero_dernier})
{
// croissant : inverser
}
else if (${premiere_ville} != "" && ${derniere_ville} == "")
{
// croissant : inverser
}
else if (${premiere_ville} != "" && && ${derniere_ville} != "")
{
if (${premiere_ville}.localeCompare(${derniere_ville}) < 0
||
(${premiere_ville}.localeCompare(${derniere_ville}) == 0
&&
${numero_premier} < ${numero_dernier}))
{
// croissant : inverser
}
}
// ------------------------------------------------------------------------
// contrôler si les membres sont triés par ordre (dé)croissant du nom du parent
//
// 1) au moins 2 parents non vides (donc forcément les deux premiers)
// - parent1 < parent2 => croissant
// - parent1 > parent2 => décroissant
// - parent1 = parent2
// - membre1 < membre2 => croissant
// - membre1 > membre2 => décroissant
// - membre1 = membre2
// - numéro1 < numéro 2 => croissant
// - numéro1 > numéro 2 => décroissant
// 2) un seul parent non vide (donc le premier)
// - membre2 < membre3 => croissant
// - membre2 > membre3 => décroissant
// - membre2 = membre3
// - numéro2 < numéro 3 => croissant
// - numéro2 > numéro 3 => décroissant
if (${nb_parents} >= 2)
{
if (${parent1}.localeCompare(${parent2}) < 0)
{
// croissant
}
else if (${parent1}.localeCompare(${parent2}) > 0)
{
// décroissant
}
else if (${membre1}.localeCompare(${membre2}) < 0)
{
// croissant
}
else if (${membre1}.localeCompare(${membre2}) > 0)
{
// décroissant
}
else if (${numero1} < ${numero2})
{
// croissant
}
else //if (${numero1} > ${numero2})
{
// décroissant
}
}
// un seul parent
else if (${nb_total_membres} > 2)
{
if (${membre2}.localeCompare(${membre3}) < 0)
{
// croissant
}
else if (${membre2}.localeCompare(${membre3}) > 0)
{
// décroissant
}
else if (${numero2} < ${numero3})
{
// croissant
}
else //if (${numero2} > ${numero3})
{
// décroissant
}
}
// simplification ordre croissant
if (${nb_parents}) >= 2)
{
if ((${parent1}.localeCompare(${parent2}) > 0)
||
(${parent1}.localeCompare(${parent2}) == 0
&& ${membre1}.localeCompare(${membre2}) > 0)
||
(${parent1}.localeCompare(${parent2}) == 0
&& ${membre1}.localeCompare(${membre2}) == 0
&& ${numero1} > ${numero2}))
{
// décroissant => inverser
}
}
// un seul parent
else if (${nb_total_membres} > 2)
{
if ((${membre2}.localeCompare(${membre3}) > 0)
||
(${membre2}.localeCompare(${membre3}) == 0
&& ${numero2} > ${numero3}))
{
// décroissant => inverser
}
}
// simplification ordre décroissant
if (${nb_parents}) >= 2)
{
if ((${parent1}.localeCompare(${parent2}) < 0)
||
(${parent1}.localeCompare(${parent2}) == 0
&& ${membre1}.localeCompare(${membre2}) < 0)
||
(${parent1}.localeCompare(${parent2}) == 0
&& ${membre1}.localeCompare(${membre2}) == 0
&& ${numero1} < ${numero2}))
{
// croissant => inverser
}
}
// un seul parent
else if (${nb_total_membres} > 2)
{
if ((${membre2}.localeCompare(${membre3}) < 0)
||
(${membre2}.localeCompare(${membre3}) == 0
&& ${numero2} < ${numero3}))
{
// croissant => inverser
}
}
// ------------------------------------------------------------------------
// contrôler si les membres sont triés par ordre (dé)croissant de la colonne responsable
// colonne responsable non vide en tête
//
// 1) au moins 2 oui dans la colonne responsable (donc forcément les deux premiers)
// - membre1 < membre2 => croissant
// - membre1 > membre2 => décroissant
// - membre1 = membre2
// - numéro1 < numéro 2 => croissant
// - numéro1 > numéro 2 => décroissant
// 2) un seul oui dans la colonne responsable (donc le premier)
// - numéro2 < numéro 3 => croissant
// - numéro2 > numéro 3 => décroissant
if (${nb_resp} >= 2)
{
if (${membre1}.localeCompare(${membre2}) < 0)
{
// croissant
}
else if (${membre1}.localeCompare(${membre2}) > 0)
{
// décroissant
}
else if (${numero1} < ${numero2})
{
// croissant
}
else //if (${numero1} > ${numero2})
{
// décroissant
}
}
// un seul responsable
else if (${nb_total_membres} > 2)
{
if (${membre2}.localeCompare(${membre3}) < 0)
{
// croissant
}
else if (${membre2}.localeCompare(${membre3}) > 0)
{
// décroissant
}
else if (${numero2} < ${numero3})
{
// croissant
}
else //if (${numero2} > ${numero3})
{
// décroissant
}
}
// simplification ordre croissant
if (${nb_resp}) >= 2)
{
if (${membre1}.localeCompare(${membre2}) > 0
||
(${membre1}.localeCompare(${membre2}) == 0
&& ${numero1} > ${numero2}))
{
// décroissant => inverser
}
}
// un seul responsable
else if (${nb_total_membres} > 2)
{
if (${membre2}.localeCompare(${membre3}) > 0
||
(${membre2}.localeCompare(${membre3}) == 0
&& ${numero2} > ${numero3}))
{
// décroissant => inverser
}
}
// simplification ordre décroissant
if (${nb_resp}) >= 2)
{
if (${membre1}.localeCompare(${membre2}) < 0
||
(${membre1}.localeCompare(${membre2}) == 0
&& ${numero1} < ${numero2}))
{
// croissant => inverser
}
}
// un seul responsable
else if (${nb_total_membres} > 2)
{
if (${membre2}.localeCompare(${membre3}) < 0
||
(${membre2}.localeCompare(${membre3}) == 0
&& ${numero2} < ${numero3}))
{
// croissant => inverser
}
}
let numeros = [ 8, 5, 9, 2, 3, 6, 7, 4, 1 ];
let noms = [ "Yopduu Cxùbvnn", "Xeosnm Rixwxé", "Vonôdjz Jcpùuèf", "Tnczgèb Ùttypmt",
"Sdcrdi Vzùmbim", "Kgazmà Éurbdv", "Izgzwùz Evjsqjeù","Hmupazn Chrédki",
"Lambert Paul" ];
let parents = [ "Lambert Paul", "Lambert Paul", "Lambert Paul", "Lambert Paul",
"Lambert Paul", "Lambert Paul", "Lambert Paul", "Lambert Paul", "" ];
function inverser(numeros, noms, parents)
{
for (let i = 0; i < numeros.length; ++i) {
if (parents[i] != "") {
premier = i;
break;
}
}
for (let i = numeros.length - 1; i >= 0; --i) {
if (parents[i] != "") {
dernier = i;
break;
}
}
console.log("premier : ", numeros[premier], noms[premier], parents[premier]);
console.log("dernier : ", numeros[dernier], noms[dernier], parents[dernier]);
if (parents[premier].localeCompare(parents[dernier]) < 0)
{
console.log(parents[premier], "<", parents[dernier]);
}
if (parents[premier].localeCompare(parents[dernier]) == 0 &&
noms[premier].localeCompare(noms[dernier]) < 0)
{
console.log(parents[premier], "=", parents[dernier]);
console.log(noms[premier], "<", noms[dernier]);
}
if (parents[premier].localeCompare(parents[dernier]) == 0 &&
noms[premier].localeCompare(noms[dernier]) == 0 &&
numeros[premier] < numeros[dernier])
{
console.log(parents[premier], "=", parents[dernier]);
console.log(noms[premier], "=", noms[dernier]);
console.log(numeros[premier], "<", numeros[dernier]);
}
if (parents[premier].localeCompare(parents[dernier]) < 0
||
(parents[premier].localeCompare(parents[dernier]) == 0 &&
noms[premier].localeCompare(noms[dernier]) < 0)
||
(parents[premier].localeCompare(parents[dernier]) == 0 &&
noms[premier].localeCompare(noms[dernier]) == 0 &&
numeros[premier] < numeros[dernier]))
{
console.log("Inverser le tri");
}
else {
console.log("Tri ok");
}
}
inverser(numeros, noms, parents);