web-dev-qa-db-fra.com

Renvoie la chaîne la plus longue du tableau (JavaScript)

J'essaie donc de trouver la chaîne la plus longue dans un tableau de chaînes. J'ai déjà fait un problème similaire à celui-ci auparavant où je devais renvoyer la longueur de la plus longue chaîne. Le problème est que mon code fonctionne et renvoie 11 quand il ressemble à ceci:

var long1= 0;

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"];

function longestString(arr){
  for (i=0; i<arr.length; i++){
      if (arr[i].length > long1){
        long1= arr[i].length;
      }

  }
  return long1;
}

mais si je change long1= arr[i].length; en long1 = arr[i];, il retourne simplement arr[0] à la place. Est-ce que j'ai râté quelque chose? La boucle semble itérer correctement sinon.

Edit: c’est-à-dire qu’il renvoie bbllkw.

javascriptarraysstringfor-loop
6
leandraaar

Vous devez simplement changer une longue déclaration en: 

var long1= '';

et dans l'état de boucle for, il devrait être 

arr[i].length > long1.length
3
user8012147

Vous pouvez utiliser reduce à la place:

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"];
var longest = plorp.reduce(function(a, b) { 
  return a.length > b.length ? a : b
}, '');
console.log(longest);

Ou version ES6:

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"];
var longest = plorp.reduce((a, b) => a.length > b.length ? a : b, '');
console.log(longest);

8
Dekel

Mis à jour lorsqu'un utilisateur souhaitait une solution plus basique

Nous trouvons ici la plus grande longueur d'un élément de tableau avec la fonction reduce, puis filtrons le tableau avec les éléments ayant cette longueur avec la fonction filter. Il nous renvoie plusieurs éléments s'ils ont la même longueur mais la plus longue

var plorp = ['sameLength', 'someoth', 'asfzc', 'sameLLngth'];
    ln = plorp.reduce((r,s) => r > s.length ? r : s.length, 0);


const result = plorp.filter(pl => pl.length == ln);

console.log(result);

Old Answer

S'il y aplus d'une chaînela plus longue du tableau, il en retournera un tableau. S'il n'y en a qu'un seul, il renverra la chaîne et non un tableau.

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"];
var wholeArr = [];

function longestString(arr) {
    var tlength = 0;
    for(var i =0; i < plorp.length; i++){
      if(tlength < plorp[i].length){
        tlength = plorp[i].length;
      }
    }
    for(var j =0; j < plorp.length; j++){
      if(plorp[j].length == tlength){
         wholeArr.Push(plorp[j]);
      }
    }
   if(wholeArr.length == 1){
     return wholeArr[0]
   }else{
      return wholeArr
  }
}


console.log(longestString(plorp));
2
turmuka

var arr = ["premier", "deuxième", "troisième", "quatrième", "mille"]

fonction getLongestString (arr) { let longestStringArr = arr.sort ((a, b) => a.length - b.length) .reverse (); renvoie longestStringArr [0]; } 

console.log (getLongestString (arr)) 

1
Bharti Ladumor

Comparez simplement la longueur des chaînes, puis affectez-la à long1.

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis", "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz", "qqquuhii", "dvvvwz"];

function longestString(arr) {
  var long1 = arr[0];
  for (i = 0; i < arr.length; i++) {
    if (arr[i].length > long1.length) {
      long1 = arr[i];
    }
  }
  return long1;
}


console.log(longestString(plorp));

0
Daolagajao

Le problème est quand vous définissez

long1=arr[i];

Et vous comparez avec la longueur qui est une valeur entière.

À la première itération, vous comparez la valeur entière 0 à la longueur de la première chaîne, ce qui rend bien sûr le résultat de l'expression de comparaison vrai et vous définissez 

 long1=arr[0];

Pour l'itération suivante, long1 ne contient plus de valeur entière mais de chaîne. La comparaison entre length et long1 renvoie toujours false. 

C'est pourquoi vous obtenez toujours la première chaîne comme résultat.

Vous devez initialiser long1 en tant que chaîne vide et utiliser long1.length pour la comparaison comme suggéré par la réponse de belhadj.

0
Zamrony P. Juhara

Une autre solution implique la méthode sort du tableau et une fonction de comparaison, mais il peut s'agir d'une solution "lourde" selon MDN :

En fonction de la nature de la fonction compareFunction, cette valeur peut générer un .__ élevé. aérien. Plus la comparaisonFunction est efficace et plus nombreux sont les éléments il est judicieux d’envisager d’utiliser une carte pour tri.

Donc, en prenant le conseil précédent, voici un moyen d’obtenir la plus longue chaîne en utilisant une carte en conjonction avec la méthode de tri d’un tableau, comme suit:

var plorp = ["bbllkw", "oox", "ejjuyyy", "plmiis",
             "xxxzgpsssa", "xxwwkktt", "znnnnfqknaz",
             "qqquuhii", "dvvvwz"];

function getLongestStr() {
  var mapped = plorp.map((el, i) => ({ index: i, length: el }) );
  mapped.sort((a, b) => {

      if (a.length > b.length) {
        return -1;
      }
   
      if (a.length < b.length) {
        return 1;
      }
      return 0;
  });

// DESC order so longest string in 0th element
  return mapped.map((el) => plorp[el.index])[0];
}
console.log( getLongestStr() );

Discussion connexe intéressante ici .

0
slevy1