Questions d’entretien Scala

Tutoriels

Scala

Avant de lire ce post, veuillez consulter mon post précédent sur « Scala Basic Interview Questions and Answers » pour acquérir des connaissances de base sur le langage Scala. Dans ce post, nous allons discuter de quelques questions d’entretien supplémentaires sur Scala qui sont utiles pour les développeurs Scala expérimentés. Note :- Comme cette liste est déjà devenue très longue, je vais publier un autre post avec les questions et réponses restantes. Veuillez vous référer à ce post à l’adresse : « Scala Intermediate and Advanced Interview Questions and Answers«

Scala Interview Questions

Dans cette section, nous allons répertorier toutes les questions d’entretien intermédiaires Scala, et dans la section suivante, nous les discuterons en détail.

Qu’est-ce que le constructeur principal ? Qu’est-ce que le constructeur secondaire ou auxiliaire en Scala ?
Quelle est l’utilité des constructeurs auxiliaires en Scala ? Veuillez expliquer les règles à suivre pour définir des constructeurs auxiliaires en Scala.
Quelles sont les différences entre Array et ArrayBuffer en Scala ?
Qu’est-ce qu’une classe case ? Qu’est-ce qu’un objet case ? Quels sont les avantages d’une classe case ?
Quelle est la différence entre Case Object et Object (Objet normal) ?
Quand on compare à la classe normale, quelles sont les principales avantages ou bénéfices d’une Case Class?
Quelle est l’utilisation des méthodes isInstanceOf et asInstanceOf en Scala? Existe-t-il un concept similaire en Java?
Comment prouver que par défaut, un objet Case est sérialisable tandis qu’un objet normal ne l’est pas?
Quelle est la différence entre un Array et une List en Scala?
Quelle est la différence entre « val » et « lazy val » en Scala? Qu’est-ce que l’évaluation Eager? Qu’est-ce que l’évaluation Lazy?
Quelle est la relation entre la méthode equals et == en Scala? Différenciez le == de Scala de l’opérateur == de Java?
Différence entre la classe interne de Scala et la classe interne de Java?
Qu’est-ce que le problème du Diamant? Comment Scala résout-il le problème du Diamant?
Pourquoi Scala n’a-t-il PAS le mot-clé « static »? Quelle est la principale raison de cette décision?
Quelle est l’utilité du mot-clé « object » en Scala? Comment créer des objets Singleton en Scala?
Comment définir des méthodes de fabrique en utilisant le mot-clé object en Scala? Quelle est l’utilité de définir des méthodes de fabrique dans un objet?
Qu’est-ce que la méthode apply en Scala? Qu’est-ce que la méthode unapply en Scala? Quelle est la différence entre les méthodes apply et unapply en Scala?
Comment cela fonctionne-t-il sous le capot lorsque nous créons une instance d’une classe sans utiliser le mot-clé ‘new’ en Scala? Quand optons-nous pour cette approche?
Comment déclarer un constructeur primaire privé en Scala? Comment faire appel à un constructeur primaire privé en Scala?
Est-ce qu’un objet compagnon accède aux membres privés de sa classe Compagnon en Scala?
Quelle est la principale décision de conception concernant les deux mots-clés distincts: classe et objet en Scala? Comment définissons-nous les membres d’instance et les membres statiques en Scala?
Qu’est-ce qu’un objet en Scala? Est-ce un objet singleton ou une instance d’une classe?
Qu’est-ce qu’un objet compagnon en Scala? Qu’est-ce qu’une classe compagnon en Scala? Quel est l’usage de l’objet compagnon en Scala?
Comment implémenter des interfaces en Scala?
Qu’est-ce qu’une plage (Range) en Scala? Comment créer une plage en Scala?
Combien de valeurs du type Rien (Nothing) existent en Scala?
Combien de valeurs du type Unit existent en Scala?
Qu’est-ce qu’une plage (Range) en Scala? Comment créer une plage en Scala?
Dans la programmation fonctionnelle, quelle est la différence entre une fonction et une procédure?
Quelles sont les principales différences entre les constructeurs auxiliaires de Scala et les constructeurs de Java?
Quel est l’usage du mot-clé ‘yield’ dans la construction de for-compréhension de Scala?
Qu’est-ce qu’une garde (guard) dans la construction de for-compréhension de Scala?
Comment Scala résout-il automatiquement et facilement le problème du diamant d’héritage par rapport à Java 8?
En Scala, le motif de correspondance suit quel motif de conception? En Java, l’opérateur ‘instanceof’ suit quel motif de conception?

Questions et réponses d’entretien Scala

Dans cette section, nous aborderons chaque question de la liste ci-dessus et discuterons en détail avec des exemples appropriés (si nécessaire). Si vous souhaitez comprendre ces concepts en profondeur avec des exemples, veuillez consulter mes publications précédentes dans la section Tutoriels Scala.

Qu’est-ce qu’un constructeur principal ? Qu’est-ce qu’un constructeur secondaire ou auxiliaire en Scala ? Quel est le but du constructeur auxiliaire en Scala ? Est-il possible de surcharger les constructeurs en Scala ?

Scala a deux types de constructeurs :

Constructeur principal
Constructeur auxiliaire

Constructeur principal En Scala, le constructeur principal est un constructeur qui est défini avec la classe elle-même. Chaque classe doit avoir un constructeur principal : soit un constructeur avec paramètres, soit un constructeur sans paramètres. Exemple : –

class Person

La classe Personne ci-dessus a un constructeur principal sans paramètre ou sans paramètre ou sans paramètre pour créer des instances de cette classe.

class Person (firstName: String, lastName: String)

La classe Personne ci-dessus a un constructeur principal à deux paramètres pour créer des instances de cette classe. Constructeur auxiliaire Le constructeur auxiliaire est également connu sous le nom de constructeur secondaire. Nous pouvons déclarer un constructeur secondaire en utilisant les mots clés ‘def’ et ‘this’ comme indiqué ci-dessous :

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

Quel est l’usage des constructeurs auxiliaires en Scala ? Veuillez expliquer les règles à suivre pour définir des constructeurs auxiliaires en Scala.

En Scala, le but principal des constructeurs auxiliaires est de surcharger les constructeurs. Comme en Java, nous pouvons fournir différents types de constructeurs afin que l’utilisateur puisse choisir le bon en fonction de ses besoins. Règles des constructeurs auxiliaires :

Ils sont comme des méthodes. Comme les méthodes, nous devrions utiliser le mot clé ‘def’ pour les définir.
Nous devrions utiliser le même nom ‘this’ pour tous les constructeurs auxiliaires.
Chaque constructeur auxiliaire devrait commencer par un appel à un autre constructeur auxiliaire précédemment défini ou au constructeur principal. Sinon, une erreur de compilation.
Chaque constructeur auxiliaire devrait différer avec sa liste de paramètres : que ce soit par le nombre ou les types.
Les constructeurs auxiliaires ne peuvent pas appeler les constructeurs de la super classe. Ils devraient les appeler uniquement à travers le constructeur principal.
Tous les constructeurs auxiliaires appellent leur constructeur principal soit directement, soit indirectement à travers d’autres constructeurs auxiliaires.

NOTE :- Si vous voulez en savoir plus sur les constructeurs Scala, veuillez consulter mes articles Scala sur : Constructeur Principal et Constructeur Auxiliaire.

Quelles sont les différences entre Array et ArrayBuffer en Scala ?

Différences entre Array et ArrayBuffer en Scala :

Array est un tableau de taille fixe. On ne peut pas changer sa taille une fois créé.
ArrayBuffer est un tableau de taille variable. On peut augmenter ou diminuer sa taille dynamiquement.
Array est quelque chose de similaire aux tableaux primitifs de Java.
ArrayBuffer est quelque chose de similaire à ArrayList de Java.

Qu’est-ce qu’une classe de cas? Qu’est-ce qu’un objet de cas? Quels sont les avantages d’une classe de cas?

Une classe de cas est une classe définie avec les mots-clés « case class ». Un objet de cas est un objet défini avec les mots-clés « case object ». Grâce à ce mot-clé « case », nous obtiendrons certains avantages pour éviter le code redondant. Nous pouvons créer des objets de classe de cas sans utiliser le mot-clé « new ». Par défaut, le compilateur Scala préfixe « val » pour tous les paramètres du constructeur. C’est pourquoi, sans utiliser val ou var, les paramètres du constructeur de la classe de cas deviendront des membres de la classe, ce qui n’est pas possible pour les classes normales. Avantages d’une classe de cas:

Par défaut, le compilateur Scala ajoute les méthodes toString, hashCode et equals. Nous pouvons éviter d’écrire ce code redondant.
Par défaut, le compilateur Scala ajoute un objet compagnon avec les méthodes apply et unapply, c’est pourquoi nous n’avons pas besoin du mot-clé new pour créer des instances d’une classe de cas.
Par défaut, le compilateur Scala ajoute également la méthode copy.
Nous pouvons utiliser des classes de cas dans les motifs de correspondance.
Par défaut, les classes de cas et les objets de cas sont sérialisables.

Quelle est la différence entre un objet Case et un objet (objet normal)?

Un objet normal est créé en utilisant le mot-clé « object ». Par défaut, c’est un objet singleton.

object MyNormalObject

Un objet Case est créé en utilisant le mot-clé « case object ». Par défaut, c’est également un objet singleton

case object MyCaseObject

Par défaut, un objet Case obtient les méthodes toString et hashCode. Mais un objet normal ne le peut pas.
Par défaut, un objet Case est Serializable. Mais un objet normal ne l’est pas.

Comparé à une classe normale, quels sont les principaux avantages ou bénéfices d’une classe Case?

Voici les principaux avantages ou bénéfices d’une classe Case par rapport aux classes normales:

Évite beaucoup de code boilerplate en ajoutant automatiquement certaines méthodes utiles.
Par défaut, supporte l’immuabilité car ses paramètres sont des ‘val’.
Facile à utiliser dans la correspondance de motifs.
Pas besoin d’utiliser le mot-clé ‘new’ pour créer une instance de classe Case.
Par défaut, prend en charge la sérialisation et la désérialisation.

Quelle est l’utilisation des méthodes isInstanceOf et asInstanceOf en Scala ? Existe-t-il un concept similaire disponible en Java ?

Les méthodes isInstanceOf et asInstanceOf sont toutes deux définies dans la classe Any. Il n’est donc pas nécessaire de les importer pour obtenir ces méthodes dans une classe ou un objet quelconque. La méthode « isInstanceOf » est utilisée pour tester si l’objet est d’un type donné ou non. Si c’est le cas, elle renvoie true. Sinon, elle renvoie false.

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

La méthode « asInstanceOf » est utilisée pour convertir l’objet en un type donné. Si l’objet donné et le type sont du même type, alors il est converti en le type donné. Sinon, il lance java.lang.ClassCastException.

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

En Java, le mot-clé ‘instanceof’ est similaire à la méthode ‘isInstanceOf’ de Scala. En Java, le type de conversion manuelle suivant est similaire à la méthode ‘asInstanceOf’ de Scala.

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

Comment prouver que par défaut, l’objet Case est Serializable et l’objet Normal ne l’est pas ?

Oui, par défaut, l’objet Case est Serializable. Mais l’objet normal ne l’est pas. Nous pouvons le prouver en utilisant la méthode isInstanceOf comme indiqué ci-dessous:

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

Différence entre Array et List en Scala?

Les tableaux sont toujours mutables tandis que les listes sont toujours immuables.
Une fois créées, nous pouvons modifier les valeurs du tableau tandis que nous ne pouvons pas modifier l’objet List.
Les tableaux sont des structures de données de taille fixe tandis que les listes sont des structures de données de taille variable. La taille de la liste est automatiquement augmentée ou diminuée en fonction des opérations que nous effectuons dessus.
Les tableaux sont invariants tandis que les listes sont covariantes.

REMARQUE: – Si vous n’êtes pas sûr de ce qu’est l’invariant et le covariant, veuillez lire ma prochaine publication sur les questions d’entretien Scala.

Quelle est la différence entre « val » et « lazy val » en Scala? Qu’est-ce que l’évaluation Eager? Qu’est-ce que l’évaluation Lazy?

Comme nous l’avons discuté dans mes questions d’entretien Scala de base, « val » signifie valeur ou constante qui est utilisée pour définir des variables immuables. Il existe deux types d’évaluations de programme:

Évaluation impatiente
Évaluation paresseuse

L’évaluation impatiente signifie évaluer le programme au moment de la compilation ou du déploiement, quel que soit l’usage que les clients font de ce programme. L’évaluation paresseuse signifie évaluer le programme au moment de l’exécution à la demande, c’est-à-dire lorsque les clients accèdent au programme, alors seulement il est évalué. La différence entre « val » et « lazy val » est que « val » est utilisé pour définir des variables qui sont évaluées de manière impatiente et « lazy val » est également utilisé pour définir des variables mais elles sont évaluées de manière paresseuse.

Quelle est la relation entre la méthode equals et == en Scala ? Faites la différence entre == de Scala et l’opérateur == de Java ?

En Scala, nous n’avons pas besoin d’appeler la méthode equals() pour comparer deux instances ou objets. Lorsque nous comparons deux instances avec ==, Scala appelle automatiquement la méthode equals() de cet objet. L’opérateur == de Java est utilisé pour vérifier l’égalité des références, c’est-à-dire si deux références pointent vers le même objet ou non. == de Scala est utilisé pour vérifier l’égalité des instances, c’est-à-dire si deux instances sont égales ou non.

Différence entre la classe interne de Scala et la classe interne de Java?

En Java, la classe interne est associée à la classe externe, c’est-à-dire que la classe interne est un membre de la classe externe. Contrairement à Java, Scala traite la relation entre la classe externe et la classe interne différemment. La classe interne de Scala est associée à l’objet de la classe externe.

Qu’est-ce que le problème du diamant? Comment Scala résout-il le problème du diamant?

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
}

Ici, la sortie est « From C.display » du trait C. Le compilateur Scala lit « extends B with C » de droite à gauche et prend la définition de la méthode « display » du trait le plus à gauche, c’est-à-dire C. NOTE:- Consultez mon article sur « Scala Traits in Depth » pour comprendre cela avec une explication claire.

Pourquoi Scala n’a-t-il PAS le mot clé « static »? Quelle est la principale raison de cette décision?

Comme nous le savons, Scala n’a PAS du tout le mot clé « static ». Il s’agit d’une décision de conception prise par l’équipe Scala. La principale raison de cette décision est de faire de Scala un langage orienté objet pur. Le mot clé « static » signifie que nous pouvons accéder aux membres de cette classe sans créer d’objet ou sans utiliser un objet, ce qui va à l’encontre des principes de la POO. Si un langage prend en charge le mot clé « static », alors ce langage n’est pas un langage orienté objet pur. Par exemple, comme Java prend en charge le mot clé « static », ce n’est pas un langage orienté objet pur. Mais Scala est un langage orienté objet pur.

Quel est l’usage du mot clé « object » en Scala? Comment créer des objets Singleton en Scala?

En Scala, le mot clé « object » est utilisé à des fins diverses :

Il est utilisé pour créer un objet singleton en Scala.

object MySingletonObject

Ici, MySingletonObject devient automatiquement un objet singleton.- Le mot clé « object » est utilisé pour définir des applications Scala, c’est-à-dire des programmes Scala exécutables.

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

Lorsque nous définissons une méthode principale dans un objet comme indiqué ci-dessus (c’est la même chose que la méthode main() en Java), cela devient automatiquement un programme Scala exécutable.- Il est utilisé pour définir des membres statiques tels que des variables statiques et des méthodes statiques sans utiliser le mot clé ‘static’.

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

Par défaut, la variable PI et les méthodes add deviendront des membres statiques. Cela signifie que nous pouvons les appeler sans créer d’objet séparé, comme MyScalaStaticMembers.add(10,20).- Il est utilisé pour définir des méthodes de fabrique. Veuillez consulter ma prochaine question à ce sujet.

Comment définir des méthodes de fabrique en utilisant le mot-clé object en Scala? Quel est l’intérêt de définir des méthodes de fabrique dans un object?

En Scala, nous utilisons le mot-clé ‘object’ pour définir des méthodes de fabrique. Le but principal de ces méthodes de fabrique en Scala est d’éviter l’utilisation du mot-clé ‘new’. Sans utiliser le mot-clé ‘new’, nous pouvons créer des objets. Pour définir des méthodes de fabrique: Nous pouvons utiliser la méthode apply pour définir des méthodes de fabrique en Scala. Si nous avons un constructeur principal et plusieurs constructeurs auxiliaires, nous devons définir plusieurs méthodes apply comme indiqué ci-dessous.

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)
}

Maintenant, nous pouvons créer des objets Person sans utiliser le mot-clé new, ou avec le mot-clé new selon votre préférence.

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

Qu’est-ce que la méthode apply en Scala ? Qu’est-ce que la méthode unapply en Scala ? Quelle est la différence entre les méthodes apply et unapply en Scala ?

En Scala, les méthodes apply et unapply jouent un rôle très important. Elles sont également très utiles dans le framework Play pour mapper et désassembler les données entre les données de formulaire et les données de modèle. En termes simples,

la méthode apply : Pour composer ou assembler un objet à partir de ses composants.
la méthode unapply : Pour décomposer ou désassembler un objet en ses composants.

La méthode apply de Scala : Elle est utilisée pour composer un objet en utilisant ses composants. Supposons que nous voulions créer un objet Personne, alors nous utilisons les deux composants prénom et nom de famille pour composer l’objet Personne comme indiqué ci-dessous.

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

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

La méthode unapply de Scala : Elle est utilisée pour décomposer un objet en ses composants. Elle suit le processus inverse de la méthode apply. Supposons que nous ayons un objet Personne, alors nous pouvons décomposer cet objet en ses deux composants : prénom et nom de famille comme indiqué ci-dessous.

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)
}

Comment cela fonctionne-t-il sous le capot, lorsque nous créons une instance d’une Classe sans utiliser le mot-clé ‘new’ en Scala ? Quand optons-nous pour cette approche ? Comment déclarer des constructeurs privés en Scala ?

En Scala, lorsque nous créons une instance d’une Classe sans utiliser le mot-clé ‘new’, en interne, cela fait appel à la méthode apply appropriée disponible dans l’objet Compagnon. Ici, méthode apply appropriée signifie celle qui correspond aux paramètres. Quand choisissons-nous cette option : Lorsque nous avons besoin de fournir un constructeur privé et que nous avons besoin d’éviter d’utiliser le mot-clé ‘new’, nous pouvons implémenter uniquement la méthode apply avec le même ensemble de paramètres et permettre à nos utilisateurs de classe de le créer sans le mot-clé new.

Comment déclarer un constructeur principal privé en Scala ? Comment appeler un constructeur principal privé en Scala ?

En Scala, nous pouvons déclarer très facilement un constructeur principal privé. Il suffit de définir un constructeur principal comme il est et d’ajouter ‘private’ juste après le nom de la classe et avant la liste des paramètres comme indiqué ci-dessous :

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

Comme c’est un constructeur privé, nous ne pouvons pas l’appeler depuis l’extérieur. Nous devrions fournir une méthode de fabrique (c’est-à-dire une méthode apply) comme indiqué ci-dessus et utiliser ce constructeur indirectement.

Un objet compagnon accède-t-il aux membres privés de sa classe compagnon en Scala ?

Généralement, les membres privés signifient accessibles uniquement à l’intérieur de cette classe. Cependant, la classe compagnon et l’objet compagnon de Scala ont fourni une autre fonctionnalité. En Scala, un objet compagnon peut accéder aux membres privés de sa classe compagnon et la classe compagnon peut accéder aux membres privés de son objet compagnon.

Quelle est la décision de conception principale concernant deux mots-clés séparés : class et object en Scala ? Comment définissons-nous les membres d’instance et les membres statiques en Scala ?

En Scala, nous utilisons le mot-clé class pour définir les membres d’instance et le mot-clé object pour définir les membres statiques. Scala n’a pas de mot-clé static, mais nous pouvons toujours les définir en utilisant le mot-clé object. La principale décision de conception à ce sujet est la claire séparation entre les membres d’instance et les membres statiques. Un couplage lâche entre eux. Et une autre raison majeure est d’éviter le mot-clé static afin que Scala devienne un langage purement orienté objet.

Qu’est-ce qu’un objet en Scala ? Est-ce un objet singleton ou une instance d’une classe ?

Contrairement à Java, Scala a deux significations pour ‘object’. Ne vous confondez pas à ce sujet, je vais l’expliquer clairement. En Java, nous n’avons qu’une seule signification pour objet, qui est « Une instance d’une classe ».

Tout comme Java, la première signification de objet est « Une instance d’une classe ».

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

La deuxième signification est que « object » est un mot-clé en Scala. Il est utilisé pour définir des programmes exécutables Scala, des objets compagnons, des objets singleton, etc.

Qu’est-ce qu’un objet compagnon en Scala ? Qu’est-ce qu’une classe compagnon en Scala ? À quoi sert un objet compagnon en Scala ?

En termes simples, si une classe Scala et un objet partagent le même nom et sont définis dans le même fichier source, alors cette classe est appelée « Classe Compagnon » et cet objet est appelé « Objet Compagnon ». Lorsque nous créons une classe en utilisant le mot-clé Scala « class » et un objet en utilisant le mot-clé Scala « object » avec le même nom et dans le même fichier source, alors cette classe est appelée « Classe Compagnon » et cet objet est appelé « Objet Compagnon ». Exemple : Employee.scala

class Employee{ }
object Employee{ }

En Scala, l’objectif principal de l’objet compagnon est de définir des méthodes apply et d’éviter l’utilisation du mot-clé new lors de la création d’une instance de cette classe compagnon.

Comment implémenter des interfaces en Scala ?

Comme nous le savons du contexte Java, nous utilisons une interface pour définir un contrat. Cependant, Scala n’a pas de concept d’interface ni de mot-clé interface. À la place, Scala propose un concept plus puissant et flexible, à savoir le « trait », à cette fin.

Qu’est-ce qu’une Range en Scala ? Comment créer une Range en Scala ?

Une Range est une collection paresseuse en Scala. Elle est représentée par une classe disponible dans le package ‘scala’, appelée ‘scala.Range’. Elle est utilisée pour représenter une séquence de valeurs entières, formant une séquence ordonnée d’entiers. Exemple :-

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)

Combien de valeurs du type Nothing existent-elles en Scala ?

En Scala, le type Nothing n’a aucune valeur, c’est-à-dire zéro. Il ne possède aucune valeur et est un sous-type de toutes les classes de valeurs et de références.

Combien de valeurs du type Unit existent-elles en Scala ?

En Scala, Unit est quelque chose de similaire au mot clé void de Java. Il est utilisé pour représenter « Aucune valeur n’existe ». Il a une et une seule valeur qui est ().

Qu’est-ce qu’une fonction pure?

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

Ici, « + » est une fonction pure disponible dans la classe Int. Elle donne le même résultat 30 pour les mêmes entrées 10 et 30, peu importe le nombre de fois où nous l’appelons.

En FP, quelle est la différence entre une fonction et une procédure?

Les deux sont utilisés pour effectuer des calculs, cependant ils ont une différence majeure dans le monde de la programmation fonctionnelle. Une fonction est une unité de calcul sans effet secondaire tandis qu’une procédure est également une unité de calcul avec des effets secondaires.

Quelles sont les principales différences entre les constructeurs auxiliaires de Scala et les constructeurs de Java?

Le constructeur auxiliaire de Scala est presque similaire au constructeur de Java avec quelques différences. Par rapport aux constructeurs de Java, les constructeurs auxiliaires présentent les quelques différences suivantes :

Les constructeurs auxiliaires sont appelés en utilisant le mot-clé « this ».
Tous les constructeurs auxiliaires sont définis avec le même nom, c’est-à-dire « this ». En Java, nous utilisons le nom de la classe pour définir les constructeurs.
Chaque constructeur auxiliaire doit commencer par un appel à un constructeur auxiliaire précédemment défini ou au constructeur principal.
Nous utilisons le mot-clé « def » pour définir les constructeurs auxiliaires comme la définition de méthode/fonction. En Java, la définition de constructeur et la définition de méthode sont différentes.

Quelle est l’utilisation du mot-clé « yield » dans la construction de compréhension for de Scala ?

Nous pouvons utiliser le mot-clé « yield » dans la construction de compréhension for de Scala. « for/yield » est utilisé pour itérer une collection d’éléments et génère une nouvelle collection du même type. Il ne change pas la collection originale. Il génère une nouvelle collection du même type que le type de collection original. Par exemple, si nous utilisons la construction « for/yield » pour itérer une liste, alors elle génère une nouvelle liste uniquement.

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)

Qu’est-ce que la garde dans la construction de for-comprehension de Scala ?

En Scala, la construction for-comprehension a une clause if qui est utilisée pour écrire une condition afin de filtrer certains éléments et générer une nouvelle collection. Cette clause if est également connue sous le nom de « Garde ». Si cette garde est vraie, alors ajoutez cet élément à la nouvelle collection. Sinon, n’ajoutez pas cet élément à la collection d’origine. Exemple :- For-comprehension Garde pour générer uniquement des nombres pairs dans une nouvelle collection.

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)

Comment Scala résout-il automatiquement et facilement le problème du diamant d’héritage par rapport à Java 8 ?

Si nous utilisons les méthodes par défaut de l’interface Java 8, nous aurons le problème du diamant d’héritage. Le développeur doit le résoudre manuellement en Java 8. Il ne fournit pas de résolution par défaut ou automatique pour ce problème. En Scala, nous aurons le même problème avec les Traits, mais Scala est très intelligent et résout automatiquement le problème du diamant d’héritage en utilisant le concept de linéarisation de classe.

En Scala, le Pattern Matching suit quel Design Pattern ? En Java, l’opérateur ‘isinstanceof’ suit quel Design Pattern ?

En Scala, le Pattern Matching suit le Design Pattern Visitor. De la même manière, l’opérateur ‘isinstanceof’ de Java suit également le Design Pattern Visitor. C’est tout pour les « Questions et réponses intermédiaires sur Scala ». Nous discuterons de quelques questions et réponses avancées sur Scala dans mes prochains articles. N’hésitez pas à me laisser un commentaire si vous avez aimé mon article ou si vous avez des problèmes/suggestions.

Source:
https://www.digitalocean.com/community/tutorials/scala-interview-questions