Quel est le moyen le plus efficace d'inverser un tableau en Javascript?

Basé sur cette configuration:

var array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var length = array.length;

Array.reverse(); est le premier ou le deuxième plus lent!

Les repères sont ici: http://jsperf.com/js-array-reverse-vs-while-loop/5

Dans tous les navigateurs, les boucles d'échange sont plus rapides. Il existe deux types courants d'algorithmes d'échange (voir Wikipedia ), chacun avec deux variations.

Les deux types d'algorithmes de swap sont le swap temporaire et le swap XOR.

Les deux variations gèrent les calculs d'index différemment. Le la première variation compare l'index gauche actuel et l'index droit, puis décrémente l'index droit du tableau. La deuxième variation compare l'index gauche actuel et la longueur divisée par la moitié, puis recalcule l'index droit pour chaque itération.

Vous pouvez ou ne pouvez pas voir d'énormes différences entre les deux variations. Par exemple, dans Chrome 18, les premières variations du swap temporaire et du swap XOR sont plus de 60% plus lentes que les deuxièmes variations, mais dans Opera 12, les deux les variations du swap temporaire et du swap XOR ont des performances similaires.

D'échange Temporaire:

Première variation:

function temporarySwap(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0, right = length - 1; left < right; left += 1, right -= 1)
    {
        var temporary = array[left];
        array[left] = array[right];
        array[right] = temporary;
    }
    return array;
}

Deuxième variante:

function temporarySwapHalf(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0; left < length / 2; left += 1)
    {
        right = length - 1 - left;
        var temporary = array[left];
        array[left] = array[right];
        array[right] = temporary;
    }
    return array;
}

XOR swap:

Première variation:

function xorSwap(array)
{
    var i = null;
    var r = null;
    var length = array.length;
    for (i = 0, r = length - 1; i < r; i += 1, r -= 1)
    {
        var left = array[i];
        var right = array[r];
        left ^= right;
        right ^= left;
        left ^= right;
        array[i] = left;
        array[r] = right;
    }
    return array;
}

Deuxième variante:

function xorSwapHalf(array)
{
    var i = null;
    var r = null;
    var length = array.length;
    for (i = 0; i < length / 2; i += 1)
    {
        r = length - 1 - i;
        var left = array[i];
        var right = array[r];
        left ^= right;
        right ^= left;
        left ^= right;
        array[i] = left;
        array[r] = right;
    }
    return array;
}

Il existe une autre méthode d'échange appelée affectation de déstructuration: http://wiki.ecmascript.org/doku.php?id=harmony:destructuring

Déstructuration affectation:

Première variation:

function destructuringSwap(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0, right = length - 1; left < right; left += 1, right -= 1)
    {
        [array[left], array[right]] = [array[right], array[left]];
    }
    return array;
}

Deuxième variante:

function destructuringSwapHalf(array)
{
    var left = null;
    var right = null;
    var length = array.length;
    for (left = 0; left < length / 2; left += 1)
    {
        right = length - 1 - left;
        [array[left], array[right]] = [array[right], array[left]];
    }
    return array;
}

En ce moment, un algorithme utilisant l'affectation de déstructuration est le plus lent de tous. Il est encore plus lent que Array.reverse();. Cependant, les algorithmes utilisant des affectations de déstructuration et des méthodes Array.reverse(); sont les exemples les plus courts, et ils ont l'air les plus propres. J'espère que leur performance s'améliorera à l'avenir.

Une autre mention est que les navigateurs modernes améliorent leurs performances de matrice push et splice opérations.

Dans Firefox 10, cet algorithme de boucle for utilisant array push et splice rivalise avec les algorithmes de boucle d'échange temporaire et XOR.

for (length -= 2; length > -1; length -= 1)
{
    array.push(array[length]);
    array.splice(length, 1);
}

Cependant, vous devriez probablement rester avec les algorithmes de boucle d'échange jusqu'à ce que beaucoup d'autres navigateurs correspondent ou dépassent leurs performances array push et splice.