Mayor rendimento en tratamiento de arrays

[DoHITB]

Buenas,

Tengo una duda técnica, a ver si me podéis ayudar:

Estoy ordenando un array con una función general. Ésta acepta un parámetro para decidir si es de mayor a menor o de meno a mayor.

Entonces, se me ocurren dos alternativas:

Código Javascript:

//suponemos que los datos a comparar son datoA y datoB
if(mayorAmenor){
  r = '>='
}else{
  r = '<='
}
 
if(eval('datoA'+r+'datoB')){
  //datoA es mayor
}
 

frente a una ordenación "estándar", digamos siempre de mayor a menor, y luego hacer:

Código Javascript:

//ordenas el array, guardado en miArray
 
if(menorAmayor){
  miArray.reverse();
}
 

Se que el "eval()" está mal visto, pero en este caso me va muy bien; por otra parte no se si consume más que el "reverse"... puesto que teóricamente el 50% de los casos puede necesitar un "reverse"...

¿Qué daría mayor rendimiento (es decir, no me vale eso de "el segundo porque no usa eval()")?

Saludos y gracias.

[IsaBelM]

creo que obtendrás mejor rendimiento y más eficiencia con es esto

(function ord(r) {

console.log([0, 2, 4, 10, 3, 1].sort(function(f, s) {
if(r)
return f - s;
return s - f;

}));

})(false);

[DoHITB]

Iniciado por IsaBelM

creo que obtendrás mejor rendimiento y más eficiencia con es esto

Ya, bueno... conozco la función sort...

El tema no es más que quiera en realidad ordenar el array, sino experimentar con JS haciendo cosas por mi cuenta (en mi opinión, la mejor manera de aprender).

Es decir, es como "auto-imponerse" ejercicios en los que tenga uno que exprimirse el coco, con tal que de salgan dudas como "¿qué es más eficiente, el dar la vuelta o el eval()?"

Desde mi punto de vista, veo que el "eval()" tiene un valor añadido, mientras que el hacer un orden fijo y luego mirar de invertir si es preciso puede ser más óptimo (sobretodo si no hay que darle la vuelta - en caso contrario haces n/2 pasos extra, donde "n" es la longitud del array).

De todas maneras gracias y un saludo.

[IsaBelM]

tu consulta no tiene respuesta. contrapones dos códigos sin relación alguna. por un lado evalúas dos valores y por otro reordenas una matriz

en el primero de los casos, el uso de eval() no es que esté desaconsejado, como puedes leer en la gran cantidad de literatura que hay en la web sobre esta función, sino que no es necesario. para evaluar dos valores

if(mayorAmenor){
return a >= b;
}else{
return a < b;
}

buscándole tres pies al gato

if(mayorAmenor){
return Math.min(a, b);
}else{
return Math.max(a, b);
}

[DoHITB]

Iniciado por IsaBelM

tu consulta no tiene respuesta. contrapones dos códigos sin relación alguna. por un lado evalúas dos valores y por otro reordenas una matriz

en el primero de los casos, el uso de eval() no es que esté desaconsejado, como puedes leer en la gran cantidad de literatura que hay en la web sobre esta función, sino que no es necesario. para evaluar dos valores


buscándole tres pies al gato

Entiendo que en principio no se vea la relación entre los códigos... quizá obvié demasiado código.

Dejo el algoritmo que pretendo evaluar:

Código:

Array toSort; //array a ordenar, suponemos tiene datos (numéricos)
i = 0;
j = 0;
n = longitud(toSort);

de i=0 hasta n de 1 en 1
  max = i

  de j = i+1 hasta n de 1 en 1
    si array(j) >= array(max)
        max = j
    fin
  sigue

  intercambia(array(i), array(max))
sigue

Esto ordenaría de mayor a menor (descendente). No obstante se podría querer ordenar es ascendente, por lo que se podría añadir un parámetro tal que:

Código:

orden = '>=';

si ascendente
    orden = '<=';
fin

y luego evalular (eval()) la condición para obtener el orden deseado.

La contrapostura sería:

Código:

ordena

si ascendente
    cambia_orden(array);
fin

Espero que ahora se vea más clara la contraposición de los dos códigos.

Saludos y gracias por contestar.