Preguntas de entrevista de Scala

Tutoriales
Scala

Antes de leer este post, por favor revisa mi publicación anterior en “Preguntas y respuestas básicas de entrevistas de Scala” para obtener conocimientos básicos sobre el lenguaje Scala. En este post, vamos a discutir algunas preguntas más de entrevistas de Scala que son útiles para desarrolladores experimentados en Scala. Nota:- Dado que esta lista ya es bastante extensa, voy a publicar otro post con las preguntas y respuestas restantes. Por favor, consulta ese post en: “Preguntas y respuestas de entrevistas intermedias y avanzadas de Scala“

Preguntas de entrevista de Scala

En esta sección, vamos a enumerar todas las preguntas de entrevista intermedia de Scala y en la siguiente sección las discutiremos en detalle.

  1. ¿Cuál es el Constructor Principal? ¿Cuál es el Constructor Secundario o Auxiliar en Scala?
  2. ¿Cuál es el uso de los Constructores Auxiliares en Scala? Por favor, explique las reglas a seguir al definir Constructores Auxiliares en Scala.
  3. ¿Cuáles son las diferencias entre Array y ArrayBuffer en Scala?
  4. ¿Qué es una case class? ¿Qué es un case object? ¿Cuáles son las ventajas de una case class?
  5. ¿Cuál es la diferencia entre Case Object y Object (Objeto Normal)?
  6. Cuando se compara con la clase Normal, ¿cuáles son las principales ventajas o beneficios de una Case-class?
  7. ¿Cuál es el uso de los métodos isInstanceOf y asInstanceOf en Scala? ¿Existe algún concepto similar disponible en Java?
  8. ¿Cómo se demuestra que por defecto, un objeto Case es Serializable y un objeto Normal no lo es?
  9. ¿Cuál es la diferencia entre Array y List en Scala?
  10. ¿Cuál es la diferencia entre “val” y “lazy val” en Scala? ¿Qué es la Evaluación Eager? ¿Qué es la Evaluación Lazy?
  11. ¿Cuál es la relación entre el método equals y == en Scala? ¿Diferenciar el == de Scala y el operador == de Java?
  12. ¿Cuál es la diferencia entre la clase interna de Scala y la clase interna de Java?
  13. ¿Qué es el Problema del Diamante? ¿Cómo resuelve Scala el Problema del Diamante?
  14. ¿Por qué Scala NO tiene la palabra clave “static”? ¿Cuál es la razón principal de esta decisión?
  15. ¿Cuál es el uso de la palabra clave “object” en Scala? ¿Cómo crear objetos Singleton en Scala?
  16. ¿Cómo definir métodos de fábrica utilizando la palabra clave object en Scala? ¿Cuál es el uso de definir métodos de fábrica en object?
  17. ¿Qué es el método apply en Scala? ¿Qué es el método unapply en Scala? ¿Cuál es la diferencia entre los métodos apply y unapply en Scala?
  18. ¿Cómo funciona bajo el capó, cuando creamos una instancia de una Clase sin usar la palabra clave ‘new’ en Scala? ¿Cuándo optamos por este enfoque?
  19. ¿Cómo declaramos un Constructor Primario privado en Scala? ¿Cómo hacemos una llamada a un Constructor Primario privado en Scala?
  20. ¿Accede un objeto Companion a los miembros privados de su clase Companion en Scala?
  21. ¿Cuál es la decisión de diseño principal sobre dos palabras clave separadas: class y object en Scala? ¿Cómo definimos miembros de instancia y miembros estáticos en Scala?
  22. ¿Qué es un objeto en Scala? ¿Es un objeto singleton o una instancia de una clase?
  23. ¿Qué es un Objeto Compañero en Scala? ¿Qué es una Clase Compañera en Scala? ¿Cuál es el uso del Objeto Compañero en Scala?
  24. ¿Cómo se implementan interfaces en Scala?
  25. ¿Qué es un Rango en Scala? ¿Cómo se crea un Rango en Scala?
  26. ¿Cuántos valores del tipo Nothing existen en Scala?
  27. ¿Cuántos valores del tipo Unit existen en Scala?
  28. ¿Qué es un Rango en Scala? ¿Cómo se crea un Rango en Scala?
  29. En FP, ¿Cuál es la diferencia entre una función y un procedimiento?
  30. ¿Cuáles son las principales diferencias entre los constructores auxiliares de Scala y los constructores de Java?
  31. ¿Cuál es el uso de la palabra clave ‘yield’ en la construcción de comprensión ‘for’ de Scala?
  32. ¿Qué es una guarda en la construcción de comprensión ‘for’ de Scala?
  33. ¿Cómo resuelve Scala el Problema del Diamante de Herencia automáticamente y más fácilmente que Java 8?
  34. En Scala, ¿el Patrón de Coincidencia sigue qué Patrón de Diseño? En Java, ¿el operador ‘instanceof’ sigue qué Patrón de Diseño?

Preguntas y Respuestas de Entrevista en Scala

En esta sección, abordaremos cada pregunta de la lista anterior y discutiremos en detalle con ejemplos adecuados (si es necesario). Si deseas comprender estos conceptos a fondo con ejemplos, por favor, revisa mis publicaciones anteriores en la sección de Tutoriales de Scala.

¿Cuál es el Constructor Principal? ¿Cuál es el Constructor Secundario o Auxiliar en Scala? ¿Cuál es el propósito del Constructor Auxiliar en Scala? ¿Es posible sobrecargar constructores en Scala?

Scala tiene dos tipos de constructores:

  • Constructor Principal
  • Constructor Auxiliar

Constructor Principal En Scala, el Constructor Principal es un constructor que se define con la propia definición de la clase. Cada clase debe tener un Constructor Principal: ya sea un constructor con parámetros o un constructor sin parámetros. Ejemplo:-

class Person

La clase Persona anterior tiene un constructor primario sin parámetros para crear instancias de esta clase.

class Person (firstName: String, lastName: String)

La clase Persona anterior tiene un constructor primario con dos parámetros para crear instancias de esta clase. Constructor Auxiliar El constructor auxiliar también se conoce como constructor secundario. Podemos declarar un constructor secundario usando las palabras clave ‘def’ y ‘this’ como se muestra a continuación:

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

¿Cuál es el uso de los constructores auxiliares en Scala? Por favor, explique las reglas a seguir al definir constructores auxiliares en Scala?

En Scala, el propósito principal de los constructores auxiliares es sobrecargar los constructores. Al igual que en Java, podemos proporcionar varios tipos de constructores para que el usuario pueda elegir el adecuado según sus necesidades. Reglas de los Constructores Auxiliares:

  • Son como métodos solamente. Al igual que los métodos, debemos usar la palabra clave ‘def’ para definirlos.
  • Debemos usar el mismo nombre ‘this’ para todos los constructores auxiliares.
  • Cada constructor auxiliar debe comenzar con una llamada al constructor auxiliar previamente definido o al constructor primario. De lo contrario, error en tiempo de compilación.
  • Cada Constructor Auxiliar debe diferir con su lista de parámetros: ya sea por número o tipos.
  • Los Constructores Auxiliares no pueden llamar a constructores de la superclase. Solo deben llamarlos a través del Constructor Primario.
  • Todos los Constructores Auxiliares llaman a su Constructor Primario directa o indirectamente a través de otros Constructores Auxiliares.

NOTA:- Si quieres aprender sobre los Constructores de Scala, por favor consulta mis publicaciones sobre Scala en: Constructor Primario y Constructor Auxiliar.

¿Cuáles son las diferencias entre Array y ArrayBuffer en Scala?

Diferencias entre Array y ArrayBuffer en Scala:

  • Array es un array de tamaño fijo. No podemos cambiar su tamaño una vez creado.
  • ArrayBuffer es un array de tamaño variable. Puede aumentar o disminuir su tamaño dinámicamente.
  • Array es algo similar a los arrays primitivos de Java.
  • ArrayBuffer es algo similar a ArrayList de Java.

¿Qué es una case class? ¿Qué es un case object? ¿Cuáles son las ventajas de una case class?

Una case class es una clase que se define con la palabra clave “case class”. Un case object es un objeto que se define con la palabra clave “case object”. Debido a esta palabra clave “case”, obtendremos algunos beneficios para evitar el código redundante. Podemos crear objetos de case class sin usar la palabra clave “new”. Por defecto, el compilador de Scala añade “val” para todos los parámetros del constructor. Por eso, sin usar val o var, los parámetros del constructor de una case class se convertirán en miembros de la clase, lo cual no es posible para las clases normales. Ventajas de las case class:

  • Por defecto, el compilador de Scala añade los métodos toString, hashCode e equals. Podemos evitar escribir este código redundante.
  • Por defecto, el compilador de Scala añade un objeto compañero con los métodos apply y unapply, por eso no necesitamos la palabra clave new para crear instancias de una case class.
  • Por defecto, el compilador de Scala también añade el método copy.
  • Podemos usar case classes en Pattern Matching.
  • Por defecto, las Case class y Case Objects son Serializable.

¿Cuál es la diferencia entre el objeto Case y el objeto (Objeto normal)?

  • El objeto normal se crea utilizando la palabra clave “object”. Por defecto, es un objeto único.
object MyNormalObject
  • El objeto Case se crea utilizando la palabra clave “case object”. Por defecto, también es un objeto únicokeywords.By default, It’s also a singleton object
case object MyCaseObject
  • By Default, Case Object gets toString and hashCode methods. But normal object cannot.
  • Por defecto, el objeto Case tiene los métodos toString y hashCode. Pero el objeto normal no los tiene.

En comparación con la Clase Normal, ¿cuáles son las principales ventajas o beneficios de una Clase Case?

Las siguientes son las principales ventajas o beneficios de una Clase Case sobre las Clases Normales:

  • Ahorra mucho código repetitivo al agregar automáticamente algunos métodos útiles.
  • Por defecto, soporta la inmutabilidad porque sus parámetros son ‘val’.
  • Fácil de usar en coincidencia de patrones.
  • No es necesario utilizar la palabra clave ‘new’ para crear una instancia de la Clase Case.
  • Por defecto, admite la serialización y deserialización.

¿Cuál es el uso de los métodos isInstanceOf y asInstanceOf en Scala? ¿Existe algún concepto similar disponible en Java?

Ambos métodos isInstanceOf y asInstanceOf están definidos en la clase Any. Por lo tanto, no es necesario importar para obtener estos métodos en cualquier clase u objeto. El método “isInstanceOf” se utiliza para probar si el objeto es de un tipo dado o no. Si es así, devuelve true. De lo contrario, devuelve false.

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

El método “asInstanceOf” se utiliza para convertir el objeto al tipo dado. Si el objeto dado y el tipo son del mismo tipo, entonces se convierte al tipo dado. De lo contrario, arroja java.lang.ClassCastException.

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

En Java, la palabra clave ‘instanceof’ es similar al método ‘isInstanceOf’ de Scala. En Java, el siguiente tipo de conversión manual es similar al método ‘asInstanceOf’ de Scala.

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

¿Cómo demuestras que por defecto, el Case Object es Serializable y el objeto normal no lo es?

Sí, de forma predeterminada, el objeto Case es serializable. Pero el objeto normal no lo es. Podemos demostrar esto usando el método isInstanceOf, como se muestra a continuación: 

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

Diferencia entre Array y List en Scala?

  • Los Arrays son siempre mutables, mientras que las Listas son siempre inmutables.
  • Una vez creados, podemos cambiar los valores del Array, mientras que no podemos cambiar el objeto List.
  • Los Arrays son estructuras de datos de tamaño fijo, mientras que las Listas son estructuras de datos de tamaño variable. El tamaño de la Lista se incrementa o disminuye automáticamente según las operaciones que realicemos en ella.
  • Los Arrays son invariantes, mientras que las Listas son covariantes.

NOTA: Si no está seguro acerca de los conceptos de Invariante y Covariante, lea mi próxima publicación sobre Preguntas de Entrevista en Scala.

¿Cuál es la diferencia entre “val” y “lazy val” en Scala? ¿Qué es la Evaluación Ansiosa? ¿Qué es la Evaluación Perezosa?

Como discutimos en mis Preguntas Básicas de Entrevista en Scala, “val” significa valor o constante, que se utiliza para definir variables inmutables. Hay dos tipos de evaluaciones de programas:

  • Evaluación Ansiosa
  • Evaluación Perezosa

La Evaluación Ansiosa significa evaluar el programa en tiempo de compilación o en tiempo de despliegue del programa independientemente de si los clientes están utilizando ese programa o no. La Evaluación Perezosa significa evaluar el programa en tiempo de ejecución según demanda, es decir, cuando los clientes acceden al programa, entonces solo se evalúa. La diferencia entre “val” y “lazy val” es que “val” se utiliza para definir variables que se evalúan de manera ansiosa y “lazy val” también se utiliza para definir variables, pero se evalúan de manera perezosa.

¿Cuál es la relación entre el método equals y == en Scala? ¿Diferenciar el == de Scala y el operador == de Java?

En Scala, NO necesitamos llamar al método equals() para comparar dos instancias u objetos. Cuando comparamos dos instancias con ==, Scala llama automáticamente al método equals() de ese objeto. El operador == de Java se utiliza para verificar la igualdad de referencias, es decir, si dos referencias están apuntando al mismo objeto o no. El == de Scala se utiliza para verificar la igualdad de instancias, es decir, si dos instancias son iguales o no.

Diferencia entre la clase interna de Scala y la clase interna de Java?

En Java, la clase interna está asociada con la clase externa, es decir, la clase interna es un miembro de la clase externa. A diferencia de Java, Scala trata la relación entre la clase externa y la clase interna de manera diferente. La clase interna de Scala está asociada con el objeto de la clase externa.

¿Qué es el Problema del Diamante? ¿Cómo resuelve Scala el 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
}

Aquí, la salida es “Desde C.display” desde el rasgo C. El compilador de Scala lee “extiende B con C” de derecha a izquierda y toma la definición del método “display” del rasgo más a la izquierda, es decir, C. NOTA:- Consulta mi publicación sobre “Aspectos detallados de los rasgos de Scala” para entender esto con una explicación clara.

¿Por qué Scala NO tiene la palabra clave “static”? ¿Cuál es la razón principal de esta decisión?

Como sabemos, Scala NO tiene la palabra clave “static” en absoluto. Esta es la decisión de diseño tomada por el equipo de Scala. La razón principal para tomar esta decisión es hacer de Scala un Lenguaje de Programación Orientado a Objetos Puro. La palabra clave “static” significa que podemos acceder a los miembros de esa clase sin crear un objeto o sin usar un objeto, lo cual va en contra de los principios de la Programación Orientada a Objetos. Si un lenguaje admite la palabra clave “static”, entonces no es un Lenguaje de Programación Orientado a Objetos Puro. Por ejemplo, Java admite la palabra clave “static”, por lo que no es un Lenguaje de Programación Orientado a Objetos Puro. Pero Scala sí lo es.

¿Cuál es el uso de la palabra clave “object” en Scala? ¿Cómo se crean objetos Singleton en Scala?

En Scala, la palabra clave “object” se utiliza para los siguientes propósitos:

  • Se utiliza para crear objetos Singleton en Scala.
object MySingletonObject

Aquí, MySingletonObject se convierte automáticamente en un objeto Singleton.- La palabra clave “object” se utiliza para definir aplicaciones Scala que son programas ejecutables de Scala.

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

Cuando definimos el método principal en un objeto, como se muestra arriba (es lo mismo que el método main() en Java), se convierte automáticamente en un programa ejecutable de Scala.- Se utiliza para definir miembros estáticos como variables estáticas y métodos estáticos sin usar la palabra clave ‘static’.

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

Por def la variable PI y los métodos add se convertirán en miembros estáticos. Eso significa que podemos llamarlos sin crear un objeto separado como MyScalaStaticMembers.add(10,20). Se utiliza para definir métodos de fábrica. Por favor, vea mi próxima pregunta sobre esto.

¿Cómo se definen los métodos de fábrica utilizando la palabra clave object en Scala? ¿Cuál es el uso de definir métodos de fábrica en un objeto?

En Scala, usamos la palabra clave ‘object’ para definir métodos de fábrica. El propósito principal de estos métodos de fábrica en Scala es evitar el uso de la palabra clave ‘new’. Sin usar la palabra clave ‘new’ podemos crear objetos. Para definir métodos de fábrica: Podemos usar el método apply para definir métodos de fábrica en Scala. Si tenemos un Constructor Principal y Múltiples Constructores Auxiliares, entonces necesitamos definir múltiples métodos apply como se muestra a continuación.

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

Ahora podemos crear objetos Person sin usar la palabra clave new o con la palabra clave new según su preferencia.

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

¿Qué es el método apply en Scala? ¿Qué es el método unapply en Scala? ¿Cuál es la diferencia entre los métodos apply y unapply en Scala?

En Scala, los métodos apply y unapply juegan un papel muy importante. También son muy útiles en Play Framework para mapear y desmapear datos entre datos de formulario y datos de modelo. En palabras simples,

  • método apply: Para componer o ensamblar un objeto a partir de sus componentes.
  • método unapply: Para descomponer o desensamblar un objeto en sus componentes.

Método apply de Scala: Se utiliza para componer un objeto utilizando sus componentes. Supongamos que queremos crear un objeto Persona, luego usamos los dos componentes firstName y lastName y componemos el objeto Persona como se muestra a continuación.

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

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

Método unapply de Scala: Se utiliza para descomponer un objeto en sus componentes. Sigue el proceso inverso del método apply. Supongamos que tenemos un objeto Persona, luego podemos descomponer este objeto en sus dos componentes: firstName y lastName como se muestra a continuación.

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

¿Cómo funciona internamente cuando creamos una instancia de una clase sin usar la palabra clave ‘new’ en Scala? ¿Cuándo optamos por este enfoque? ¿Cómo se declaran los constructores privados en Scala?

En Scala, cuando creamos una instancia de una clase sin usar la palabra clave ‘new’, internamente se hace una llamada al método apply apropiado disponible en el objeto compañero. Aquí, “método apply apropiado” significa aquel que coincide con los parámetros. ¿Cuándo elegimos esta opción? Cuando necesitamos proporcionar un constructor privado y queremos evitar el uso de la palabra clave ‘new’, podemos implementar solo el método apply con el mismo conjunto de parámetros y permitir a los usuarios de nuestra clase crearlo sin la palabra clave ‘new’.

¿Cómo declaramos un Constructor Primario privado en Scala? ¿Cómo hacemos una llamada a un Constructor Primario privado en Scala?

En Scala, podemos declarar un Constructor Primario privado de manera muy sencilla. Solo tienes que definir un Constructor Primario como es habitual y agregar ‘private’ justo después del nombre de la clase y antes de la lista de parámetros, como se muestra a continuación:

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

Como es un constructor privado, no podemos llamarlo desde el exterior. Deberíamos proporcionar un método de fábrica (que es el método apply) como se muestra arriba y usar ese constructor indirectamente.

¿Un objeto Companion puede acceder a miembros privados de su clase Companion en Scala?

En general, los miembros privados significan que solo son accesibles dentro de esa clase. Sin embargo, la clase Companion y el Objeto Companion de Scala han proporcionado otra característica. En Scala, un objeto Companion puede acceder a los miembros privados de su clase Companion y la clase Companion puede acceder a los miembros privados de su objeto Companion.

¿Cuál es la decisión de diseño principal acerca de las dos palabras clave separadas: class y object en Scala? ¿Cómo definimos miembros de instancia y miembros estáticos en Scala?

En Scala, utilizamos la palabra clave class para definir miembros de instancia y la palabra clave object para definir miembros estáticos. Scala no tiene la palabra clave static, pero aún así podemos definirlos utilizando la palabra clave object. La decisión de diseño principal al respecto es la clara separación entre miembros de instancia y estáticos. Un acoplamiento débil entre ellos. Y otra razón importante es evitar la palabra clave static para que Scala se convierta en un lenguaje de programación orientado a objetos puro.

¿Qué es un objeto en Scala? ¿Es un objeto singleton o una instancia de una clase?

A diferencia de Java, Scala tiene dos significados para la palabra ‘object’. No te confundas al respecto, lo explicaré claramente. En Java, solo tenemos un significado para objeto, que es “una instancia de una clase”.

  • Al igual que en Java, el primer significado de objeto en Scala es “una instancia de una clase”.
val p1 = new Person("Scala","Java")
or 
val p1 = Person("Scala","Java")
  • El segundo significado es que “object” es una palabra clave en Scala. Se utiliza para definir programas ejecutables en Scala, objetos compañeros, objetos singleton, etc.

¿Qué es un objeto compañero en Scala? ¿Cuál es una clase compañera en Scala? ¿Cuál es el uso de un objeto compañero en Scala?

En palabras simples, si una clase Scala y un objeto comparten el mismo nombre y se definen en el mismo archivo fuente, entonces esa clase se conoce como “Clase Compañera” y ese objeto se conoce como “Objeto Compañero”. Cuando creamos una clase con la palabra clave “class” de Scala y un objeto con la palabra clave “object” de Scala con el mismo nombre y dentro del mismo archivo fuente, entonces esa clase se conoce como “Clase Compañera” y ese objeto se conoce como “Objeto Compañero”. Ejemplo: Employee.scala

class Employee{ }
object Employee{ }

En Scala, el propósito principal del Objeto Compañero es definir métodos apply y evitar el uso de la palabra clave “new” al crear una instancia de esa clase compañera.

¿Cómo implementar interfaces en Scala?

Como sabemos desde el trasfondo de Java, usamos la interfaz para definir contratos. Sin embargo, no existe el concepto de interfaz en Scala. Incluso, Scala no tiene una palabra clave de interfaz. Scala tiene un concepto más poderoso y flexible, es decir, el rasgo para este propósito.

¿Qué es un Rango en Scala? ¿Cómo crear un Rango en Scala?

Un Rango es una Colección Perezosa en Scala. El Rango es una clase disponible en el paquete ‘scala’ como ‘scala.Range’. Se utiliza para representar una secuencia de valores enteros. Es una secuencia ordenada de enteros. Ejemplo:-

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)

¿Cuántos valores del tipo Nothing existen en Scala?

En Scala, el tipo Nothing no tiene valores, es decir, cero. No tiene ningún valor. Es un subtipo de todas las clases de Valor y clases de Referencia.

¿Cuántos valores del tipo Unit existen en Scala?

En Scala, Unit es algo similar a la palabra clave void de Java. Se utiliza para representar que “No existe ningún valor”. Tiene un único valor que es ().

¿Qué es una función 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

Aquí, “+” es una función pura disponible en la clase Int. Da el mismo resultado, 30, para las mismas entradas 10 y 30, independientemente de cuántas veces lo llamemos.

En FP, ¿Cuál es la diferencia entre una función y un procedimiento?

Ambos se utilizan para realizar cálculos, sin embargo, tienen una diferencia importante en el mundo de la Programación Funcional. Una función es una unidad de cálculo sin efectos secundarios, mientras que un procedimiento también es una unidad de cálculo con efectos secundarios.

¿Cuáles son las principales diferencias entre los constructores auxiliares de Scala y los constructores de Java?

El constructor auxiliar de Scala es casi similar al constructor de Java con algunas diferencias. En comparación con los constructores de Java, los constructores auxiliares tienen las siguientes diferencias:

  • Los constructores auxiliares se llaman utilizando la palabra clave “this”.
  • Todos los constructores auxiliares se definen con el mismo nombre, que es “this”. En Java, usamos el nombre de la clase para definir los constructores.
  • Cada constructor auxiliar debe comenzar con una llamada a un constructor auxiliar previamente definido o al constructor principal.
  • Usamos la palabra clave ‘def’ para definir constructores auxiliares como la definición de métodos/funciones. En Java, la definición de constructor y la definición de método son diferentes.

¿Cuál es el uso de la palabra clave ‘yield’ en la construcción de comprensión de Scala?

Podemos usar la palabra clave ‘yield’ en la construcción de comprensión de Scala. ‘for/yield’ se utiliza para iterar una colección de elementos y generar una nueva colección del mismo tipo. No cambia la colección original. Genera una nueva colección del mismo tipo que el tipo de colección original. Por ejemplo, si usamos la construcción ‘for/yield’ para iterar una Lista, solo genera una nueva Lista.

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é es el guardia en la construcción de for-comprehension de Scala?

En Scala, la construcción for-comprehension tiene una cláusula if que se utiliza para escribir una condición para filtrar algunos elementos y generar una nueva colección. Esta cláusula if también se conoce como “guardia”. Si ese guardia es verdadero, entonces se agrega ese elemento a la nueva colección. De lo contrario, no se agrega ese elemento a la colección original. Ejemplo:- Guardia de for-comprehension para generar solo números pares en una nueva colección.

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)

¿Cómo resuelve Scala el problema del Diamante de Herencia automáticamente y de manera más fácil que Java 8?

Si usamos los métodos predeterminados de la interfaz de Java 8, obtendremos el problema del Diamante de Herencia. El desarrollador tiene que resolverlo manualmente en Java 8. No proporciona una resolución predeterminada o automática para este problema. En Scala, obtendremos el mismo problema con Traits, pero Scala es muy inteligente y resuelve automáticamente el problema del Diamante de Herencia utilizando el concepto de Linealización de Clases.

En Scala, ¿qué patrón de diseño sigue el Pattern Matching? En Java, ¿qué patrón de diseño sigue el operador ‘instanceof’?

En Scala, el Pattern Matching sigue el patrón de diseño Visitor. De la misma manera, el operador ‘instanceof’ de Java también sigue el patrón de diseño Visitor. Eso es todo sobre “Preguntas y respuestas intermedias de Scala”. Discutiremos algunas Preguntas y Respuestas Avanzadas de Scala en mis próximas publicaciones. Por favor, déjame un comentario si te ha gustado mi publicación o tienes algún problema/sugerencia.

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