Sono nuovo di Scala e stavo leggendo solo Scala By Example. Nel capitolo 2, l'autore ha 2 diverse versioni di Quicksort.Scala Performance: imperativo vs stile funzionale
uno in stile imperativo:
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)
}
Uno è stile funzionale:
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 <)))
}
}
Il vantaggio evidente lo stile funzionale ha più stile imperativo è concisione. Ma per quanto riguarda le prestazioni? Dal momento che usa la ricorsione, paghiamo la penalizzazione delle prestazioni proprio come facciamo in altre lingue imperative come la C? Oppure, essendo Scala un linguaggio ibrido, il "modo di Scala" (funzionale) è preferito, quindi più efficiente.
Nota: l'autore ha menzionato lo stile funzionale che utilizza più memoria.
possibile duplicato di [La programmazione funzionale scala è più lenta della codifica tradizionale?] (Http://stackoverflow.com/questions/2794823/is-scala-functional-programming-slower-than-traditional-coding) – missingfaktor
"Conciso" non è lo stesso di "leggibile". Prova: [il linguaggio di programmazione J] (http://en.wikipedia.org/wiki/J_ (programming_language)) –
Penso di capire ora che l'autore di Scala per esempio sta cercando di mostrare un altro modo per risolvere il problema che è molto più conciso. Per riassumere: si programma il più conciso possibile in tutte le parti del codice, in modo da ottenere la massima concisione, produttività. Quindi esegui la tua applicazione e, se è troppo lenta, configurala e ottimizza le parti del collo di bottiglia. – sivabudh