Tutoriel Scala

Qu'est-ce que Scala ?

Scala Scala est un langage de programmation statiquement typé qui combine programmation orientée objet et fonctionnelle afin d'améliorer la scalabilité des applications. Il s'exécute principalement sur la plateforme JVM, et les développeurs peuvent également l'utiliser pour écrire des logiciels pour plateformes natives via Scala-Native, ou pour navigateur via Scala.js. Javascénario Durée.

Scala est un langage évolutif utilisé pour développer des logiciels multiplateformes, d'où son nom. Ce langage a été conçu pour résoudre plusieurs problèmes de verbosité rencontrés dans… Java tout en restant concis. Martin Odersky a conçu Scala, et sa première version publique est apparue en 2004.

Pourquoi apprendre Scala

Voici les principales raisons d'apprendre le langage de programmation Scala :

• Scala est facile à apprendre pour les programmeurs orientés objet et Java développeurs, et c'est devenu l'un des langages populaires ces dernières années.
• Scala offre des fonctions de premier ordre aux utilisateurs.
• Scala peut être exécuté sur le JVM, ouvrant la voie à l'interopérabilité avec d'autres langages.
• Il est conçu pour les applications concurrentes, distribuées et résilientes, pilotées par les messages, ce qui en fait l'un des langages les plus demandés de cette décennie.
• C'est un langage concis et puissant, capable d'évoluer rapidement en fonction des besoins de ses utilisateurs.
• Il est orienté objet et comprend de nombreuses fonctionnalités de programmation fonctionnelle, offrant aux développeurs une grande flexibilité dans la manière dont ils écrivent le code.
• Scala propose Duck Typing par types structurels.
• Il contient moins de texte standard que Java.
• Les frameworks Lift et Play, écrits en Scala, continuent de mûrir et de gagner en popularité.

Comment installer Scala

Pour commencer à écrire des programmes Scala, vous devez l'installer sur votre ordinateur. Pour ce faire, rendez-vous sur le site officiel à l'adresse suivante : https://www.scala-lang.org/download/ pour télécharger la dernière version de Scala.

En suivant le lien, deux options d'installation de Scala vous sont proposées. Pour ce tutoriel Scala, nous utiliserons… IntelliJ IDEA, qui offre une excellente prise en charge de Scala prête à l'emploi.

Une fois que vous aurez cliqué sur le lien de téléchargement, vous trouverez deux éditions de l'IDE IntelliJ.

Pour ce tutoriel Scala, nous téléchargerons l'édition Community, qui est gratuite et comprend tout ce dont vous avez besoin pour écrire des programmes Scala.

Étape 1) Sélectionnez l'édition communautaire.
Sur la page, cliquez sur le menu déroulant « Édition communautaire ».

Il offre la possibilité de télécharger l'IDE IntelliJ avec JBR, qui contient une implémentation JDK (Java Kit de développement) tel qu'OpenJDK dont Scala a besoin pour compiler et exécuter le code.

Étape 2) Lancez l'installation.
Une fois IntelliJ téléchargé, double-cliquez sur le fichier d'installation et suivez l'assistant à l'écran.

Étape 3) Sélectionnez un emplacement.
Choisissez un emplacement pour installer l'EDI.

Si vous n'avez pas téléchargé le pack contenant le JDK, le programme d'installation vous invite tout de même à ajouter le JDK via une case à cocher lors de l'installation.

Étape 4) Cliquez sur Suivant.
Laissez les autres paramètres par défaut tels quels et cliquez sur Suivant.

Programme Scala Hello World

Étape 5) Cliquez sur l'icône de démarrage.
Une fois l'installation terminée, lancez l'IDE IntelliJ en cliquant sur son icône de démarrage dans le menu Démarrer, comme pour une application classique.

Vous devez encore ajouter le plugin Scala à IntelliJ. Cliquez sur le menu déroulant « Configurer » en bas à droite de l’écran et sélectionnez l’option « Plugins ».

Dans l'onglet Marketplace, recherchez Scala. Le plugin apparaît en premier résultat sous l'étiquette Langages.

Étape 6) Installez le plugin.
Cliquez sur Installer pour lancer le téléchargement du plugin Scala.

Étape 7) Redémarrez l'IDE.
Une fois le téléchargement terminé, vous serez invité à redémarrer l'IDE pour que le plugin installé puisse commencer à fonctionner.

Après le redémarrage, vous revenez à la même page qu'auparavant, mais le plugin Scala est désormais installé et prêt à l'emploi.

Étape 8) Sélectionnez « Créer un projet », ce qui vous mènera à une page où vous pourrez choisir la langue du projet.

Étape 9) Choisissez Scala en cochant la case Scala et cliquez sur Suivant.

Étape 10) Choisissez un emplacement pour enregistrer le fichier de projet et donnez un nom au projet.

Si le répertoire n'existe pas, IntelliJ vous demandera l'autorisation de le créer. Acceptez et cliquez sur Terminer. Vous serez alors redirigé vers votre projet Scala, qui ne contient actuellement aucun code Scala.

Le chargement des index peut prendre un certain temps ; ne vous inquiétez donc pas si vous ne pouvez pas interagir avec l’IDE ​​pendant l’affichage de la barre de progression en bas de l’écran. L’IDE charge les fichiers nécessaires à l’exécution de Scala et à la saisie semi-automatique.

Étape 11) Cliquez sur l'onglet Projet à gauche de l'IDE et développez-le pour afficher le contenu du projet.

À ce stade, le projet est vide et ne contient qu'un dossier .idea et un fichier hello-world.iml généré par l'IDE. Le dossier src, qui contient le code source du projet, est l'élément important. C'est là que vous créez votre premier fichier Scala.

Étape 12) Faites un clic droit sur src pour ouvrir un menu et créer un nouveau fichier Scala.

Choisissez un nom pour le fichier. Pour ce tutoriel Scala, utilisez hello, puis choisissez Objet dans la liste déroulante pour le type de contenu du fichier Scala.

Une fois cela fait, vous obtenez un fichier Scala contenant un objet singleton que vous utiliserez pour exécuter le code.

Maintenant que vous avez un fichier Scala contenant un objet Hello, écrivez votre premier programme en étendant l'objet que vous avez créé à l'aide du mot-clé App.

L'extension de l'objet avec App indique au compilateur quel code exécuter au démarrage du programme. Immédiatement après l'extension de App, une flèche verte apparaît à gauche, indiquant que le programme est désormais exécutable.

Dans l'objet Hello, écrivez la fonction println() pour afficher le texte dans la console. Exécutez le programme en cliquant sur la flèche verte.

Cliquer sur la flèche permet de sélectionner l'option « Exécuter Hello ». En la sélectionnant, le code est compilé et, après quelques secondes, le résultat du programme apparaît dans la console IntelliJ.

Vous avez maintenant installé Scala avec succès et exécuté votre premier programme.

Ce que vous pouvez faire avec Scala

Scala est largement utilisé dans de nombreux domaines grâce à sa flexibilité et son interopérabilité avec la JVM. Voici quelques cas d'utilisation courants :

• Développement web frontend avec ScalaJS.
• Développement mobile pour Android et iOS avec Scala Native.
• Bibliothèques côté serveur telles que HTTP4S, Akka-Http et le framework Play.
• Applications de l'Internet des objets (IoT).
• Développement de jeu.
• Traitement automatique du langage naturel à l'aide de la suite de bibliothèques ScalaNLP.
• Pratiquer conjointement des techniques avancées telles que la programmation fonctionnelle et la programmation orientée objet.
• Applications de communication hautement concurrentes utilisant des acteurs, une bibliothèque pour la JVM inspirée d'Erlang.
• L'apprentissage automatique utilise des bibliothèques comme Figaro pour la programmation probabiliste et Apache. Spark pour le traitement de données à grande échelle.

Fonctions anonymes

Le langage Scala prend en charge les fonctions anonymes, également appelées littéraux de fonctionComme Scala est un langage fonctionnel, les développeurs décomposent souvent les problèmes complexes en de nombreuses petites tâches et créent de nombreuses fonctions. Pour faciliter cela, Scala permet aux fonctions d'être instancié sans nomVous pouvez les affecter directement à des variables ou à des définitions en utilisant def, comme le montre l'exemple Scala suivant :

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

Vous pouvez ensuite les utiliser comme des fonctions classiques en leur passant des paramètres :

multiplyByTwo(3)
//6

multiplyByThree(4)
//12

Ces méthodes s'avèrent pratiques pour obtenir un code clair et concis. Les fonctions anonymes sont utiles pour définir des méthodes courtes, ne nécessitant que peu de code. Elles sont très simples à créer et ne requièrent aucune formalité particulière.

Ces méthodes ne se limitent pas aux fonctions avec arguments et peuvent être utilisées pour instancier des méthodes qui ne prennent aucun argument.

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

La plupart de ces fonctions anonymes sont utilisées dans d'autres parties du code où l'on a besoin d'une fonction rapide. C'est pourquoi on les appelle aussi… fonctions en ligneL'utilisation de fonctions anonymes est une pratique courante qui apparaît dans toute la bibliothèque de collections pour effectuer rapidement des actions sur une collection.

Par exemple, la méthode filter prend une fonction en ligne pour créer une autre collection ne contenant que les éléments qui répondent aux critères définis dans la fonction anonyme.

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)

Ici, les fonctions anonymes vérifient si la valeur de la liste est paire ou impaire et renvoient l'élément correspondant.

//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, il est également possible d'utiliser des caractères génériques lorsque le paramètre de la fonction anonyme n'est pas nommé. Par exemple :

var timesTwo = (_:Int) * 2

timesTwo(5)
//10

Dans ce cas, vous ne nommez pas le paramètre. Le trait de soulignement est utilisé pour le représenter.

Évaluation paresseuse

La plupart des langages évaluent les variables et les paramètres de fonction séquentiellement, les uns après les autres. En Scala, le mot-clé lazy permet de gérer les valeurs que vous ne souhaitez pas évaluer tant qu'elles ne sont pas référencées.

Une variable déclarée comme paresseuse n'est pas évaluée à l'endroit où elle est définie ; ce phénomène est communément appelé évaluation immédiate. Elle n'est évaluée que lorsqu'elle est référencée ultérieurement dans le code.

Cela peut s'avérer utile lorsque l'évaluation d'une valeur nécessiterait un calcul coûteux. Si la valeur n'est pas toujours nécessaire, vous évitez un calcul onéreux susceptible de ralentir le logiciel en rendant la variable paresseuse.

lazy val myExpensiveValue = expensiveComputation

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

Ce n'est pas le seul cas d'utilisation des variables paresseuses. Elles permettent également de gérer les dépendances circulaires dans le code.

Si l'indicateur de configuration est désactivé, vous n'avez pas besoin d'utiliser myExpensiveValue, ce qui vous évite un calcul coûteux. Cela contribue à garantir une expérience utilisateur optimale, car les ressources ne sont pas gaspillées pour des valeurs qui ne sont jamais lues.

L'évaluation paresseuse est également utile pour les arguments de fonction, qui ne sont utilisés que lorsqu'ils sont référencés à l'intérieur de la fonction. Ce concept est appelé paramètres par leur nom.

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

De nombreux langages utilisent l'approche d'appel par valeur pour l'évaluation des arguments. Un paramètre passé par son nom n'est évalué que lorsque cela est nécessaire dans le corps de la fonction. Une fois évaluée, sa valeur est stockée et peut être réutilisée ultérieurement sans nouvelle évaluation ; ce concept est appelé mémoïsation.

Inférence de type

En Scala, il n'est pas nécessaire de déclarer le type de chaque variable créée, car le compilateur Scala peut l'inférer à partir du membre droit d'une expression. Cela permet d'obtenir un code plus concis et d'éviter d'écrire du code répétitif lorsque le type attendu est évident.

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

Fonction d'ordre supérieur

Une fonction d'ordre supérieur est une fonction qui peut prendre des fonctions comme arguments et renvoyer une fonction. En Scala, les fonctions sont considérées comme des objets de première classe. Cette approche offre une grande flexibilité dans la conception de programmes. Il est possible de créer des fonctions dynamiquement et d'alimenter dynamiquement d'autres fonctions avec des fonctionnalités.

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

Dans la fonction ci-dessus, vous transmettez un Int et une fonction qui prend un Int et renvoie un IntVous pouvez passer en paramètre n'importe quelle fonction possédant cette signature. Par signature, nous entendons les entrées et sorties d'une fonction. Une signature de Int => Int signifie qu'une fonction prend un Int en entrée et renvoie un Int en sortie.

Une signature de () => Int Cela signifie qu'une fonction ne prend aucun argument en entrée et renvoie un entier (Int) en sortie. Un exemple de telle fonction est celle qui génère un entier aléatoire.

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

La fonction ci-dessus possède une signature () => Int.

Une fonction peut également avoir une signature () => UnitCela signifie que la fonction ne prend aucun argument et ne renvoie aucun type. Elle peut en revanche modifier un état ou exécuter une action prédéterminée.

Ces méthodes sont déconseillées car elles peuvent agir comme une boîte noire et affecter le système de manière imprévisible. Elles sont également plus difficiles à tester. Définir explicitement les types d'entrée et de sortie permet de comprendre le fonctionnement de la fonction.

Une fonction d'ordre supérieur peut également renvoyer une fonction. Par exemple, vous pourriez créer une méthode qui renvoie une fonction d'élévation, c'est-à-dire une fonction qui prend un nombre et lui applique une puissance.

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

La fonction ci-dessus prend un Int. Son type de retour est une fonction anonyme qui prend un Int. x et l'utilise comme argument de la fonction puissance.

Curry

En Scala, il est possible de transformer une fonction prenant deux arguments en une fonction n'en prenant qu'un seul à la fois. Lorsqu'un argument est passé, il est appliqué partiellement, et la fonction obtenue prend l'argument restant pour compléter l'appel. La curryfication permet de construire des fonctions en ajoutant progressivement des arguments.

Ceci est utile pour créer des fonctions dynamiquement avant même de disposer d'un ensemble complet d'arguments.

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

Si vous avez besoin d'une fonction qui multiplie par un nombre spécifique, il n'est pas nécessaire de créer une autre méthode de multiplication. Vous pouvez appliquer un argument à la fonction curryfiée et réutiliser le résultat :

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

var multiplyByFive = multiplyTwoNumbers(5) _

multiplyByFive(4)

//returns 20

Correspondance de motif

Scala possède un mécanisme intégré puissant qui vous aide à vérifier si une variable correspond à certains critères, un peu comme une instruction switch. Java ou une chaîne d'instructions if/else. Le langage prend en charge le filtrage par motif, que vous pouvez utiliser pour vérifier si une variable est d'un type particulier. Le filtrage par motif en Scala est puissant et peut déstructurer les composants qui ont un unapply méthode permettant d'obtenir directement les champs qui vous intéressent à partir de la variable mise en correspondance.

Le filtrage par motif de Scala offre également une syntaxe plus agréable qu'une instruction switch.

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

Vous comparez la variable à un ensemble d'options. Lorsque la variable correspond aux critères, l'expression située à droite de la flèche (=>) est évaluée et le résultat de la correspondance est renvoyé.

Le caractère de soulignement permet de repérer les cas qui ne sont pas pris en compte dans le code, reproduisant ainsi le comportement du cas par défaut dans une instruction switch.

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 _ => //unknown type, do something else
}

Dans le code ci-dessus, vous pouvez détecter le type de myItem variable et, sur cette base, se ramifier vers un code spécifique.

La correspondance de modèles vérifie si la variable correspond à chaque cas dans l'ordre.

Le caractère de soulignement sert d'espace réservé et correspond à toute condition que les autres instructions case ne couvrent pas. Vous prenez une variable myItem et appelez le match méthode.

• Vérifier si myItem is true et exécutez la logique à droite de la grosse flèche « => ».
• Utilisez le trait de soulignement pour faire correspondre tout ce qui ne correspond à aucune des instructions case définies dans le code.

Avec les classes de cas, vous pouvez déstructurer la classe pour, par exemple,tracchamps t à l'intérieur de l'objet.

En utilisant le sealed En utilisant le mot-clé `--class` pour définir des classes, vous bénéficiez de l'avantage que le compilateur vérifie exhaustivement les cas que vous essayez de faire correspondre et vous avertit si vous oubliez d'en traiter un.

Immutabilité

Il est possible de créer des valeurs qui ne peuvent pas être modifiées par d'autres fonctions en Scala en utilisant val mot-clé. Ceci est réalisé dans Java En utilisant le final mot-clé. En Scala, vous utilisez un val lors de la création d'une variable au lieu de var, qui est l'alternative pour les variables mutables.

Une variable définie à l'aide de val Le mot-clé est en lecture seule, tandis que celui-ci est défini avec var peuvent être lues et modifiées ultérieurement par d'autres fonctions ou par l'utilisateur dans le code.

var changeableVariable = 8

changeableVariable = 10
//the compiler does not complain, and the code compiles successfully

println(changeableVariable)
//10

val myNumber = 7

myNumber = 4

//this will not compile

Tentative d'attribution d'une valeur à myNumber après l'avoir déclaré comme un val génère une erreur de compilation : « réaffectation à val ».

Pourquoi utiliser l'Immuabilité ?

L'immuabilité empêche les modifications inattendues des valeurs par le code et les autres programmeurs, ce qui pourrait entraîner des résultats imprévisibles. Si les utilisateurs d'une valeur doivent la modifier, ils peuvent en créer une copie. Ainsi, les bogues causés par la modification simultanée d'une même variable par plusieurs acteurs sont évités.

Classes et objets

Les objets sont des entités du monde réel, et une classe est un modèle qui définit ces objets. Les classes possèdent à la fois un état et des comportements. L'état peut être constitué de valeurs ou de variables. Les comportements correspondent aux méthodes en Scala.

La section suivante explique comment définir une classe, l'instancier et l'utiliser en Scala.

Voici une classe appelée Rectangle qui possède deux valeurs et deux fonctions. Vous pouvez également utiliser les paramètres. l et b directement en tant que champs dans le programme. Vous avez un objet qui possède une méthode principale et qui instancie la classe avec deux valeurs.

Exemple :

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 a rectangle with length $length and breadth $breadth"
}
object RectObject {
  def main(args: Array[String]) {
    val rect = new Rectangle(4, 5)
    println(rect.toString)
    println(rect.getArea)
  }
}

En Scala, tous les champs et méthodes sont publics par défaut. Il est essentiel de les utiliser. override car toString est déjà défini pour chaque objet en Scala.

Droit des successions

Scala possède plusieurs types d'héritage (simple, multiniveau, multiple, hiérarchique et hybride) qui partagent de nombreux points communs avec les formes traditionnelles que l'on trouve dans JavaVous pouvez hériter à la fois des classes et des traits. Vous héritez des membres d'une classe dans une autre classe à l'aide du mot-clé `@hit`. extendsCela permet la réutilisation.

Il est possible d'hériter d'une seule classe ou de plusieurs classes. Il est également possible d'hériter de sous-classes qui possèdent elles-mêmes leurs propres superclasses, créant ainsi une hiérarchie d'héritage.

Dans l'exemple Scala ci-dessous, la classe de base est Circle, et la classe dérivée est SphereUn cercle possède une valeur appelée rayon, héritée par la classe Sphere. La méthode calcArea est remplacé à l'aide du mot-clé override.

Exemple :

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

Abdostracproduction

En Scala, vous pouvez créer des abstracméthodes t et champs membres utilisant abstracclasses et caractéristiques. À l'intérieur des abdominauxtract classes et traits, vous pouvez définir abstracchamps t sans les implémenter.

Exemple :

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

Ces champs sont implémentés par les classes qui étendent le trait ou l'abstracclasse t. Vous pouvez utiliser des traits pour créer des classes.tracdéfinir ce qu'une application doit faire, puis implémenter ces méthodes ultérieurement.

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

Ainsi, vous pouvez planifier l'apparence d'une application sans implémenter les méthodes.ping vous imaginez comment les différentes méthodes apparaîtront. Cela suit un modèle connu sous le nom de programmation abstracdes questions plutôt que la mise en œuvre concrète.

Une classe précédée du abstract Le mot-clé peut contenir à la fois abstract et non-abstracméthodes t. Cependant, l'héritage multiple n'est pas pris en charge dans abstracclasses t, vous ne pouvez donc étendre qu'un seul abstracclasse t.

Objets Singleton

Un singleton est une classe instanciée une seule fois dans un programme. Il provient d'un modèle de programmation populaire et utile appelé « modèle singleton ». Il est particulièrement utile pour créer des instances destinées à avoir une longue durée de vie et à être fréquemment utilisées dans le programme, lorsque l'état est essentiel à la coordination des événements au sein du système. Créer une telle classe en Scala est simple, car Scala offre un moyen facile de créer des singletons. object mot-clé.

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

Vous pouvez ensuite faire référence à cet objet dans tout le programme, avec la garantie que toutes les parties du programme verront les mêmes données, car il n'existe qu'une seule instance de celui-ci.

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

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

Le concept de membres statiques n'existe pas en Scala, c'est pourquoi on utilise des objets singleton qui se comportent comme des membres statiques d'une classe.

Classes implicites

Les classes implicites sont une fonctionnalité ajoutée dans la version 2.10 et sont principalement utilisées pour ajouter de nouvelles fonctionnalités aux classes fermées existantes.

Le implicit Le mot-clé doit être défini dans une classe, un objet ou un trait. Le constructeur principal d'une classe implicite doit avoir exactement un argument dans sa première liste de paramètres. Il peut également inclure une liste de paramètres implicites supplémentaires.

Dans l'exemple Scala ci-dessous, une nouvelle fonctionnalité permettant de remplacer les voyelles d'une chaîne de caractères par * a été ajoutée.

object StringUtil {
  implicit class StringEnhancer(str: String) {

    def replaceVowelWithStar: String = str.replaceAll("[aeiou]", "*")
  }
}

Vous devez importer la classe implicite dans la classe où vous l'utilisez.

import StringUtil.StringEnhancer

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

Programmation orientée objet (POO) vs. Programmation fonctionnelle (PF)

En POO, les programmes sont construits par groupesping Les données et les fonctions qui les manipulent sont organisées en unités hautement interconnectées. Les objets contiennent leurs données dans des champs et les méthodes opèrent sur ces champs. Dans ce style de programmation, les principaux éléments sont…tracLa finalité réside dans les données, car les méthodes créées sont destinées à fonctionner sur ces données.

Programmation fonctionnelleEn revanche, elle sépare les données et les fonctions qui les manipulent. Cela permet aux développeurs de traiter les fonctions comme des entités absolues.traction et force motrice lors de la modélisation des programmes.

Scala permet la programmation fonctionnelle en traitant les fonctions comme des objets de première classe, autorisant ainsi leur passage en paramètre à d'autres fonctions et leur retour en paramètre. La combinaison de ces deux paradigmes fait de Scala un excellent choix pour le développement de logiciels complexes dans des secteurs tels que la science des données.

Frameworks importants sur Scala

Voici quelques frameworks importants pour Scala :

• JOUER est un framework d'application Web open source qui utilise Architecture MVCSorti en 2007 et désormais sous licence Apache, il est devenu l'un des frameworks les plus populaires sur GitHub dès 2013. Des entreprises comme LinkedIn, WalmartSamsung et Eero utilisent ce framework.
• Hauteur de levage Lift est un autre framework web gratuit écrit en Scala et lancé en 2007. Foursquare utilise le framework Lift, un framework performant et rapide à mettre en œuvre.
• Akka fournit une boîte à outils pour la création d'applications pilotées par messages hautement concurrentes, distribuées et résilientes sur la JVM.
• Chats est une bibliothèque qui fournit des abstractions pour la programmation fonctionnelle.
• Spark est un moteur d'analyse unifié pour le traitement de données à grande échelle, largement utilisé dans les flux de travail de big data et d'apprentissage automatique.

Prise en charge de la concurrence

• Les valeurs en Scala sont immuables par défaut, ce qui le rend très adaptable aux environnements concurrents.
• Scala possède de nombreuses caractéristiques qui en font un langage idéal pour les applications concurrentes.
• Futures and Promises facilite le traitement des données de manière asynchrone, prenant ainsi en charge le parallélisme.
• Akka est une boîte à outils qui utilise le modèle de concurrence Actor. Les acteurs agissent lorsqu'ils reçoivent des messages.
• Concurrence utilisant les threads de Java est également pris en charge en Scala.
• Le traitement de flux est une autre fonctionnalité remarquable qui permet un traitement continu et en temps réel des données.

Scala possède certaines des meilleures bibliothèques de concurrence du marché. Java écosystème :

• Originaire Java threads.
• Fibres issues de bibliothèques comme Vertx.
• ZIO, une bibliothèque qui possède des primitives permettant de gérer la concurrence et le calcul asynchrone.
• Mémoire transactionnelle logicielle (STM) pour les transactions.
• Future, qui est intégré au langage Scala.

Java contre Scala

Voici les principaux différences entre Java et Scala.

FAQ