Tutorial de Scala

Resumen del tutorial de Scala

Este tutorial de Scala cubre todos los aspectos y temas de Scala. Aprenderá todos los fundamentos desde cero, como qué es Scala, el proceso de instalación de Scala, programas de Scala, funciones de Scala, evaluación diferida, interfaz de tipos, clases y objetos, herencia, abstracciones, Java y diferencias de escala, etc.

Scala es un lenguaje escalable que se utiliza para escribir software para múltiples plataformas. De ahí que reciba el nombre de “Scala”. Este lenguaje está destinado a resolver los problemas de Java Al mismo tiempo es más conciso. Diseñado inicialmente por Martin Odersky, fue lanzado en 2003.

¿Por qué aprender Scala?

Estas son las razones principales para aprender el lenguaje de programación Scala:

• Scala es fácil de aprender para programadores orientados a objetos, Java desarrolladores. Se está convirtiendo en uno de los idiomas populares en los últimos años.
• Scala ofrece funciones de primera clase para los usuarios
• Scala se puede ejecutar en JVM, abriendo así el camino a la interoperabilidad con otros lenguajes.
• Está diseñado para aplicaciones concurrentes, distribuidas y resistentes basadas en mensajes. Es uno de los idiomas más exigentes de esta década.
• Es un lenguaje conciso, potente y puede crecer rápidamente según la demanda de sus usuarios.
• Está orientado a objetos y tiene muchas características de programación funcionales que brindan mucha flexibilidad a los desarrolladores para codificar de la manera que deseen.
• Scala ofrece muchos tipos de patos
• Tiene menos texto estándar si vienes de Java
• Los frameworks Lift and Play escritos en Scala se encuentran en la curva de crecimiento.

Cómo instalar Scala

Para comenzar a escribir programas Scala, debe tenerlo instalado en su computadora. Para hacer esto, deberá visitar su sitio. https://www.scala-lang.org/download/ para descargar la última versión de Scala.

Siguiendo el enlace, nos encontramos con dos opciones que podemos elegir para instalar Scala en nuestras máquinas. Para este tutorial de Scala, descargaremos el IntelliJ IDEA.

Una vez que visite el enlace de descarga, encontrará dos versiones de IntelliJ IDE.

Para este tutorial de Scala, descargaremos la Community Edition, que es gratuita y viene con todo lo que necesita para escribir programas de Scala.

Paso 1) Seleccionar Community Edition
En la página, haga clic en el menú desplegable de Community Edition.

Nos presenta una opción para descargar IntelliJ IDE junto con JBR que contiene una implementación JDK (Java Kit de desarrollo) OpenJDK que Scala necesita para compilar y ejecutar el código.

Paso 2) Ejecuta la instalación
Una vez que descargue IntelliJ, haga doble clic en él para ejecutar el asistente de instalación y seguir el cuadro de diálogo.

Paso 3) Seleccione una Ubicación
Elija una ubicación para instalar el IDE.

Si por casualidad no descargaste el que tiene el JDK, aún así aparece un mensaje que nos indica que podemos marcar la casilla para descargarlo.

Paso 4) Haga clic en siguiente
Deje los demás valores predeterminados como están y haga clic en Siguiente.

Paso 5) Haga clic en el icono de inicio
Una vez que se complete la instalación, ejecute IntelliJ IDE haciendo clic en su icono de inicio en el menú de inicio como una aplicación normal.

Aún necesita realizar un paso adicional para agregar el complemento Scala a IntelliJ; Para ello, haga clic en el menú desplegable del menú de configuración ubicado en la parte inferior derecha de la pantalla y seleccione la opción de complemento.

En la pestaña Marketplace, una búsqueda de Scala presentará el complemento como el primer resultado en la etiqueta Idiomas.

Paso 6) Instalar complemento
Haga clic en instalar, lo que hará que el complemento comience la descarga.

Paso 7) Reinicie el IDE
Una vez completada la descarga, se le pedirá que reinicie el IDE para que el complemento instalado pueda comenzar a funcionar.

Después de reiniciar, se encontrará en la misma página que antes cuando ejecutamos el IDE, pero esta vez ya hemos instalado el complemento Scala.

Programa Scala Hola Mundo

Paso 1) Seleccione la opción Crear proyecto, lo que nos llevará a una página donde podremos seleccionar el tipo de idioma que utilizará nuestro proyecto.

Paso 2) Elija Scala seleccionando la casilla de verificación Scala y haga clic en siguiente.

Paso 3) Seleccione una ubicación para guardar nuestro archivo de proyectos y asigne un nombre a nuestro proyecto.

Si el directorio no existe, IntelliJ nos pedirá permiso para crear la carpeta. Aceptar y hacer clic en finalizar. Serás llevado a tu proyecto Scala, que actualmente no tiene ningún código Scala.

Tomará algún tiempo cargar algunos índices, así que no se preocupe si no puede hacer nada inmediatamente mientras hay una barra de progreso en la parte inferior de su IDE, simplemente significa que su IDE está cargando algunos archivos necesarios para ejecutar Scala y ayuda con el autocompletado de IDE.

Paso 4) A continuación, haremos clic en la pestaña de proyectos a la izquierda del IDE y la expandiremos para que podamos ver el contenido de nuestro proyecto.

Por el momento el proyecto está vacío y solo contiene una carpeta .idea y un archivo hello-world.iml generado por el IDE. Nuestro punto de interés es la carpeta src. Src es donde almacenamos el código fuente de nuestro proyecto. Es donde crearemos nuestro primer archivo Scala.

Paso 5) Haga clic derecho en src para abrir un menú para crear un nuevo archivo Scala.

Luego crearemos un nombre para el archivo, en este tutorial de Scala usaremos hola y luego elegiremos en un menú desplegable qué poner como contenido del archivo Scala. Seleccione "Objeto"

Una vez que hagamos esto, tendremos un archivo Scala que tiene un objeto Singleton que usaremos para ejecutar nuestro código.

Ahora que tiene un archivo Scala con un objeto Hello. Escribirá su primer programa ampliando el objeto que ha creado utilizando la palabra clave App.

Extender nuestro objeto con la aplicación le dice al compilador qué código ejecutar cuando inicia su programa. Inmediatamente después de extender la aplicación, aparece una flecha verde en el lado izquierdo, lo que indica que ahora puede ejecutar su programa.

Dentro del objeto Hello, escribimos una función println() que se usa para imprimir el texto que contiene en la consola. Ejecutaremos nuestro código haciendo clic en la flecha verde.

Al hacer clic en la flecha se nos presenta la opción Ejecutar, hola, al hacer clic en ella, nuestro código comenzará a compilarse y luego de unos segundos veremos los resultados de nuestro programa impresos desde la consola incorporada en el IDE de IntelliJ.

Y ahí vamos, hemos instalado Scala con éxito y ejecutamos nuestro primer programa.

Qué puedes hacer con Scala

• Desarrollo web front-end con ScalaJS
• Desarrollo móvil, ambos Android Desarrollo e IOS – con Scala Native
• Bibliotecas del lado del servidor como HTTP4S, Akka-Http, Play Framework
• Internet de las cosas usando
• Desarrollo del juego
• PNL: procesamiento del lenguaje natural utilizando un conjunto de bibliotecas ScalaNLP
• Probar técnicas de programación avanzadas como la Programación Funcional y la Programación Orientada a Objetos.
• Cree una aplicación de comunicación altamente concurrente utilizando actores, una biblioteca para JVM inspirada en Erlang
• Úselo para aprendizaje automático usando bibliotecas como Figaro que realiza programación probabilística y Apache. Spark que

Funciones anónimas

El lenguaje Scala tiene funciones anónimas, que también se denominan literales de función. Como Scala es un lenguaje funcional, a menudo significa que los desarrolladores dividen grandes problemas en muchas tareas pequeñas y crean muchas funciones para resolverlos. Para facilitar la creación de funciones, Scala contiene estas funciones que se pueden instanciado sin nombre. Podemos asignarlos directamente a variables o definiciones 'def' como se muestra en el siguiente ejemplo de Scala:

val multiplyByTwo = (n:Int) => n * 2
def multiplyByThree = (n:Int) => n *3

Luego podemos usar la forma normal en que usamos las funciones pasándoles parámetros a continuación.

multiplyByTwo(3)

//6

multiplyByThree(4)

//12

Estos métodos resultan útiles cuando queremos tener un código limpio y conciso. Podemos utilizar funciones anónimas al definir métodos que no sean grandes y no requieran mucho código en su cuerpo. Son muy sencillos y no necesitan ninguna ceremonia para crearlos.

Estos métodos no se limitan a funciones con argumentos y se pueden utilizar para crear instancias de métodos que no aceptan ningún argumento.

val sayHello = ()=>{ println("hello") }

La mayoría de estas funciones anónimas se utilizan en otras partes de nuestro código donde necesitamos crear una función rápida.

Otra razón por la que estas funciones también se conocen como funciones en línea. El uso de funciones anónimas es un patrón común que se usa de manera generalizada en la biblioteca de colecciones para realizar acciones rápidas sobre una colección.

Por ejemplo, tenemos el método de filtro que toma una función en línea/función anónima para crear otra colección con solo elementos que cumplen con los criterios que definimos en la función anónima.

val myList = List(1,2,3,4,5,6,7)

val myEvenList = myList.filter((n: Int) => n % 2 == 0)
//List(2,4,6)

val myOddList = myList.filter((n:Int) => n % 2 != 0)
//List(1,3,5,7)

Aquí los métodos que tenemos como funciones anónimas son los que verifican si el valor que obtenemos de la lista es par o impar y devuelven el elemento.

//the one checking that the value is even
(n: Int) => n % 2 == 0

//the one checking that the value is odd
(n:Int) => n % 2 != 0

En Scala, también es posible utilizar comodines donde los parámetros de nuestra función anónima no tienen nombre. Por ejemplo

var timesTwo = (_:Int)*2

timesTwo(5)
//10

En este escenario, no nombramos el parámetro que estamos pasando. Lo único que usamos es un guión bajo para representarlo.

Evaluación perezosa

La mayoría de los lenguajes evalúan secuencialmente variables y parámetros de funciones, uno tras otro. En Scala, tenemos una palabra clave llamada lazy, que ayuda a tratar con valores que no queremos que se evalúen hasta que se haga referencia a ellos.

Una variable marcada como perezosa no se evaluará donde esté definida, esto se conoce comúnmente como evaluación ansiosa, solo se evaluará cuando se haga referencia a ella en algún momento posterior en el código.

Esto puede ser útil cuando evaluar un valor puede ser un cálculo costoso; si no es el caso que el valor siempre es necesario, podemos ahorrarnos ejecutar un cálculo costoso que puede ralentizar nuestro software al hacer que nuestra variable sea lenta.

lazy val myExpensiveValue = expensiveComputation

def runMethod()={
    if(settings == true){
        use(myExpensiveValue)
    }else{
        use(otherValue)
    }
}

Este no es el único caso de uso de variables diferidas. También ayudan a abordar cuestiones de dependencia circular en el código.

En caso de que la configuración sea falsa, es posible que no necesitemos usar myExpensiveValue, lo que puede evitarnos realizar un cálculo costoso que ayuda a garantizar que los usuarios se diviertan usando nuestra aplicación, ya que sus otras necesidades se pueden calcular correctamente sin ser abrumadoras. el carnero.

En caso de que la configuración sea falsa, es posible que no necesitemos usar myExpensiveValue, lo que puede evitarnos realizar un cálculo costoso que ayuda a garantizar que los usuarios se diviertan usando nuestra aplicación, ya que sus otras necesidades se pueden calcular adecuadamente sin abrumar. el carnero.

La pereza también ayuda con los argumentos de funciones, donde los argumentos solo se usan cuando se hace referencia a ellos dentro de la función. Este concepto se denomina parámetros de llamada por nombre.

def sometimesUsedString(someValue:String, defaultValue:=> String)={
 if(someValue != null){
   use(defaultValue)
 }else{
   use(someValue)
   }
 }

Muchos lenguajes utilizan el método de llamada por valor para evaluar argumentos. El parámetro que se pasa mediante llamada por nombre solo se evaluará cuando sea necesario en el cuerpo de la función y no se evaluará antes de eso. Una vez que se evalúa el valor, se almacena y se puede reutilizar más adelante sin tener que volver a evaluarlo. Este concepto se conoce como memorización.

Inferencia de tipo

En Scala, no es necesario declarar tipos para cada variable que crea. Esto se debe a que el compilador de Scala puede realizar inferencias de tipos basándose en la evaluación del lado derecho. Esto permite que su código sea más conciso: nos libera de escribir textos repetitivos donde el tipo esperado es obvio.

var first:String = "Hello, "
var second:String = "World"
var third = first + second
//the compile infers that third is of type String

Función de orden superior

Una función de orden superior es una función que puede tomar funciones como argumentos y puede devolver una función como tipo de retorno. En Scala, las funciones se consideran ciudadanos de primera clase. Usar estas funciones de esta manera nos permite ser muy flexibles en el tipo de programas que podemos crear. Podemos crear funciones dinámicamente e incorporar funcionalidad dinámicamente a otras funciones.

def doMathToInt(n:Int, myMathFunction:Int=>Int): Int ={
    myMathFunction(n)
}

En la función anterior, pasamos un int y una función que toma un int y devuelve un int. Podemos pasar cualquier función de esa firma. Por firma nos referimos a la entrada y salida de una función. Una firma de Int=>Int significa que una función toma un Int como entrada y devuelve un Int como salida.

Una firma de ()=>Int significa que una función no toma nada como entrada y devuelve un Int como salida. Un ejemplo de una función como esa sería aquella que genera un int aleatorio para nosotros.

def generateRandomInt()={
 return scala.util.Random.nextInt()
}

La función anterior tiene una firma ()=>Int

Podemos tener una función que tenga una firma scala ()=>Unidad. Esto significa que las funciones no toman nada y no devuelven un tipo. La función podría estar haciendo algún tipo de cálculo cambiando algo para hacer algo predeterminado.

Sin embargo, no se recomiendan estos tipos de métodos, ya que parecen ser una caja negra que puede afectar a un sistema de maneras desconocidas. Además, no se pueden probar. Tener tipos de entrada y salida explícitos nos permite razonar sobre lo que hace nuestra función.

Una función de orden superior también puede devolver una función.

Por ejemplo, podríamos crear un método que cree una función potenciadora, es decir, tome un número y le aplique potencia.

def powerByFunction(n:Int):Int=>Int = {
  return (x:Int)=> scala.math.pow(x,n).toInt
}

La función anterior toma un int. Nuestro tipo de retorno es una función anónima que toma un Int x, * usamos int x como argumento para la función de potencia.

Zurra

En Scala, podemos convertir una función que toma dos argumentos en una que toma un argumento a la vez. Cuando pasamos un argumento, lo aplicamos parcialmente y terminamos con una función que toma un argumento para completar la función. Currying nos permite crear funciones agregando parcialmente algunos argumentos.

Esto puede ser útil para crear funciones dinámicamente antes de que tengamos un conjunto completo de argumentos.

def multiply two numbers(n:Int)(m:Int): Unit ={
  return n * m
}

Si necesitamos crear una función que multiplique por algún número específico, no necesitamos crear otro método de multiplicación.

Simplemente podemos llamar a .cured en nuestra función anterior y obtener una función que tome un argumento primero y devolver una función parcialmente aplicada.

def multiplyTwoNumbers(n:Int)(m:Int): Unit ={
  return n * m
}

var multiplyByFive = multiplyTwoNumbers(5) 

multiplyByFive(4)

//returns 20

La coincidencia de patrones

Scala tiene un poderoso mecanismo incorporado para ayudarnos a verificar si una variable coincide con ciertos criterios, muy parecido a lo que haríamos en una declaración de cambio en Java o en una serie de declaraciones if/else. El lenguaje tiene coincidencia de patrones que podemos usar para verificar si una variable es de un tipo particular. La coincidencia de patrones en Scala es poderosa y se puede usar para desestructurar los componentes que tienen un método de aplicación para obtener los campos que nos interesan directamente de la variable que estamos comparando.

La coincidencia de patrones de Scala también proporciona una sintaxis más agradable en comparación con la declaración de cambio.

myItem match {
  case true => //do something
  case false => //do something else
  case  _ => //if none of the above do this by default
}

Comparamos nuestra variable con un conjunto de opciones, y cuando la variable que estamos comparando cumple con los criterios, la expresión en el lado derecho de la flecha gruesa (=>) se evalúa y se devuelve como resultado de la coincidencia.

Usamos un guión bajo para detectar casos que no coinciden en nuestro código. Refleja el comportamiento del caso predeterminado cuando se trata de declaraciones de cambio.

class Animal(var legs:Int,var sound:String)
class Furniture(var legs:Int, var color:Int, var woodType:String)

myItem match {
case myItem:Animal => //do something
case myItem:Furniture => //do something else
case _ => //case we have a type we don't recognize do sth else
}

En el código anterior, puede averiguar el tipo de variable myItem y, en función de eso, derivar a algún código específico.

La coincidencia de patrones comprueba si la variable coincide

El guión bajo funciona como un marcador de posición que coincide con cualquier otra condición que no coincida con los demás elementos de las declaraciones de caso anteriores. Tomamos una variable myItem y llamamos al método de coincidencia.

• comprobamos si myItem es verdadero usando y hacemos algo de lógica en el lado derecho de la flecha gruesa "=>".
• Usamos el guión bajo para hacer coincidir cualquier cosa que no coincida con ninguna de las declaraciones de caso que hemos definido en el código.

Con las clases Case, podemos incluso ir más allá y desestructurar la clase para obtener campos dentro del objeto.

Al usar la palabra clave sellada para definir nuestras clases, obtenemos el beneficio de que el compilador verifique exhaustivamente los casos con los que intentamos comparar y nos avise si nos olvidamos de manejar uno en particular.

Inmutabilidad

Es posible crear valores que otras funciones en Scala no pueden cambiar usando la palabra clave val. Esto se logra en Java utilizando la palabra clave final. En Scala, lo hacemos usando una palabra clave val al crear una variable en lugar de usar var, que es la alternativa que usaríamos para crear una variable mutable.

Una variable definida con la palabra clave val es de solo lectura, mientras que una definida con var puede ser leída y modificada por otras funciones o arbitrariamente por el usuario en el código.

var changeableVariable = 8

changeableVariable =10
//the compiler doesn't complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//if we try this the code won't compile

Intentar asignar un valor a myNumber después de haberlo declarado como val genera un error en tiempo de compilación o "reasignación a val".

¿Por qué utilizar la inmutabilidad?

La inmutabilidad nos ayuda a evitar que el código y otros programadores cambien nuestros valores inesperadamente, lo que conduciría a resultados inesperados si pretenden utilizar el valor que almacenamos, en su lugar pueden hacer una copia del mismo. De esta manera, se evitan errores que pueden ser causados ​​por múltiples actores que cambian la misma variable.

Clases y objetos

Todos sabemos que los objetos son entidades del mundo real y que la clase es una plantilla que define los objetos. Las clases tienen tanto estado como comportamientos. Los estados son valores o variables. Los comportamientos son los métodos en Scala.

Veamos cómo se puede definir una clase, crear una instancia de ella y usarla usando Scala.

Aquí, la clase llamada Rectángulo, que tiene dos variables y dos funciones. También puede utilizar los parámetros l y b directamente como campos en el programa. Tiene un objeto que tiene un método principal y ha creado una instancia de la clase con dos valores.

Ejemplo:

class Rectangle( l: Int,  b: Int) {
  val length: Int = l
  val breadth: Int = b
  def getArea: Int = l * b
  override def toString = s"This is rectangle with length as $length and breadth as  $breadth"
  }
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)    
  }
}

Todos los campos y métodos son públicos por defecto en Scala. Es esencial utilizar override porque el método toString está definido para Object en Scala.

Herencia

Scala tiene múltiples tipos de herencia (como herencia única, multinivel, múltiple, jerárquica, híbrida) que comparten mucho en común con las formas tradicionales que se encuentran en Java. Puedes heredar tanto de clases como de rasgos. Puede heredar los miembros de una clase en otra clase usando la palabra clave "extiende". Esto permite la reutilización.

Es posible heredar de una clase o de varias clases. También es posible heredar de subclases que a su vez tienen sus superclases, creando una jerarquía de herencia en el proceso.

En el siguiente ejemplo de Scala, la clase base es Círculo y la clase derivada es Esfera. Un círculo tiene un valor llamado radio, que se hereda en la clase Esfera. El método calcArea se anula mediante la palabra clave override.

Ejemplo:

class Circle {
  val radius = 5;
  def calcArea = {
    println(radius * radius )
  }
}
class Sphere extends Circle{
 override def calcArea = {
    println(radius * radius * radius )
  }
}
  object SphereObject{
    def main(args : Array[String]){
      new Sphere().calcArea 
    }
  }

Abstracción

En Scala, podemos crear métodos abstractos y campos miembro utilizando clases y rasgos abstractos. Dentro de las clases y rasgos abstractos, podemos definir campos abstractos sin necesariamente implementarlos.

Ejemplo:

trait MakesSound{
    var nameOfSound:String
    def sound():String
}
abstract class HasLegs(var legs:Int){
    val creatureName:String

    def printLegs():String={
        return s"$creatureName has this number of legs: $legs"
    }
}

Estos campos se implementan mediante las clases que extienden el rasgo o la clase abstracta. Puede utilizar rasgos para crear contratos sobre lo que nuestra aplicación debería poder hacer y luego implementar esos métodos más adelante.

trait DatabaseService{
    def addItemName(itemName:String)
    def removeItem(itemId:Int)
    def updateItem(itemId:Int, newItemName:String)
}

De esta manera, podemos planificar cómo se verá nuestra aplicación sin implementar los métodos que pueden ayudarnos a imaginar cómo se verán los distintos métodos. Sigue un patrón conocido como programación de abstracciones y no la implementación real.

La clase precedida por la palabra clave abstract puede contener métodos tanto abstractos como no abstractos. Sin embargo, las herencias múltiples no se admiten en la clase abstracta. Entonces, puedes extender como máximo una clase abstracta.

Objetos Singleton

Un Singleton es una clase de la que solo se crea una instancia una vez en un programa. Proviene de un patrón de programación popular y útil conocido como "patrón singleton". Es útil para crear instancias que deben tener una vida útil prolongada y a las que se accederá comúnmente en todo el programa, cuyo estado es integral para coordinar los eventos de un sistema. Crear una clase de este tipo en Scala es fácil ya que Scala nos proporciona un medio sencillo para crear singletons utilizando la palabra clave object.

object UserProfile{
    var userName=""
    var isLoggedIn:Boolean = false
}

Luego podemos hacer referencia a este objeto en todo nuestro programa con la garantía de que todas las partes de nuestro programa verán los mismos datos ya que solo hay una instancia del mismo.

def getLoggedInStatus():Boolean={
   return UserProfile.isLoggedIn
}

def changeLoggedInStatus():Boolean={
    UserProfile.isLoggedIn = !UserProfile.isLoggedIn
    return  UserProfile.isLoggedIn
}

El concepto de miembros estáticos no existe en Scala, esa es la razón por la que es necesario utilizar objetos singleton, que actúan como miembros estáticos de una clase.

Clases implícitas

Las clases implícitas son la nueva funcionalidad agregada después de la versión 2.1. Es principalmente para agregar nuevas funciones a las clases cerradas.

La palabra clave implícita debe definirse en una clase, objeto o rasgo. El constructor principal de una clase implícita debe tener exactamente un argumento en su primera lista de parámetros. También puede incluir una lista de parámetros implícita adicional.

En el siguiente ejemplo de Scala, se agrega una nueva funcionalidad para reemplazar las vocales de una cadena con *.

object StringUtil {
  implicit class StringEnhancer(str: String) {
    
    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Debes importarlo en la clase donde lo estás usando.

import StringUtil.StringEnhancer

object ImplicitEx extends App {
  val msg = "This is Guru99!"
  println(msg.replaceVowelWithStar)
}

Programación orientada a objetos (OOP) versus programación funcional (FP)

En OOP, los programas se construyen agrupando datos y las funciones que operan con esos datos en unidades altamente conectadas. Los objetos llevan sus datos en los campos y métodos que operan sobre ellos. En este estilo de programación, la abstracción principal son los datos, ya que los métodos que se crean están destinados a operar con los datos.

Programación funcional, por otro lado, separa los datos y las funciones que operan sobre los datos. Esto permite a los desarrolladores tratar las funciones como abstracción y fuerza impulsora al modelar programas.

Scala permite la programación funcional al considerar a las funciones como ciudadanos de primera clase, lo que permite que se las pase como valores a otras funciones y que se las devuelva como valores también. La combinación de estos dos paradigmas ha hecho de Scala una excelente opción para crear software complejo en diversas industrias, como la ciencia de datos.

Marcos importantes en Scala

Aquí hay algunos marcos importantes de Scala.

• Jugar es un marco de aplicación web de código abierto que utiliza Arquitectura MVC. Lanzado en 2007 y ahora con licencia Apache, se convirtió en el marco más popular en GitHub en 2013. Empresas como LinkedIn, Walmart, Samsung y Eero utilizan este marco.
• Altura de elevación es otro marco web gratuito escrito en Scala lanzado en 2007. Foursquare utiliza el marco Lift. Es un marco de alto rendimiento y más rápido de construir.
• Acre
• Gatos - Leecork
• Spark

Soporte de concurrencia

• Los valores en Scala son inmutables por defecto. Esto lo hace muy adaptable al entorno concurrente.
• Hay muchas características en Scala que lo hacen mejor para aplicaciones concurrentes.
• Los futuros y las promesas facilitan el procesamiento de datos de forma asincrónica, lo que favorece el paralelismo.
• Akka: conjunto de herramientas que utiliza el modelo de concurrencia de Actor. Hay una serie de Actores que actúan cuando reciben mensajes.
• Concurrencia usando hilos de Java También puede ser compatible con Scala.
• El procesamiento de flujo es otra gran característica que permite el procesamiento continuo de datos en tiempo real.

Scala tiene algunas de las mejores bibliotecas de concurrencia del mundo. Java ecosistema.

• Nativo Java threads
• Fibras de bibliotecas como Vertex
• ZIO: una biblioteca que tiene primitivas para ayudarnos a lidiar con la concurrencia y el cálculo asincrónico
• STM – Transacción
• Futuro: incorporado en el lenguaje Scala

Java contra Scala

Aquí están los principales diferencia entre Java y escala.

Scala	Java
Más compacto y conciso	Fragmentos de código comparativamente más grandes
Diseñado y desarrollado para ser un lenguaje orientado a objetos y funcional. Admite una amplia variedad de funciones de programación funcional, como concurrencia e inmutabilidad.	Desarrollado originalmente como un lenguaje orientado a objetos y comenzó a admitir funciones de programación funcional en los últimos días. Todavía no es fuerte como lenguaje de programación funcional.
Utiliza un modelo de actor para admitir la concurrencia, que es moderno.	Utiliza el modelo convencional basado en subprocesos para la concurrencia.
Estructuras de soporte: jugar, levantar	Soporta Spring, Grails y mucho más.
Soporta evaluación perezosa	No admite evaluación perezosa
Sin miembros estáticos	Contiene miembros estáticos
Admite sobrecarga del operador	No admite sobrecarga del operador
La compilación del código fuente es comparativamente lenta.	La compilación del código fuente es más rápida que Scala
Rasgos – actuar como Java 8 interfaces	Java 8 interfaces intentan cerrar la brecha entre clases e interfaces
Es necesario reescribir	No es necesario reescribir
No hay garantía sobre los códigos libres de errores.	Garantía total de defectos menores
Admite compatibilidad con versiones anteriores.	Scala no admite compatibilidad con versiones anteriores.
OperaLos padres reciben un trato diferente en Java y no son llamadas a métodos.	Todos los operadores en las entradas se realizan mediante un método llamado en Scala.
Admite herencias múltiples utilizando clases pero no mediante clases abstractas	No soporta herencias múltiples usando clases, sino por interfaces
El código está escrito en forma compacta.	El código está escrito en formato largo.
Scala no contiene la palabra clave estática.	Java contiene la palabra clave estática.

Resumen

En este tutorial, aprendió cómo comenzar con Scala. También ha aprendido las características funcionales y orientadas a objetos. También has descubierto las similitudes y diferencias entre Java y Escala. Este tutorial debería haberle ayudado con una amplia variedad de ejemplos bien demostrados.