El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Funcions d'Ordre Superior

Següent ►
►

Les funcions d'ordre superior són un concepte fonamental en la programació funcional i són àmpliament utilitzades en Scala. Aquestes funcions poden rebre altres funcions com a paràmetres, retornar funcions com a resultat, o ambdues coses. Això permet una gran flexibilitat i expressivitat en el codi.

Conceptes Clau

  1. Funcions com a Paràmetres: Les funcions poden ser passades com a arguments a altres funcions.
  2. Funcions com a Resultat: Les funcions poden retornar altres funcions.
  3. Composició de Funcions: Les funcions poden ser combinades per crear noves funcions.

Exemples Pràctics

Funcions com a Paràmetres

Una funció d'ordre superior pot rebre una funció com a argument. Per exemple, considerem una funció applyOperation que aplica una operació a dos nombres:

def applyOperation(a: Int, b: Int, operation: (Int, Int) => Int): Int = {
  operation(a, b)
}

// Definim algunes operacions
val sum = (x: Int, y: Int) => x + y
val multiply = (x: Int, y: Int) => x * y

// Utilitzem applyOperation amb diferents operacions
val result1 = applyOperation(3, 4, sum) // 7
val result2 = applyOperation(3, 4, multiply) // 12

println(result1) // Imprimeix 7
println(result2) // Imprimeix 12

Funcions com a Resultat

Una funció d'ordre superior pot retornar una funció com a resultat. Per exemple, considerem una funció createMultiplier que crea una funció multiplicadora:

def createMultiplier(factor: Int): Int => Int = {
  (x: Int) => x * factor
}

val double = createMultiplier(2)
val triple = createMultiplier(3)

println(double(5)) // Imprimeix 10
println(triple(5)) // Imprimeix 15

Composició de Funcions

La composició de funcions permet combinar dues o més funcions per crear una nova funció. Scala proporciona l'operador andThen per a aquest propòsit:

val addOne = (x: Int) => x + 1
val multiplyByTwo = (x: Int) => x * 2

val addOneAndMultiplyByTwo = addOne andThen multiplyByTwo

println(addOneAndMultiplyByTwo(5)) // Imprimeix 12

Exercicis Pràctics

Exercici 1: Filtrar una Llista

Escriu una funció d'ordre superior filterList que filtri una llista d'enters segons un predicat donat.

def filterList(list: List[Int], predicate: Int => Boolean): List[Int] = {
  list.filter(predicate)
}

// Prova la funció
val numbers = List(1, 2, 3, 4, 5, 6)
val isEven = (x: Int) => x % 2 == 0

val evenNumbers = filterList(numbers, isEven)
println(evenNumbers) // Imprimeix List(2, 4, 6)

Exercici 2: Transformar una Llista

Escriu una funció d'ordre superior transformList que transformi una llista d'enters segons una funció donada.

def transformList(list: List[Int], transformer: Int => Int): List[Int] = {
  list.map(transformer)
}

// Prova la funció
val numbers = List(1, 2, 3, 4, 5)
val square = (x: Int) => x * x

val squaredNumbers = transformList(numbers, square)
println(squaredNumbers) // Imprimeix List(1, 4, 9, 16, 25)

Errors Comuns i Consells

  1. Oblidar el Tipus de Retorn: Quan es defineix una funció que retorna una altra funció, és important especificar correctament el tipus de retorn.
  2. Confusió amb la Sintaxi: La sintaxi de les funcions d'ordre superior pot ser confusa al principi. Practicar amb exemples senzills pot ajudar a comprendre millor.
  3. No Utilitzar Funcions Pures: Assegura't que les funcions que passes com a arguments o retornes siguin pures (sense efectes secundaris) per mantenir la coherència de la programació funcional.

Conclusió

Les funcions d'ordre superior són una eina poderosa en Scala que permeten escriure codi més modular i reutilitzable. Comprendre com passar funcions com a arguments, retornar funcions i compondre funcions és essencial per aprofitar al màxim les capacitats de Scala. Practica amb els exemples i exercicis proporcionats per consolidar aquests conceptes.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats