Performances Scala: Imperative VS Style fonctionnel

Question

Je suis nouveau à Scala et je viens de lire scala par exemple .Au chapitre 2, l'auteur dispose de 2 versions différentes de Quicksort.

un est un style impératif:

def sort(xs: Array[Int]) {
    def swap(i: Int, j: Int) {
        val t = xs(i); xs(i) = xs(j); xs(j) = t
    }
    def sort1(l: Int, r: Int) {
        val pivot = xs((l + r) / 2)
        var i = l; var j = r
        while (i <= j) {
            while (xs(i) < pivot) i += 1
            while (xs(j) > pivot) j -= 1
            if (i <= j) {
                swap(i, j)
                i += 1
                j -= 1
            }
        }
        if (l < j) sort1(l, j)
        if (j < r) sort1(i, r)
    }
    sort1(0, xs.length - 1)
}

Un style fonctionnel:

def sort(xs: Array[Int]): Array[Int] = {
  if (xs.length <= 1) xs
  else {
    val pivot = xs(xs.length / 2)
    Array.concat(
      sort(xs filter (pivot >)),
           xs filter (pivot ==),
      sort(xs filter (pivot <)))
  }
}

L'avantage évident que le style fonctionnel a sur le style impératif est la concision.Mais qu'en est-il de la performance?Depuis qu'il utilise la récursion, payons-nous pour la pénalité de performance comme nous le faisons dans d'autres langues impératives comme c?Ou, Scala étant une langue hybride, la "voie Scala" (fonctionnelle) est préférable, donc plus efficace.

Remarque: l'auteur a mentionné que le style fonctionnel utilise plus de mémoire.

Answer 1

Cela dépend. Si vous regardez dans les sources Scala, il y a souvent un style impératif utilisé «sous la hotte» afin d'être performant - mais dans de nombreux cas exactement ces modifications permettent vous réalisateur fonctionnaire code. Donc, généralement, vous pouvez trouver une solution fonctionnelle assez rapide, mais vous devez faire attention et savoir ce que vous faites (surtout concernant vos structures de données). Par exemple. Le tableau Concat dans le deuxième exemple n'est pas agréable, mais probablement pas trop mal - mais en utilisant des listes ici et les concessions avec ::: Serions surchargées.

Mais ce n'est pas plus que des devinements éduqués si vous ne mettez pas vraiment mesurer la performance. Dans des projets complexes, il est très difficile de prédire la performance, d'autant plus que des choses telles que la création d'objets et les appels de méthode deviennent de plus en plus optimisées par le compilateur et la JVM.

Je suggérerais de commencer avec le style fonctionnel. Si c'est trop lent, profilez-le. Habituellement, il y a une meilleure solution fonctionnelle. Sinon, vous pouvez utiliser le style impératif (ou un mélange de la fois) en dernier recours.