la plus efficace façon d'obtenir la chaîne avec la plus haute priorité sur un tableau

Question

Disons que j'ai un tableau comme suit:

var numArray = [ 1, 2, 1, 2, 1, 1, 3, 2, 1, 3 ]; 

Je pourrais facilement obtenir la valeur maximale hors de lui en utilisant:

Math.max.apply(Math, array); 

Mais si je devais un tableau comme suit:

var stringArray = [ "Foo", "Very Foo", "Not So Foo", 
        "Foo", "Very Foo", "Extremely Foo" ]; 

Alors quelle serait la façon d'obtenir la valeur maximale la plus efficace o Tout d'abord, la valeur maximale étant, par ordre d'importance: "Extrêmement Foo"> "Très Foo"> "Foo"> "Pas So Foo"

La première chose qui vint à l'esprit était iterating à travers le tableau avec un boucle et comparer manuellement en tant que tel:

var maxValue = ""; 
for(var i = 0; i < stringArray.length; i++) { 
    if(maxValue != "Extremely Foo") { 
     if(maxValue != "Very Foo") { 
      if(maxValue != "Foo") { 
       maxValue = stringArray[i]; 
      } 
      else if(stringArray[i] != "Not So Foo") { 
       maxValue = stringArray[i]; 
      } 
     } 
     else if(stringArray[i] == "Extremely Foo") { 
      maxValue = stringArray[i]; 
      break; 
     } 
    } 
    else { break; } 
} 

Alors je pensais à faire un ENUM pour donner à chaque autre chaîne une valeur:

enum Foos { 
    Not So Foo = 0, 
    Foo = 1, 
    Very Foo = 2, 
    Extremely Foo = 3, 
} 

et en utilisant la valeur ENUM en tant que méthode de comparaison à utiliser plus de opérateur logique à la place.

Ma question est: Quelle est la meilleure façon d'atteindre ce que j'essaie d'atteindre? L'une des deux façons dont j'ai parlé ou est-ce qu'il y a une façon différente de le faire en Javascript qui est plus efficace?

Answer 1

Vous pouvez utiliser # Array réduire, et sur chaque chaîne de prise d'itération avec la valeur la plus élevée dans le ENUM:

var foosEnum = { "Not So Foo": 0, "Foo": 1, "Very Foo": 2, "Extremely Foo": 3 }; 
 
var stringArray = [ "Foo", "Very Foo", "Not So Foo", "Foo", "Very Foo", "Extremely Foo" ]; 
 
        
 
var result = stringArray.reduce(function(c, n) { 
 
    return foosEnum[c] > foosEnum[n] ? c : n; 
 
}); 
 

 
console.log(result);

Answer 2

Vous pourriez faire un tableau de vos priorités dans l'ordre croissant, puis trier votre stringArray en utilisant l'index de commande:

const stringArray = [ "Foo", "Very Foo", "Not So Foo", 
 
        "Foo", "Very Foo", "Extremely Foo" ] 
 
const order = ['Not so Foo', 'Foo', 'Very Foo', 'Extremely Foo']; 
 
stringArray.sort((a, b) => order.indexOf(b) - order.indexOf(a)) 
 
console.log(stringArray)

Answer 3

Vous devriez avoir un tableau de nombres et simplement convertir les nombres en chaînes si vous devez les afficher.

Answer 4

Si vous aviez un tableau de fooportance, vous pouvez créer une fonction fooness qui détermine la plus grande valeur de foo dans le tableau de foos

function fooness(foo) { 
 
    var fooportance = ["Extremely Foo", "Very Foo", "Foo", "Not So Foo"]; 
 
    return fooportance.indexOf(foo); 
 
} 
 

 
var stringArray = ["Foo", "Very Foo", "Not So Foo", "Foo", "Very Foo", "Extremely Foo"]; 
 

 
stringArray.sort(function(a, b) { 
 
    return fooness(a) > fooness(b); 
 
}); 
 

 
var mostFoo = stringArray[0]; 
 

 
console.log(mostFoo)

Answer 5

Vous pouvez mapper vos clés aux numéros (vous avez quatre clés donc: 0,1,2,3), puis trier les chaînes en utilisant les chiffres, après que la chaîne la plus haute sera à la première position (0):

var myMap = {"Not So Foo":0, 
      "Foo":1, 
      "Very Foo":2, 
      "Extremely Foo":3}; 
var stringArray = [ "Foo", "Very Foo", "Not So Foo", 
       "Foo", "Very Foo", "Extremely Foo" ]; 
stringArray.sort(function(a,b){ 
    return myMap[b] - myMap[a]; 
}); 
var highest = stringArray[0];