Domande di Intervista Scala

Prima di leggere questo post, ti preghiamo di consultare il mio post precedente su “Domande e Risposte Basiche per un Colloquio su Scala” per acquisire una conoscenza di base del linguaggio Scala. In questo post, discuteremo alcune altre domande per un colloquio su Scala che potrebbero essere utili per alcuni sviluppatori esperti di Scala. Nota:- Poiché questa lista è già diventata molto grande, scriverò un altro post con le domande e risposte rimanenti. Si prega di fare riferimento a quel post su: “Domande e Risposte Intermedie e Avanzate per un Colloquio su Scala“

Domande per un Colloquio su Scala

In questa sezione, elencheremo tutte le domande intermedie per un colloquio su Scala e nella prossima sezione le discuteremo in dettaglio.

1. Cos’è il Costruttore Primario? Cos’è il Costruttore Secondario o Ausiliario in Scala?
2. Qual è l’uso dei Costruttori Ausiliari in Scala? Potresti spiegare le regole da seguire nella definizione di Costruttori Ausiliari in Scala?
3. Quali sono le differenze tra Array e ArrayBuffer in Scala?
4. Cos’è una classe case? Cos’è un oggetto case? Quali sono i vantaggi di una classe case?
5. Qual è la differenza tra un Oggetto Case e un Oggetto (Oggetto Normal)?
6. Rispetto alla classe normale, quali sono i principali vantaggi o benefici di una classe di tipo Case?
7. Qual è l’utilizzo dei metodi isInstanceOf e asInstanceOf in Scala? Esiste un concetto simile disponibile in Java?
8. Come si prova che per default, l’oggetto di tipo Case è Serializable mentre l’oggetto normale non lo è?
9. Differenza tra Array e List in Scala?
10. Qual è la differenza tra “val” e “lazy val” in Scala? Cosa si intende per valutazione immediata (Eager Evaluation)? Cosa si intende per valutazione ritardata (Lazy Evaluation)?
11. Qual è la relazione tra il metodo equals e l’operatore == in Scala? Differenza tra l’operatore == di Scala e l’operatore == di Java?
12. Differenza tra la classe interna di Scala e la classe interna di Java?
13. Cosa si intende per Diamond Problem? Come Scala risolve il Diamond Problem?
14. Perché Scala NON ha la parola chiave “static”? Qual è la ragione principale di questa decisione?
15. Qual è l’utilizzo della parola chiave “object” in Scala? Come creare oggetti Singleton in Scala?
16. Come definire metodi Factory utilizzando la parola chiave “object” in Scala? Qual è l’utilità di definire metodi Factory nell’object?
17. Cosa è il metodo apply in Scala? Cosa è il metodo unapply in Scala? Qual è la differenza tra i metodi apply e unapply in Scala?
18. Come funziona internamente quando si crea un’istanza di una classe senza utilizzare la parola chiave ‘new’ in Scala? Quando si utilizza questo approccio?
19. Come dichiarare un costruttore primario privato in Scala? Come effettuare una chiamata a un costruttore primario privato in Scala?
20. Un oggetto Companion accede ai membri privati della sua classe Companion in Scala?
21. Qual è la principale decisione di design riguardo alle due parole chiave separate: class e object in Scala? Come definiamo i membri di istanza e i membri statici in Scala?
22. Cosa è un oggetto in Scala? È un oggetto singleton o un’istanza di una classe?
23. Cosa è un oggetto Companion in Scala? Cosa è una classe Companion in Scala? Qual è l’utilizzo di un oggetto Companion in Scala?
24. Come implementare le interfacce in Scala?
25. Cosa è un Range in Scala? Come creare un Range in Scala?
26. Quanti valori di tipo Nothing ci sono in Scala?
27. Quanti valori di tipo Unit ci sono in Scala?
28. Cosa è un Range in Scala? Come creare un Range in Scala?
29. Nella programmazione funzionale, qual è la differenza tra una funzione e una procedura?
30. Quali sono le principali differenze tra i costruttori ausiliari di Scala e i costruttori di Java?
31. A cosa serve la parola chiave ‘yield’ nella costruzione for-comprehension di Scala?
32. Cosa è una guardia nella costruzione for-comprehension di Scala?
33. Come Scala risolve automaticamente e facilmente il problema del Diamante dell’Ereditarietà rispetto a Java 8?
34. In Scala, il Pattern Matching segue quale Design Pattern? In Java, l’operatore ‘isinstanceof’ segue quale Design Pattern?

Domande e risposte per un’intervista su Scala

In questa sezione, prenderemo ogni singola domanda dalla lista sopra e discuteremo in dettaglio con esempi appropriati (se necessario). Se vuoi capire questi concetti approfonditamente con degli esempi, ti preghiamo di leggere i miei post precedenti nella sezione Tutorial su Scala.

Cosa è il Costruttore Principale? Cosa è il Costruttore Secondario o Ausiliario in Scala? Qual è lo scopo del Costruttore Ausiliario in Scala? È possibile sovraccaricare i costruttori in Scala?

Scala ha due tipi di costruttori:

• Costruttore Principale
• Costruttore Ausiliario

Costruttore Principale In Scala, il Costruttore Principale è un costruttore definito insieme alla definizione della classe stessa. Ogni classe deve avere un Costruttore Principale: sia un costruttore con parametri che un costruttore senza parametri. Esempio:-

class Person

La classe Person sopra ha un costruttore primario senza parametri per creare istanze di questa classe.

class Person (firstName: String, lastName: String)

La classe Person sopra ha un costruttore primario con due parametri per creare istanze di questa classe. Costruttore ausiliare Il costruttore ausiliare è anche noto come costruttore secondario. Possiamo dichiarare un costruttore secondario usando le parole chiave ‘def’ e ‘this’ come mostrato di seguito:

class Person (firstName: String, middleName:String, lastName: String){
  def this(firstName: String, lastName: String){
      this(firstName, "", lastName)
  }
}

Qual è l’utilizzo dei costruttori ausiliari in Scala? Si prega di spiegare le regole da seguire nella definizione dei costruttori ausiliari in Scala?

In Scala, lo scopo principale dei costruttori ausiliari è sovraccaricare i costruttori. Come in Java, possiamo fornire diversi tipi di costruttori in modo che l’utente possa scegliere quello giusto in base alle sue esigenze. Regole per i costruttori ausiliari:

• Sono simili ai metodi. Come per i metodi, dobbiamo utilizzare la parola chiave ‘def’ per definirli.
• Dobbiamo utilizzare lo stesso nome ‘this’ per tutti i costruttori ausiliari.
• Ogni costruttore ausiliare deve iniziare con una chiamata a un altro costruttore ausiliare precedentemente definito o a un costruttore primario. Altrimenti, si verifica un errore in fase di compilazione.
• Ogni Costruttore Ausiliario dovrebbe differire dalla lista dei parametri: può essere per numero o tipi.
• I Costruttori Ausiliari non possono chiamare i costruttori della superclasse. Dovrebbero chiamarli solo attraverso il Costruttore Primario.
• Tutti i Costruttori Ausiliari chiamano il Costruttore Primario, direttamente o indirettamente attraverso altri Costruttori Ausiliari.

NOTA: Se vuoi conoscere i Costruttori di Scala, consulta i miei articoli su Scala su: Costruttore Primario e Costruttore Ausiliario.

Quali sono le differenze tra Array e ArrayBuffer in Scala?

Differenze tra Array e ArrayBuffer in Scala:

• Array è un array di dimensione fissa. Non possiamo cambiarne la dimensione una volta creato.
• ArrayBuffer è un array di dimensione variabile. La sua dimensione può aumentare o diminuire dinamicamente.
• Array è simile agli array primitivi di Java.
• ArrayBuffer è simile all’ArrayList di Java.

Cos’è una case class? Cos’è un case object? Quali sono i vantaggi delle case class?

Una case class è una classe definita con la parola chiave “case class”. Un case object è un oggetto definito con la parola chiave “case object”. Grazie a questa parola chiave “case”, otteniamo alcuni vantaggi per evitare la duplicazione di codice. Possiamo creare oggetti case class senza utilizzare la parola chiave “new”. Per default, il compilatore Scala aggiunge il prefisso “val” a tutti i parametri del costruttore. Pertanto, senza utilizzare val o var, i parametri del costruttore della case class diventano membri della classe, cosa che non è possibile per le classi normali. Vantaggi delle case class:

• Per default, il compilatore Scala aggiunge i metodi toString, hashCode e equals. Possiamo evitare di scrivere questo codice duplicato.
• Per default, il compilatore Scala aggiunge un oggetto companion con i metodi apply e unapply, per cui non è necessario utilizzare la parola chiave “new” per creare istanze di una case class.
• Per default, il compilatore Scala aggiunge anche il metodo copy.
• Possiamo utilizzare le case class nel Pattern Matching.
• Per default, le case class e i case object sono serializzabili.

Qual è la differenza tra Case Object e Object (Oggetto Normale)?

• L’oggetto normale viene creato utilizzando la parola chiave “object”. Di default, è un oggetto singleton.

object MyNormalObject

• Il Case Object viene creato utilizzando le parole chiave “case object”. Di default, è anche un oggetto singleton.

case object MyCaseObject

• Di default, il Case Object dispone dei metodi toString e hashCode. Ma l’oggetto normale no.
• Di default, il Case Object è Serializable. Ma l’oggetto normale non lo è.

Rispetto alla classe normale, quali sono i principali vantaggi o benefici di una classe case?

I seguenti sono i principali vantaggi o benefici di una classe case rispetto alle classi normali:

• Evita molte righe di codice boilerplate aggiungendo automaticamente alcuni metodi utili.
• Di default, supporta l’immobilità perché i suoi parametri sono ‘val’.
• Semplice da utilizzare nel pattern matching.
• Non è necessario utilizzare la parola chiave ‘new’ per creare un’istanza di una classe case.
• Per impostazione predefinita, supporta la Serializzazione e la Deserializzazione.

Qual è l’uso dei metodi isInstanceOf e asInstanceOf in Scala? Esiste un concetto simile in Java?

Entrambi i metodi isInstanceOf e asInstanceOf sono definiti nella classe Any. Quindi non c’è bisogno di importarli per ottenere questi metodi in qualsiasi classe o oggetto. Il metodo “isInstanceOf” è utilizzato per verificare se l’oggetto è di un determinato tipo o meno. Se lo è, restituisce vero. Altrimenti restituisce falso.

   scala> val str = "Hello"
   
   scala>str.isInstanceOf[String]
   res0: Boolean = false   
 

Il metodo “asInstanceOf” è utilizzato per convertire l’oggetto nel tipo dato. Se l’oggetto dato e il tipo sono dello stesso tipo, allora lo converte nel tipo dato. Altrimenti, lancia java.lang.ClassCastException.

 scala> val str = "Hello".asInstanceOf[String]
 str: String = Hello
 

In Java, la parola chiave ‘instanceof’ è simile al metodo ‘isInstanceOf’ di Scala. In Java, il seguente tipo di conversione manuale è simile al metodo ‘asInstanceOf’ di Scala.

AccountService service = (AccountService)
 context.getBean("accountService");

Come si dimostra che, per impostazione predefinita, Case Object è Serializable e Normal Object non lo è?

Sì, per impostazione predefinita, l’oggetto Case è serializzabile. Ma un oggetto normale non lo è. Possiamo dimostrarlo utilizzando il metodo isInstanceOf come mostrato di seguito:

scala> object MyNormalObject
defined object MyNormalObject

scala> MyNormalObject.isInstanceOf[Serializable]
res0: Boolean = false

scala> case object MyCaseObject
defined object MyCaseObject

scala> MyCaseObject.isInstanceOf[Serializable]
res1: Boolean = true

Differenza tra Array e List in Scala?

• Gli Array sono sempre mutabili, mentre le List sono sempre immutabili.
• Una volta creati, possiamo cambiare i valori degli Array, mentre non possiamo cambiare l’oggetto List.
• Gli Array sono strutture dati di dimensione fissa, mentre le List sono strutture dati di dimensione variabile. La dimensione della List viene automaticamente aumentata o diminuita in base alle operazioni che eseguiamo su di essa.
• Gli Array sono invarianti, mentre le List sono covarianti.

NOTA: Se non sei sicuro delle differenze tra Invariante e Covariante, leggi il mio prossimo post sulle domande di intervista su Scala.

Qual è la differenza tra “val” e “lazy val” in Scala? Cosa significa valutazione immediata? Cosa significa valutazione ritardata?

Come abbiamo discusso nelle mie domande di intervista di base su Scala, “val” significa valore o costante ed è utilizzato per definire variabili immutabili. Ci sono due tipi di valutazione dei programmi:

• Valutazione avida
• Valutazione pigra

La valutazione avida significa valutare il programma durante la compilazione o durante il deployment, indipendentemente dal fatto che i client stiano utilizzando quel programma o meno. La valutazione pigra significa valutare il programma durante l’esecuzione su richiesta, ovvero solo quando i client accedono al programma. La differenza tra “val” e “lazy val” è che “val” viene utilizzato per definire variabili che vengono valutate avidamente, mentre “lazy val” viene utilizzato anche per definire variabili, ma vengono valutate in modo pigro.

Qual è la relazione tra il metodo equals e l’operatore == in Scala? Differenzia l’operatore == di Scala dall’operatore == di Java?

In Scala, non è necessario chiamare il metodo equals() per confrontare due istanze o oggetti. Quando confrontiamo due istanze con ==, Scala chiama automaticamente il metodo equals() di quell’oggetto. L’operatore == di Java viene utilizzato per verificare l’uguaglianza dei riferimenti, ovvero se due riferimenti puntano allo stesso oggetto o meno. L’operatore == di Scala viene utilizzato per verificare l’uguaglianza delle istanze, ovvero se due istanze sono uguali o meno.

Differenza tra la classe interna di Scala e la classe interna di Java?

In Java, la classe interna è associata alla classe esterna, cioè la classe interna è un membro della classe esterna. A differenza di Java, Scala tratta la relazione tra classe esterna e classe interna in modo diverso. La classe interna di Scala è associata all’oggetto della classe esterna.

Cosa è il problema del diamante? Come Scala risolve il problema del diamante?

A Diamond Problem is a Multiple Inheritance problem. Some people calls this problem as Deadly Diamond Problem. In Scala, it occurs when a Class extends more than one Traits which have same method definition as shown below. Unlike Java 8, Scala solves this diamond problem automatically by following some rules defined in Language. Those rules are called “Class Linearization”. Example:-

trait A{   
  def display(){ println("From A.display")  }
}
trait B extends A{ 
  override def display() { println("From B.display") }
}
trait C extends A{ 
  override def display() { println("From C.display") }
}
class D extends B with C{ }

object ScalaDiamonProblemTest extends App {
    val d = new D
    d display
}

In questo caso l’output è “Da C.display” dal trait C. Il compilatore di Scala legge “extends B with C” da destra a sinistra e prende la definizione del metodo “display” dal trait più a sinistra, cioè C. NOTA: Leggi il mio post su “Scala Traits in Profondità” per una spiegazione più chiara di questo concetto.

Perché Scala NON ha la parola chiave “static”? Qual è la ragione principale di questa decisione?

Come sappiamo, Scala NON ha affatto la parola chiave “static”. Questa è una decisione di design presa dal Team di Scala. La ragione principale di questa decisione è quella di rendere Scala un linguaggio di programmazione puramente orientato agli oggetti. La parola chiave “static” significa che possiamo accedere ai membri di una classe senza creare un oggetto o senza utilizzare un oggetto. Questo è completamente contrario ai principi della programmazione orientata agli oggetti. Se un linguaggio supporta la parola chiave “static”, allora quel linguaggio non è un linguaggio di programmazione puramente orientato agli oggetti. Ad esempio, Java supporta la parola chiave “static”, quindi non è un linguaggio di programmazione puramente orientato agli oggetti. Ma Scala è un linguaggio di programmazione puramente orientato agli oggetti.

Qual è l’utilizzo della parola chiave “object” in Scala? Come creare oggetti Singleton in Scala?

In Scala, la parola chiave “object” viene utilizzata per i seguenti scopi:

• Viene utilizzata per creare un oggetto Singleton in Scala.

object MySingletonObject

Qui, MySingletonObject diventa automaticamente un oggetto Singleton.- La parola chiave “object” viene utilizzata per definire applicazioni Scala che sono programmi eseguibili in Scala.

object MyScalaExecutableProgram{   
   def main(args: Array[String]){
       println("Hello World")
   }
}

Quando definiamo il metodo main nell’oggetto come mostrato sopra (è lo stesso del metodo main() in Java), diventa automaticamente un programma eseguibile in Scala.- Viene utilizzata per definire membri statici come variabili statiche e metodi statici senza utilizzare la parola chiave “static”.

object MyScalaStaticMembers{ 
  val PI: Double = 3.1414  
  def add(a: Int, b: Int) = a + b
}

La variabile di def PI e i metodi add diventeranno membri statici. Ciò significa che possiamo chiamarli senza creare un oggetto separato come MyScalaStaticMembers.add(10,20).- Viene utilizzato per definire i metodi di Factory. Si prega di vedere la mia prossima domanda in merito.

Come definire i metodi di Factory utilizzando la parola chiave object in Scala? Qual è l’utilizzo della definizione dei metodi di Factory in object?

In Scala, utilizziamo la parola chiave ‘object’ per definire i metodi di Factory. Lo scopo principale di questi metodi di Factory in Scala è evitare l’utilizzo della parola chiave ‘new’. Senza utilizzare la parola chiave ‘new’ possiamo creare oggetti. Per definire i metodi di Factory: Possiamo utilizzare il metodo apply per definire i metodi di Factory in Scala. Se abbiamo un costruttore primario e più costruttori ausiliari, allora dobbiamo definire più metodi apply come mostrato di seguito.

class Person(val firstName: String, val middleName: String, val lastName: String){
  def this(firstName: String, lastName: String){
    this(firstName,"",lastName)
  }
}
object Person{
  def apply(val firstName: String, val middleName: String, val lastName: String) 
        = new Person(firstName,middleName,lastName)

  def apply(val firstName: String, val lastName: String) 
        = new Person(firstName, lastName)
}

Ora possiamo creare oggetti Person senza utilizzare la parola chiave new o con la parola chiave new a tua scelta.

val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")

Cosa è il metodo apply in Scala? Cosa è il metodo unapply in Scala? Qual è la differenza tra i metodi apply e unapply in Scala?

In Scala, i metodi apply e unapply svolgono un ruolo molto importante. Sono anche molto utili nel framework Play per il mappaggio e lo smappaggio dei dati tra i dati del modulo e i dati del modello. In parole semplici,

• metodo apply: Per comporre o assemblare un oggetto dai suoi componenti.
• metodo unapply: Per decomporre o smontare un oggetto nei suoi componenti.

Metodo apply di Scala: Viene utilizzato per comporre un oggetto utilizzando i suoi componenti. Supponiamo che vogliamo creare un oggetto Person, quindi utilizziamo i due componenti firstName e laststName e componiamo l’oggetto Person come mostrato di seguito.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)
}

Metodo unapply di Scala: Viene utilizzato per decomporre un oggetto nei suoi componenti. Segue il processo inverso del metodo apply. Supponiamo di avere un oggetto Person, quindi possiamo decomporre questo oggetto nei suoi due componenti: firstName e laststName come mostrato di seguito.

class Person(val firstName: String, val lastName: String)

object Person{
  def apply(firstName: String, lastName: String) 
        = new Person(firstName, lastName)

    def unapply(p: Person): (String,String) 
        = (p.firstName, p.lastName)
}

Come funziona internamente, quando creiamo un’istanza di una classe senza utilizzare la parola chiave ‘new’ in Scala? Quando adottiamo questo approccio? Come dichiarare costruttori privati in Scala?

In Scala, quando creiamo un’istanza di una classe senza utilizzare la parola chiave ‘new’, internamente viene effettuata una chiamata al metodo apply appropriato disponibile nell’oggetto Companion. Qui per “metodo apply appropriato” si intende quello che corrisponde ai parametri. Quando scegliamo questa opzione: Quando abbiamo bisogno di fornire un costruttore privato e vogliamo evitare l’uso della parola chiave ‘new’, possiamo implementare solo il metodo apply con lo stesso insieme di parametri e consentire agli utenti della nostra classe di crearla senza la parola chiave new.

Come dichiariamo un Costruttore Primario privato in Scala? Come effettuiamo una chiamata a un Costruttore Primario privato in Scala?

In Scala, possiamo dichiarare facilmente un Costruttore Primario privato. Basta definire un Costruttore Primario come al solito e aggiungere ‘private’ subito dopo il nome della classe e prima della lista dei parametri come mostrato di seguito:

class Person private (name: String)
object Person{
 def apply(name: String) = new Person(name)
}

Essendo un costruttore privato, non possiamo chiamarlo dall’esterno. Dovremmo fornire un metodo di fabbrica (ovvero un metodo apply) come mostrato sopra e utilizzare indirettamente quel costruttore.

Un oggetto Compagno può accedere ai membri privati della sua classe Compagna in Scala?

In generale, i membri privati sono accessibili solo all’interno della classe stessa. Tuttavia, in Scala la classe Compagna e l’oggetto Compagno offrono un’altra caratteristica. In Scala, un oggetto Compagno può accedere ai membri privati della sua classe Compagna e la classe Compagna può accedere ai membri privati dell’oggetto Compagno.

Qual è la decisione di progetto principale riguardo alle due parole chiave separate: class e object in Scala? Come definiamo i membri dell’istanza e i membri statici in Scala?

In Scala, utilizziamo la parola chiave class per definire i membri dell’istanza e la parola chiave object per definire i membri statici. Scala non ha la parola chiave static, ma comunque possiamo definirli utilizzando la parola chiave object. La decisione di progetto principale riguardo a questo è la chiara separazione tra i membri dell’istanza e i membri statici. Un accoppiamento lento tra di loro. E un’altra ragione importante è evitare la parola chiave static in modo che Scala diventi un linguaggio di programmazione puramente orientato agli oggetti.

Cos’è un oggetto in Scala? È un oggetto singleton o un’istanza di una classe?

A differenza di Java, Scala ha due significati per la parola ‘oggetto’. Non confonderti, spiegherò chiaramente. In Java, abbiamo un solo significato per oggetto che è “Un’istanza di una classe”.

• Come in Java, il primo significato di oggetto è “Un’istanza di una classe”.

val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")

• Il secondo significato è che object è una parola chiave in Scala. Viene utilizzata per definire programmi eseguibili in Scala, oggetti Companion, oggetti Singleton, ecc.

Cosa è un oggetto Companion in Scala? Cosa è una classe Companion in Scala? Qual è l’uso dell’oggetto Companion in Scala?

In parole semplici, se una classe Scala e un oggetto condividono lo stesso nome e sono definiti nello stesso file sorgente, allora quella classe è conosciuta come “Classe Companion” e quell’oggetto è conosciuto come “Oggetto Companion”. Quando creiamo una classe utilizzando la parola chiave “class” di Scala e un oggetto utilizzando la parola chiave “object” di Scala con lo stesso nome e nello stesso file sorgente, allora quella classe è conosciuta come “Classe Companion” e quell’oggetto è conosciuto come “Oggetto Companion”. Esempio: – Employee.scala

class Employee{ }
object Employee{ }

In Scala, il principale scopo dell’Oggetto Companion è definire i metodi apply e evitare di utilizzare la parola chiave new nella creazione di un’istanza di quell’oggetto di classe Companion.

Come implementare le interfacce in Scala?

Come sappiamo dall’ambiente Java, utilizziamo l’interfaccia per definire un contratto. Tuttavia, in Scala non esiste il concetto di interfaccia. Scala utilizza un concetto più potente e flessibile chiamato “trait” per questo scopo.

Cosa è una Range in Scala? Come si crea una Range in Scala?

Una Range è una collezione lazy in Scala. Range è una classe disponibile nel pacchetto ‘scala’, come ‘scala.Range’. Viene utilizzata per rappresentare una sequenza di valori interi. È una sequenza ordinata di interi. Esempio:

scala> 1 to 10
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> 1 until 10
res1: scala.collection.immutable.Range = Range(1, 2, 3, 4, 5, 6, 7, 8, 9)

Quanti valori di tipo Nothing ci sono in Scala?

In Scala, il tipo Nothing non ha valori, quindi sono zero. Non ha alcun valore. È un sottotipo di tutte le classi di valore e di riferimento.

Quanti valori di tipo Unit ci sono in Scala?

In Scala, Unit è qualcosa di simile alla parola chiave void di Java. Viene utilizzato per rappresentare “Nessun valore esiste”. Ha un solo valore che è ().

Cosa si intende per funzione pura?

A pure function is a function without any observable side-effects. That means it returns always same results irrespective how many times we call it with same inputs. A pure function always gives same output for the same inputs. For Example:-

scala> 10 + 20
res0: Int = 30
scala>
scala> 10 + 20
res0: Int = 30

Qui “+” è una funzione pura disponibile nella classe Int. Restituisce sempre lo stesso risultato, 30, per gli stessi input 10 e 30, indipendentemente da quante volte viene chiamata.

Nella programmazione funzionale, qual è la differenza tra una funzione e una procedura?

Entrambi vengono utilizzati per eseguire un calcolo, tuttavia hanno una differenza importante nel mondo della programmazione funzionale. Una funzione è un’unità di calcolo senza effetti collaterali, mentre una procedura è anche un’unità di calcolo con effetti collaterali.

Quali sono le principali differenze tra i costruttori ausiliari di Scala e i costruttori di Java?

Il costruttore ausiliario di Scala è quasi simile al costruttore di Java con alcune differenze. Rispetto ai costruttori di Java, i costruttori ausiliari hanno le seguenti poche differenze:

• I costruttori ausiliari vengono chiamati utilizzando la parola chiave “this”.
• Tutti i costruttori ausiliari sono definiti con lo stesso nome, che è “this”. In Java, utilizziamo il nome della classe per definire i costruttori.
• Ogni costruttore ausiliario deve iniziare con una chiamata a un costruttore ausiliario precedentemente definito o al costruttore principale.
• Utilizziamo la parola chiave ‘def’ per definire i costruttori ausiliari, come la definizione di una funzione/metodo. In Java, la definizione del costruttore e la definizione del metodo sono diverse.

Qual è l’uso della parola chiave ‘yield’ nella costruzione di for-comprehension di Scala?

Possiamo utilizzare la parola chiave ‘yield’ nella costruzione di for-comprehension di Scala. ‘for/yield’ viene utilizzato per iterare una collezione di elementi e generare una nuova collezione dello stesso tipo. Non modifica la collezione originale. Genera una nuova collezione dello stesso tipo della collezione originale. Ad esempio, se utilizziamo la costruzione ‘for/yield’ per iterare una List, genera solo una nuova List.

scala> val list = List(1,2,3,4,5)
list: List[Int] = List(1, 2, 3, 4, 5)

scala> for(l <- list) yield l*2
res0: List[Int] = List(2, 4, 6, 8, 10)

Cos’è la guardia nella costruzione for-comprehension di Scala?

In Scala, la costruzione for-comprehension ha una clausola if che viene utilizzata per scrivere una condizione per filtrare alcuni elementi e generare una nuova collezione. Questa clausola if è anche conosciuta come “guardia”. Se la guardia è vera, allora viene aggiunto quell’elemento alla nuova collezione. Altrimenti, quell’elemento non viene aggiunto alla collezione originale. Esempio:- Guardia for-comprehension per generare solo numeri pari in una nuova collezione.

scala> val list = List(1,2,3,4,5,6,7,8,9,10)
list: List[Int] = List(1, 2, 3, 4, 5 , 6 , 7 , 8 , 9 , 10)

scala> for(l <- list if l % 2 =0 ) yield l
res0: List[Int] = List(2, 4, 6, 8, 10)

Come Scala risolve automaticamente e facilmente il problema del diamante di ereditarietà rispetto a Java 8?

Se utilizziamo le interfacce di Java 8 con i metodi predefiniti, otterremo il problema del diamante di ereditarietà. Lo sviluppatore deve risolverlo manualmente in Java 8. Non fornisce una risoluzione predefinita o automatica per questo problema. In Scala, otterremo lo stesso problema con i trait, ma Scala è molto intelligente e risolve automaticamente il problema del diamante di ereditarietà utilizzando il concetto di linearizzazione delle classi.

In Scala, il Pattern Matching segue quale Design Pattern? In Java, l’operatore ‘isinstanceof’ segue quale Design Pattern?

In Scala, il Pattern Matching segue il Design Pattern Visitor. Allo stesso modo, l’operatore ‘isinstanceof’ di Java segue anche il Design Pattern Visitor. Questo è tutto riguardo alle “Domande e Risposte intermedie di Scala”. Discuteremo alcune domande e risposte avanzate di Scala nei miei prossimi post. Per favore, lasciami un commento se ti è piaciuto il mio post o se hai qualche problema/suggerimento.