Récupérer les valeurs les plus élevées dans un array

**Bensljul** · 19/03/2021, 13h47

Bonjour,

J'ai une interrogation à propos d'une manip que je souhaite faire.

Dans mon code jquery je récupère des infos contenus dans un csv via un appel ajax (ca pas de problème ca marche super bien ^^)

Par contre mon array contient ces infos : ["A,6.3.0","B,3.2.3","F,5.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","A,6.2.0","B,3.2.0","M,5.0.0","C,4.3.0"]

du coup par exemple on voit que j'ai "A,6.3.0" et "A,6.2.0, ma question est : est ce possible de pouvoir faire en sorte de récupérer que le "A,6.3.0" ? Et ainsi de suite pour les autres valeurs ?

je pensais au .map peut être mais j'avoue j'en suis pas sur ...

En vous remerciant d'avance.

Cordialement.

**javatwister** · 19/03/2021, 20h15

Bonjour,

pas de solution éclair mais tu peux faire ça:

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
const t=["A-6.3.0","F,5.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","A,6.2.0","B,3.2.0","M,5.0.0","C,4.3.0"]
t.sort().reverse();
let tbis="";
t.forEach(v=>{if(!tbis.match(v[0])){tbis+=" "+v}});
console.log(tbis.match(/[^ ]+/g).sort());

**Bensljul** · 22/03/2021, 07h46

AH oui chercher les même valeur en [0] et prendre la version la plus elevée,

Merci je vais essayer ca

**Bensljul** · 22/03/2021, 10h35

Mince ça marche plutôt bien excepté quand il y a une valeur qui n'est présente qu'une seule fois XD

**javatwister** · 22/03/2021, 12h17

pas compris!

Et que ce passe-t-il alors? As-tu un exemple de tableau qui ne passe pas avec le script?

**Bensljul** · 22/03/2021, 12h29

Re !!

En fait le souci c'est que j'avais une valeur par exemple "test,1.2.3" qui était toute seule dans mon array et du coup je ne sais pas pourquoi elle était sortie du résultat final.

Du coup je suis parti de ta ligne de code et j'ai créer cette fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
function lastversion(array){
			var lot_array_tmp=[],
				comp_def =[];
			for (var i=0;i<array.length;i++){
				var lot=array[i].split(',')[0];
 
				lot_array_tmp.push(lot);
			}
			lot_array=unique(lot_array_tmp);
			for (var i=0; i<lot_array.length;i++){
				var lot=lot_array[i],
					v=[];
				for (var j=0;j<array.length;j++){
					var y= array[j],
						x=y.match(lot);
						if( x != null){
							var comp= x.input,
								ver = comp.split(',')[1];
								v.push(ver);
						}
				}
				comp_def.push(lot+","+v.sort().reverse()[0]);
			}
			return comp_def
		}

Et nickel ca marche

Merci beaucoup ça m'a bien aidé

**javatwister** · 22/03/2021, 12h57

Non, il devait y avait un autre problème (formatage de données...): quand je teste n'importe quelle valeur, unique ou pas, ça marche! inutile de tout compliquer avec un script de 25 lignes;
Si ton tableau est bien fait, il contient en identifiant une lettre majuscule; je me suis fondé sur ça pour le code; mais si tu as des identifiants avec plusieurs lettres, des minuscules, etc, il faut le dire...

**CosmoKnacki** · 22/03/2021, 21h21

Malheureusement ce script ne marche pas comme on le voudrait. La faute à sort() qui par défaut fait un tri alphabétique, car si j'introduis dans la liste G,12.2.0 et G,8.2.0, celui qui sera renvoyé sera G,8.2.0.
Une solution pour parer au problème est d'exploser les chaînes en valeurs atomiques pour les comparer une à une. Voilà comment je procéderais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1',
    'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0',
    'M,5.0.0', 'C,4.3.0', 'G,8.1.3'];
 
const result = appList.reduce(function (c, i) {
    const [name, ...ver] = i.split(/[,.]/);
    if ( c.has(name) ) {
        const cver = c.get(name);
        if ( (ver[0] - cver[0] || ver[1] - cver[1] || ver[2] - cver[2]) > 0 )
            c.set(name, ver);
 
    } else {
        c.set(name, ver);
    }
    return c;
}, new Map());
 
for (const [name, ver] of result) {
    console.log(`${name},${ver.join('.')}`);
}

**CosmoKnacki** · 22/03/2021, 21h32

Une autre manière de faire qui est peut-être un peu too much pour ce que tu as à faire, mais qui peut s'avérer utile si tu as d'autres manipulations à effectuer avec ces données, c'est de verser dans la poo en désignant chaque chose précisément (je suis parti sur l'hypothèse que chacun des items est un nom de software avec son numéro de version):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
class App {
    constructor(...args) {
        if ( args.length === 2 )
            [this.name, this.version] = args;
        else    
            [this.name, ...this.version] = this._parse(args[0]);
    }
 
    _parse(appStr) {
        return appStr.split(/[,.]/);
    }
 
    toString() {
        return `${this.name},${this.version.join('.')}`;
    }
}   
 
class VersionSet extends Set {
    static compare(a, b) {
        if ( typeof a === 'undefined' )
            return -1;
 
        return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
    }
 
    lastVersion() {
        let lastVersion;
        for (const version of this) {
            if ( VersionSet.compare(lastVersion, version) < 0 )
                lastVersion = version;
        }
        return lastVersion;
    }
}
 
class AppCollection extends Map {
    set(app) {
        if ( !this.has(app.name) )
            super.set(app.name, new VersionSet());
 
        super.get(app.name).add(app.version);
    }
 
    lastVersions() {
        const lastVersions = [];
        for (let [name, versions] of this) {
            lastVersions.push(new App(name, versions.lastVersion()));
        }
        return lastVersions;
    }        
}
 
const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1',
    'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0',
    'M,5.0.0', 'C,4.3.0', 'G,8.1.3'];
 
let coll = new AppCollection();
for (const app of appList) {
    coll.set(new App(app));
}
 
console.log(coll.lastVersions().map((app) => `${app}`));

Là, c'est sûr on n'est plus dans les trois lignes, mais ça peut être exploitable pour d'autres choses.

**javatwister** · 22/03/2021, 21h36

Envoyé par CosmoKnacki

si j'introduis dans la liste G,12.2.0 et G,8.2.0, celui qui sera renvoyé sera G,8.2.0.

Ah oui, j'avais pas vu le "12" (lu trop vite), j'étais resté sur des valeurs à un chiffre

Je reverrai plus tard si j'ai une idée aussi...

**CosmoKnacki** · 22/03/2021, 21h59

À la limite, si par exemple on était sûr que chaque élément du numéro de version était limité à deux chiffres (ou n chiffres définis), on pourrait faire une transformation schwartzienne le temps de traiter les données, pour ensuite les remettre dans leur forme d'origine. Exemple pour deux chiffres:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
const appList = [ 'A,6.3.0', 'B,3.2.3', 'F,5.8.0', 'G,12.2.0', 'C,4.3.1',
    'M,5.1.0', 'R,5.4.1', 'F,5.6.0', 'R,5.2.1', 'A,6.2.0', 'B,3.2.0',
    'M,5.0.0', 'C,4.3.0', 'G,8.1.3'];
 
let result = appList.map((app) => app.replace(/\b(?=\d\b)/g, '0'));
 
// traitement
 
result = result.map((app) => app.replace(/\b0\B/g, ''));

**javatwister** · 23/03/2021, 14h21

bon sur ce coup-là, pas grand chose de transcendant; et je n'ai pas réfléchi au problème d'une chaîne de numéros plus longue ou aléatoire;

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
const t=["A,6.3.0","AA,7.3.0","C,1.2.3","F,5.8.0","G,12.0.0","F,8.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","B,3.2.0","M,5.0.0","C,4.3.0"]
let t2=[],t3=[];
t.map(v=>
	v.split(/[.,]/)).forEach(v=>
		!t2[v[0]] ? t2[v[0]]=[v] : [t2[v[0]].push(v),t2[v[0]].sort((a,b)=>
			b[1]-a[1]||b[2]-a[2]||b[3]-a[3])]
);
 
for(i in t2){
	t3.push(t2[i].slice(0,1).join());
}
console.log(t3)

**SpaceFrog** · 24/03/2021, 08h17

Bon j'y vais de ma petite proposition:

ça peut aussi se faire avec un custom sort et une multiplication par des puissances de dix selon le niveau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
const t=["A,6.3.0","AA,7.3.0","C,1.2.3","F,5.8.0","G,12.0.0","F,8.8.0","G,12.2.0","C,4.3.1","M,5.1.0","R,5.4.1","F,5.6.0","R,5.2.1","B,3.2.0","M,5.0.0","C,4.3.0"]
 
function mysort(a,b) {
var reg=/[.,]/g;
var i=-1;
ta=a.split(reg);
tb=b.split(reg);
return (ta[0]+ta[1]*100+ta[2]*10+ta[3] > tb[0]+tb[1]*100+tb[2]*10+tb[3]  )? 1 : -1;
}
 
t.sort(mysort);
console.log(t)

il ne reste plus qu'a faire un reverse pour récupérer les valeurs voulues

**javatwister** · 25/03/2021, 11h40

Essai pour des séries de longueur variable, y compris avec un même indicatif alphabétique.
Eh bien je me rends compte que c'est long d'arriver à quelque chose...

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
const t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.0.0","A,306.0.0.1","ABBA,86.0.22.1","ABBA,9.0","ABBA,0.0.7.45.12"],
t2=[],t3=[];
//On crée un tableau des valeurs à partir de chaque élément
t.map(v=>
	v.split(/[.,]/)).forEach(v=>
// puis chaque tableau de valeurs sera ajouté au tableau t2 correspondant au bon indicatif alphabétique
		!t2[v[0]] ? t2[v[0]]=[v] : t2[v[0]].push(v)
);
 
// pour chaque indicatif
for(i in t2){
// on définit la longueur maximale des tableaux de valeurs
	let maxl=0;
	t2[i].forEach(v=>{if(v.length>=maxl) maxl=v.length});
// pour chaque indice du tableau de valeurs
	for(j=1;j<maxl;j++){
// on définit la valeur maximale
		let maxv=0;
		for(let k=0;k<t2[i].length;k++){
			if(t2[i][k][j]){
				if(t2[i][k][j]>=maxv){
					maxv=parseInt(t2[i][k][j],10)
				}
			}
		};
// on élimine alors du tableau indicatif les éléments dont l'indice courant est inférieur à la valeur maximale
		for(let k=0;k<t2[i].length;k++){
			if(t2[i][k][j]){
				if(t2[i][k][j]<maxv){
					t2[i].splice(k,1);k--;
				}
			}
		}
	}
// recherche de l'indice de l'élément ayant la plus grande longueur dans le tableau indicatif 
	let lg=0,ind;
	t2[i].forEach((v,i)=>{if(v.length>=lg){lg=v.length;ind=i}});
// tableau final réunissant la valeur la plus haute de chaque tableau indicatif
	t3.push(`${i},${t2[i][ind].slice(1).join(".")}`)
}
 
console.log(t3.sort())

**SpaceFrog** · 25/03/2021, 14h48

En effet je n'avais pas pensé à une longueur variable...

Il suffirait alors de repérer le plus long d'uniformiser la longueur des arrays issus du split et d'attribuer les puissances de 10 sur la base du plus long ...

**javatwister** · 25/03/2021, 16h18

Pas impossible, mais l'idée est de ne pas trop uniformiser; imagine qu'un ".0" en plus signifie "Missiles armés" ou "Petit Scarabée pas content"... Eh bien la face du monde pourrait changer

**SpaceFrog** · 25/03/2021, 16h38

non sans toucher à l'existant ...
donc pas de risque de lancer un missile ni de passr tous les feux au vert ...
je teste ...

**SpaceFrog** · 25/03/2021, 17h58

Un peu obscur mais ça donne ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
var reg=/[.,]/g;
 
function mysort(a,b) {
ta=a.split(reg);
tal=ta.length;
while(tal++<maxl){
ta.push("0");
}
tb=b.split(reg);
tbl=tb.length;
while(tbl++<maxl){
tb.push("0");
}
l=0,va=ta[0], vb=tb[0];
while (l++<maxl) {
va+=ta[l] * Math.pow(10,l);
vb+=tb[l] * Math.pow(10,l);
}
return (va > vb)? 1: -1;
}
 
var i=-1, maxl=0;
t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.0.0","A,306.0.0.1","ABBA,86.0.22.1","ABBA,9.0","ABBA,0.0.7.45.12"];
//determination de la longueur max
while(t[++i]){
l=t[i].match(reg).length;
maxl= (maxl<l)?l:maxl;
}
 
t.sort(mysort);
console.log(t);

ca qui donne :

0: "A,1.2.3.0.0.7"
1: "A,306.0.0"
2: "A,306.0.0.1"
3: "A,45.2.3.4"
4: "ABBA,0.0.7.45.12"
5: "ABBA,86.0.22.1"
6: "ABBA,9.0"

**javatwister** · 25/03/2021, 18h20

3: "A,45.2.3.4" et 6: "ABBA,9.0" = erreurs de tri;

**javatwister** · 25/03/2021, 18h47

Fallait juste que j'appuie sur le bon bouton pour trouver plus simple

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const t=["A,1.2.3.0.0.7","A,45.2.3.4","A,306.10.0","A,306.10.0.7","A,306.10.0.7.0","A,306.0.0.0.3.0","ABBA,86.0.22.1","ABBA,86.0.22.1.0","A,306.0.0.1.0","ABBA,9.0","ABBA,0.0.7.45.12"],
t2=[],t3=[];
t.map(v=> v.split(/[.,]/)).forEach(v=> !t2[v[0]] ? t2[v[0]]=[v] : t2[v[0]].push(v));
 
for(j in t2){
	t2[j].sort((a,b)=>{
		let lg=b.length > a.length ? b.length : a.length;
		for(let i=1;i<lg;i++){
			if(a[i]-b[i]!=0){
				return b[i]-a[i] || b.length - a.length
			}
		}
	})
	t3.push(`${j},${t2[j][0].slice(1).join("-")}`)
}
console.log(t3.sort())

Récupérer les valeurs les plus élevées dans un array

JavaScript

Discussions similaires

Partager

Partager