Metodi di estensione
Aggiungere metodi ai tipi
Metodi di estensione è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Aggiungere metodi a tipi esistenti
I metodi di estensione consentono di aggiungere nuovi metodi a un tipo che non appartiene a chi sviluppa il codice, come Int o String, senza modificarne il codice sorgente. Scala 3 offre una sintassi chiara per farlo.
object Main:
extension (x: Int)
def squared: Int = x * x
def main(args: Array[String]): Unit =
println(5.squared)La sintassi delle estensioni
Scriva extension (param: Type) seguito da una o più definizioni di metodi. All'interno di ciascun metodo, il parametro fa riferimento al valore ricevente.
object Main:
extension (s: String)
def shout: String = s.toUpperCase + "!"
def main(args: Array[String]): Unit =
println("hello".shout)Più metodi in un unico blocco
Una singola clausola extension può definire diversi metodi che operano tutti sullo stesso tipo ricevente.
object Main:
extension (x: Int)
def squared: Int = x * x
def cubed: Int = x * x * x
def isEven: Boolean = x % 2 == 0
def main(args: Array[String]): Unit =
println(4.squared)
println(3.cubed)
println(6.isEven)Metodi di estensione con parametri
I metodi di estensione possono accettare parametri propri, oltre al ricevente.
object Main:
extension (x: Int)
def times(s: String): String = s * x
def main(args: Array[String]): Unit =
println(3.times("ab"))Metodi di estensione generici
Le estensioni possono essere generiche e aggiungere metodi a un'intera famiglia di tipi, come List[A].
object Main:
extension [A](xs: List[A])
def second: A = xs(1)
def main(args: Array[String]): Unit =
println(List(10, 20, 30).second)
println(List("a", "b").second)Perché le estensioni sono migliori delle conversioni implicite
I metodi di estensione raggiungono in modo più sicuro l'obiettivo del vecchio approccio 'pimp-my-library': aggiungono solo i metodi indicati, senza il rischio di conversioni di tipo silenziose in altre parti del codice.
object Main:
extension (d: Double)
def percentOf(total: Double): Double = d / total * 100
def main(args: Array[String]): Unit =
println(25.0.percentOf(200.0))Estensioni e type class
I metodi di estensione si abbinano perfettamente alle type class: definisca il comportamento tramite un'istanza given ed esponga tale comportamento come metodo usando using.
trait Show[A]:
def show(a: A): String
object Main:
given Show[Int] with
def show(a: Int): String = s"<$a>"
extension [A](a: A)
def display(using s: Show[A]): String = s.show(a)
def main(args: Array[String]): Unit =
println(42.display)Definire operatori
Poiché gli operatori sono semplicemente metodi, le estensioni possono aggiungere anche operatori simbolici ai tipi esistenti.
object Main:
extension (x: Int)
def **(exp: Int): Int = math.pow(x, exp).toInt
def main(args: Array[String]): Unit =
println(2 ** 10)Ambito e importazioni
I metodi di estensione sono disponibili solo dove rientrano nell'ambito. Li definisca in un oggetto e lo importi per poterli usare, mantenendone sotto controllo la visibilità.
object StringOps:
extension (s: String)
def reversedWords: String = s.split(" ").reverse.mkString(" ")
object Main:
import StringOps._
def main(args: Array[String]): Unit =
println("hello there world".reversedWords)Concatenare i metodi di estensione
I metodi di estensione restituiscono normali valori, quindi può concatenarli con i metodi integrati per creare pipeline fluide.
object Main:
extension (s: String)
def emphasize: String = s"*$s*"
def main(args: Array[String]): Unit =
println("scala".toUpperCase.emphasize)Un helper pratico
I metodi di estensione sono ideali per piccoli helper specifici del dominio, che rendono naturale la lettura del codice chiamante.
object Main:
extension (n: Int)
def isPrime: Boolean =
n > 1 && (2 until n).forall(d => n % d != 0)
def main(args: Array[String]): Unit =
println((2 to 12).filter(_.isPrime).toList)Verifica rapida
Qual è il principale vantaggio dei metodi di estensione di Scala 3 rispetto alle conversioni implicite per aggiungere metodi?
Riepilogo
Ha appreso i metodi di estensione:
extension (x: Type) def ...aggiunge metodi ai tipi esistenti- un blocco può definire più metodi, inclusi gli operatori
- possono essere generici e accettare parametri
- si abbinano naturalmente alle type class tramite
using - sono più sicuri delle conversioni implicite e devono essere importati nell'ambito
Impara Scala con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 143
Domande Frequenti
La lezione «Metodi di estensione» è gratuita?
Sì — il testo completo di «Metodi di estensione» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.
Cosa imparerò in «Metodi di estensione»?
Aggiungere metodi ai tipi Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?
Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Metodi di estensione»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?
Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Parametri impliciti
- given/using in Scala 3
- Conversioni implicite
- Metodi di estensione