Scala - Guide rapide

Scala, abréviation de Scalable Language, est un langage de programmation fonctionnel hybride. Il a été créé par Martin Odersky. Scala intègre en douceur les fonctionnalités des langages fonctionnels et orientés objet. Scala est compilé pour s'exécuter sur la machine virtuelle Java. De nombreuses entreprises existantes, qui dépendent de Java pour leurs applications critiques, se tournent vers Scala pour augmenter leur productivité de développement, l'évolutivité de leurs applications et leur fiabilité globale.

Nous avons présenté ici quelques points qui font de Scala le premier choix des développeurs d'applications.

Scala est orienté objet

Scala est un pur langage orienté objet dans le sens où chaque valeur est un objet. Les types et le comportement des objets sont décrits par des classes et des traits qui seront expliqués dans les chapitres suivants.

Les cours sont prolongés de subclassing et un flexible mixin-based composition mécanisme comme un remplacement propre pour l'héritage multiple.

Scala est fonctionnel

Scala est également un langage fonctionnel dans le sens où chaque fonction est une valeur et chaque valeur est un objet, donc finalement chaque fonction est un objet.

Scala fournit une syntaxe légère pour définir anonymous functions, Elle supporte higher-order functions, il permet aux fonctions d'être nestedet prend en charge currying. Ces concepts seront expliqués dans les chapitres suivants.

Scala est typé statiquement

Scala, contrairement à certains des autres langages à typage statique (C, Pascal, Rust, etc.), ne s'attend pas à ce que vous fournissiez des informations de type redondantes. Vous n'êtes pas obligé de spécifier un type dans la plupart des cas, et vous n'avez certainement pas à le répéter.

Scala s'exécute sur la JVM

Scala est compilé en Java Byte Code qui est exécuté par la machine virtuelle Java (JVM). Cela signifie que Scala et Java ont une plate-forme d'exécution commune. Vous pouvez facilement passer de Java à Scala.

Le compilateur Scala compile votre code Scala en code d'octet Java, qui peut ensuite être exécuté par le 'scala'commande. Le 'scala'est similaire à la commande java commande, en ce qu'elle exécute votre code Scala compilé.

Scala peut exécuter du code Java

Scala vous permet d'utiliser toutes les classes du SDK Java ainsi que vos propres classes Java personnalisées ou vos projets open source Java préférés.

Scala peut effectuer un traitement simultané et synchronisé

Scala vous permet d'exprimer des modèles de programmation généraux de manière efficace. Il réduit le nombre de lignes et aide le programmeur à coder de manière sécurisée. Il vous permet d'écrire des codes de manière immuable, ce qui facilite l'application de la concurrence et du parallélisme (Synchroniser).

Scala contre Java

Scala a un ensemble de fonctionnalités qui diffèrent complètement de Java. Certains d'entre eux sont -

  • Tous les types sont des objets
  • Inférence de type
  • Fonctions imbriquées
  • Les fonctions sont des objets
  • Prise en charge du langage DSL (Domain Specific Language)
  • Traits
  • Closures
  • Prise en charge de la concurrence inspirée par Erlang

Cadres Web Scala

Scala est utilisé partout et surtout dans les applications Web d'entreprise. Vous pouvez consulter quelques-uns des frameworks Web Scala les plus populaires -

  • Le cadre Lift

  • Le cadre Play

  • Le cadre Bowler

Scala peut être installé sur n'importe quel système UNIX ou Windows. Avant de commencer à installer Scala sur votre machine, vous devez avoir Java 1.8 ou supérieur installé sur votre ordinateur.

Suivez les étapes ci-dessous pour installer Scala.

Étape 1: Vérifiez votre installation Java

Tout d'abord, vous devez disposer du kit de développement logiciel Java (SDK) installé sur votre système. Pour vérifier cela, exécutez l'une des deux commandes suivantes en fonction de la plate-forme sur laquelle vous travaillez.

Si l'installation de Java a été effectuée correctement, la version actuelle et les spécifications de votre installation Java seront affichées. Un exemple de sortie est donné dans le tableau suivant.

Plate-forme Commander Exemple de sortie
les fenêtres

Ouvrez la console de commande et tapez -

\>java –version

Version Java "1.8.0_31"

Durée d'exécution de Java (TM) SE

Environnement (build 1.8.0_31-b31)

Serveur 64 bits Java Hotspot (TM)

VM (build 25.31-b07, mode mixte)

Linux

Ouvrez le terminal de commande et tapez -

$java –version

Version Java "1.8.0_31"

Ouvrir l'environnement d'exécution JDK (rhel-2.8.10.4.el6_4-x86_64)

Ouvrez la machine virtuelle du serveur JDK 64 bits (build 25.31-b07, mode mixte)

Nous supposons que les lecteurs de ce didacticiel ont installé la version 1.8.0_31 du SDK Java sur leur système.

Si vous ne disposez pas du SDK Java, téléchargez sa version actuelle sur http://www.oracle.com/technetwork/java/javase/downloads/index.html et installez-le.

Étape 2: définissez votre environnement Java

Définissez la variable d'environnement JAVA_HOME pour qu'elle pointe vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple,

Sr.Non Plateforme et description
1

Windows

Définissez JAVA_HOME sur C: \ ProgramFiles \ java \ jdk1.7.0_60

2

Linux

Exporter JAVA_HOME = / usr / local / java-current

Ajoutez le chemin complet de l'emplacement du compilateur Java au chemin système.

Sr.Non Plateforme et description
1

Windows

Ajoutez la chaîne «C: \ Program Files \ Java \ jdk1.7.0_60 \ bin» à la fin de la variable système PATH.

2

Linux

Exporter PATH = $ PATH: $ JAVA_HOME / bin /

Exécutez la commande java -version à partir de l'invite de commande comme expliqué ci-dessus.

Étape 3: Installez Scala

Vous pouvez télécharger Scala depuis http://www.scala-lang.org/downloads. Au moment de la rédaction de ce tutoriel, j'ai téléchargé «scala-2.11.5-installer.jar». Assurez-vous que vous disposez des privilèges d'administrateur pour continuer. Maintenant, exécutez la commande suivante à l'invite de commande -

Plate-forme Commande et sortie La description
les fenêtres

\> java –jar scala-2.11.5-installer.jar \>

Cette commande affichera un assistant d'installation, qui vous guidera pour installer Scala sur votre machine Windows. Lors de l'installation, il demandera un accord de licence, acceptez-le simplement et ensuite il demandera un chemin où Scala sera installé. J'ai sélectionné le chemin d'accès par défaut "C: \ Program Files \ Scala", vous pouvez sélectionner un chemin approprié selon votre convenance.

Linux

Command -

$ java –jar scala-2.9.0.1-installer.jar

Output -

Bienvenue dans l'installation de Scala 2.9.0.1!

La page d'accueil est à - http://Scala-lang.org/

appuyez sur 1 pour continuer, 2 pour quitter, 3 pour réafficher

1................................................

[Début du déballage]

[Package de traitement: Installation du package logiciel (1/1)]

[Déballage terminé]

[Installation de la console terminée]

Lors de l'installation, il demandera un accord de licence, pour l'accepter de type 1 et il demandera un chemin où Scala sera installé. J'ai entré / usr / local / share, vous pouvez sélectionner un chemin approprié selon votre convenance.

Enfin, ouvrez une nouvelle invite de commande et tapez Scala -versionet appuyez sur Entrée. Vous devriez voir ce qui suit -

Plate-forme Commander Production
les fenêtres

\> scala -version

Scala code runner version 2.11.5 - Copyright 2002-2013, LAMP / EPFL

Linux

$ scala -version

Scala code runner version 2.9.0.1 - Copyright 2002-2013, LAMP / EPFL

Si vous avez une bonne compréhension de Java, il vous sera très facile d'apprendre Scala. La plus grande différence syntaxique entre Scala et Java est que le ';' le caractère de fin de ligne est facultatif.

Lorsque nous considérons un programme Scala, il peut être défini comme une collection d'objets qui communiquent en invoquant les méthodes de chacun. Voyons maintenant brièvement ce que signifient la classe, l'objet, les méthodes et les variables d'instance.

  • Object- Les objets ont des états et des comportements. Un objet est une instance d'une classe. Exemple - Un chien a des états - couleur, nom, race ainsi que comportements - remuant, aboyant et mangeant.

  • Class - Une classe peut être définie comme un modèle / plan qui décrit les comportements / états liés à la classe.

  • Methods- Une méthode est essentiellement un comportement. Une classe peut contenir de nombreuses méthodes. C'est dans les méthodes que les logiques sont écrites, les données sont manipulées et toutes les actions sont exécutées.

  • Fields- Chaque objet a son ensemble unique de variables d'instance, appelées champs. L'état d'un objet est créé par les valeurs affectées à ces champs.

  • Closure - Un closure est une fonction, dont la valeur de retour dépend de la valeur d'une ou plusieurs variables déclarées en dehors de cette fonction.

  • Traits- Un trait encapsule les définitions de méthode et de champ, qui peuvent ensuite être réutilisées en les mélangeant dans des classes. Les traits sont utilisés pour définir les types d'objets en spécifiant la signature des méthodes prises en charge.

Premier programme Scala

Nous pouvons exécuter un programme Scala dans deux modes: l'un est interactive mode et un autre est script mode.

Mode interactif

Ouvrez l'invite de commande et utilisez la commande suivante pour ouvrir Scala.

\>scala

Si Scala est installé sur votre système, la sortie suivante sera affichée -

Welcome to Scala version 2.9.0.1
Type in expressions to have them evaluated.
Type :help for more information.

Tapez le texte suivant à droite de l'invite Scala et appuyez sur la touche Entrée -

scala> println("Hello, Scala!");

Cela produira le résultat suivant -

Hello, Scala!

Mode script

Utilisez les instructions suivantes pour écrire un programme Scala en mode script. Ouvrez le bloc-notes et ajoutez-y le code suivant.

Exemple

object HelloWorld {
   /* This is my first java program.  
   * This will print 'Hello World' as the output
   */
   def main(args: Array[String]) {
      println("Hello, world!") // prints Hello World
   }
}

Enregistrez le fichier sous - HelloWorld.scala.

Ouvrez la fenêtre d'invite de commande et accédez au répertoire dans lequel le fichier programme est enregistré. Le 'scalacLa commande 'est utilisée pour compiler le programme Scala et elle générera quelques fichiers de classe dans le répertoire courant. L'un d'eux sera appeléHelloWorld.class. Il s'agit d'un bytecode qui s'exécutera sur la machine virtuelle Java (JVM) en utilisant 'scala'commande.

Utilisez la commande suivante pour compiler et exécuter votre programme Scala.

\> scalac HelloWorld.scala
\> scala HelloWorld

Production

Hello, World!

Syntaxe de base

Voici les syntaxes de base et les conventions de codage de la programmation Scala.

  • Case Sensitivity - Scala est sensible à la casse, ce qui signifie identifiant Hello et hello aurait une signification différente dans Scala.

  • Class Names- Pour tous les noms de classe, la première lettre doit être en majuscules. Si plusieurs mots sont utilisés pour former un nom de classe, la première lettre de chaque mot interne doit être en majuscules.

    Example - classe MyFirstScalaClass.

  • Method Names- Tous les noms de méthode doivent commencer par une lettre minuscule. Si plusieurs mots sont utilisés pour former le nom de la méthode, la première lettre de chaque mot interne doit être en majuscules.

    Example - def myMethodName ()

  • Program File Name- Le nom du fichier programme doit correspondre exactement au nom de l'objet. Lors de l'enregistrement du fichier, vous devez l'enregistrer en utilisant le nom de l'objet (n'oubliez pas que Scala est sensible à la casse) et ajouter '.scala'à la fin du nom. (Si le nom du fichier et le nom de l'objet ne correspondent pas, votre programme ne sera pas compilé).

    Example- Supposons que «HelloWorld» soit le nom de l'objet. Ensuite, le fichier doit être enregistré sous «HelloWorld.scala».

  • def main(args: Array[String]) - Le traitement du programme Scala commence à partir de la méthode main () qui est une partie obligatoire de chaque programme Scala.

Identificateurs Scala

Tous les composants Scala nécessitent des noms. Les noms utilisés pour les objets, classes, variables et méthodes sont appelés identificateurs. Un mot-clé ne peut pas être utilisé comme identifiant et les identifiants sont sensibles à la casse. Scala prend en charge quatre types d'identificateurs.

Identifiants alphanumériques

Un identifiant alphanumérique commence par une lettre ou un trait de soulignement, qui peut être suivi d'autres lettres, chiffres ou traits de soulignement. Le caractère '$' est un mot clé réservé dans Scala et ne doit pas être utilisé dans les identificateurs.

Voici legal alphanumeric identifiers -

age, salary, _value,  __1_value

Voici illegal identifiers -

$salary, 123abc, -salary

Identificateurs d'opérateur

Un identifiant d'opérateur se compose d'un ou plusieurs caractères d'opérateur. Les caractères de l'opérateur sont des caractères ASCII imprimables tels que +,:,?, ~ Ou #.

Voici les identifiants des opérateurs légaux -

+ ++ ::: <?> :>

Le compilateur Scala "mangle" en interne les identifiants d'opérateurs pour les transformer en identifiants Java légaux avec des caractères $ incorporés. Par exemple, l'identifiant: -> serait représenté en interne comme$colon$moins $ supérieur.

Identifiants mixtes

Un identifiant mixte se compose d'un identifiant alphanumérique, qui est suivi d'un trait de soulignement et d'un identifiant d'opérateur.

Voici les identifiants mixtes juridiques -

unary_+,  myvar_=

Ici, unary_ + utilisé comme nom de méthode définit un opérateur unaire + et myvar_ = utilisé comme nom de méthode définit un opérateur d'affectation (surcharge d'opérateur).

Identificateurs littéraux

Un identificateur littéral est une chaîne arbitraire entre des graduations inverses («...»).

Voici les identificateurs littéraux légaux -

`x` `<clinit>` `yield`

Mots-clés Scala

La liste suivante montre les mots réservés dans Scala. Ces mots réservés ne peuvent pas être utilisés comme constantes ou variables ou tout autre nom d'identifiant.

abstrait Cas capture classe
def faire autre étend
faux final enfin pour
pour certains si implicite importer
paresseux rencontre Nouveau Nul
objet passer outre paquet privé
protégé revenir scellé super
ce jeter trait Essayer
vrai type val Var
tandis que avec rendement  
- : = =>
<- <: <% >:
# @

Commentaires dans Scala

Scala prend en charge les commentaires sur une et plusieurs lignes très similaires à Java. Les commentaires sur plusieurs lignes peuvent être imbriqués, mais doivent être correctement imbriqués. Tous les caractères disponibles dans n'importe quel commentaire sont ignorés par le compilateur Scala.

object HelloWorld {
   /* This is my first java program.  
    * This will print 'Hello World' as the output
    * This is an example of multi-line comments.
    */
   def main(args: Array[String]) {
      // Prints Hello World
      // This is also an example of single line comment.
      println("Hello, world!") 
   }
}

Lignes vierges et espaces

Une ligne ne contenant que des espaces, éventuellement avec un commentaire, est connue comme une ligne vide, et Scala l'ignore totalement. Les jetons peuvent être séparés par des espaces et / ou des commentaires.

Caractères de nouvelle ligne

Scala est un langage orienté ligne où les instructions peuvent être terminées par des points-virgules (;) ou des retours à la ligne. Un point-virgule à la fin d'une instruction est généralement facultatif. Vous pouvez en taper un si vous le souhaitez, mais ce n'est pas obligatoire si l'instruction apparaît d'elle-même sur une seule ligne. En revanche, un point-virgule est requis si vous écrivez plusieurs instructions sur une seule ligne. La syntaxe ci-dessous est l'utilisation de plusieurs instructions.

val s = "hello"; println(s)

Scala: formules de vacances

Un package est un module de code nommé. Par exemple, le package de l'utilitaire Lift est net.liftweb.util. La déclaration du package est la première ligne sans commentaire dans le fichier source comme suit -

package com.liftcode.stuff

Les packages Scala peuvent être importés pour pouvoir être référencés dans la portée de compilation actuelle. L'instruction suivante importe le contenu du package scala.xml -

import scala.xml._

Vous pouvez importer une seule classe et un seul objet, par exemple, HashMap à partir du package scala.collection.mutable -

import scala.collection.mutable.HashMap

Vous pouvez importer plusieurs classes ou objets à partir d'un seul package, par exemple, TreeMap et TreeSet à partir du package scala.collection.immutable -

import scala.collection.immutable.{TreeMap, TreeSet}

Appliquer dynamique

Un trait de marqueur qui permet des invocations dynamiques. Les instances x de ce trait permettent les invocations de méthodes x.meth (args) pour les noms de méthodes arbitraires meth et les listes d'arguments args ainsi que les accès aux champs x.field pour les champs de noms de champs arbitraires. Cette fonctionnalité est introduite dans Scala-2.10.

Si un appel n'est pas supporté nativement par x (c'est-à-dire si la vérification de type échoue), il est réécrit selon les règles suivantes -

foo.method("blah") ~~> foo.applyDynamic("method")("blah")
foo.method(x = "blah") ~~> foo.applyDynamicNamed("method")(("x", "blah"))
foo.method(x = 1, 2) ~~> foo.applyDynamicNamed("method")(("x", 1), ("", 2))
foo.field ~~> foo.selectDynamic("field")
foo.varia = 10 ~~> foo.updateDynamic("varia")(10)
foo.arr(10) = 13 ~~> foo.selectDynamic("arr").update(10, 13)
foo.arr(10) ~~> foo.applyDynamic("arr")(10)

Scala a tous les mêmes types de données que Java, avec la même empreinte mémoire et la même précision. Voici le tableau donnant des détails sur tous les types de données disponibles dans Scala -

Sr.Non Type de données et description
1

Byte

Valeur signée 8 bits. Gamme de -128 à 127

2

Short

Valeur signée 16 bits. Gamme -32768 à 32767

3

Int

Valeur signée 32 bits. Plage -2147483648 à 2147483647

4

Long

Valeur signée 64 bits. -9223372036854775808 à 9223372036854775807

5

Float

Flotteur simple précision IEEE 754 32 bits

6

Double

Flotteur double précision IEEE 754 64 bits

sept

Char

Caractère Unicode non signé 16 bits. Plage de U + 0000 à U + FFFF

8

String

Une séquence de caractères

9

Boolean

Soit le littéral vrai, soit le littéral faux

dix

Unit

Ne correspond à aucune valeur

11

Null

référence nulle ou vide

12

Nothing

Le sous-type de tous les autres types; n'inclut aucune valeur

13

Any

Le supertype de tout type; tout objet est de type Any

14

AnyRef

Le supertype de tout type de référence

Tous les types de données répertoriés ci-dessus sont des objets. Il n'y a pas de types primitifs comme en Java. Cela signifie que vous pouvez appeler des méthodes sur un Int, un Long, etc.

Littéraux de base Scala

Les règles utilisées par Scala pour les littéraux sont simples et intuitives. Cette section explique tous les littéraux Scala de base.

Littéraux intégraux

Les littéraux entiers sont généralement de type Int, ou de type Long lorsqu'ils sont suivis d'un suffixe L ou l. Voici quelques littéraux entiers -

0
035
21 
0xFFFFFFFF 
0777L

Littéral à virgule flottante

Les littéraux à virgule flottante sont de type Float lorsqu'ils sont suivis d'un suffixe de type à virgule flottante F ou f, et sont de type Double dans le cas contraire. Voici quelques littéraux en virgule flottante -

0.0 
1e30f 
3.14159f 
1.0e100
.1

Littéraux booléens

Les littéraux booléens true et false sont des membres de type Boolean.

Littéraux de symboles

Un symbole littéral 'x est un raccourci pour l'expression scala.Symbol("x"). Symbol est une classe de cas, qui est définie comme suit.

package scala
final case class Symbol private (name: String) {
   override def toString: String = "'" + name
}

Littéraux de caractères

Un littéral de caractère est un seul caractère entre guillemets. Le caractère est un caractère Unicode imprimable ou est décrit par une séquence d'échappement. Voici quelques littéraux de caractères -

'a' 
'\u0041'
'\n'
'\t'

Littéraux de chaîne

Un littéral de chaîne est une séquence de caractères entre guillemets. Les caractères sont des caractères Unicode imprimables ou sont décrits par des séquences d'échappement. Voici quelques littéraux de chaîne -

"Hello,\nWorld!"
"This string contains a \" character."

Cordes multilignes

Un littéral de chaîne multiligne est une séquence de caractères entre guillemets triples "" "..." "". La séquence de caractères est arbitraire, sauf qu'elle peut contenir trois ou plusieurs guillemets consécutifs uniquement à la toute fin.

Les caractères ne doivent pas nécessairement être imprimables; les retours à la ligne ou autres caractères de contrôle sont également autorisés. Voici un littéral de chaîne multiligne -

"""the present string
spans three
lines."""

Valeurs nulles

La valeur nulle est de type scala.Nullet est donc compatible avec tous les types de référence. Il désigne une valeur de référence qui fait référence à un objet spécial "nul".

Séquences d'échappement

Les séquences d'échappement suivantes sont reconnues dans les littéraux de caractères et de chaînes.

Séquences d'échappement Unicode La description
\ b \ u0008 retour arrière BS
\ t \ u0009 onglet horizontal HT
\ n \ u000c formfeed FF
\F \ u000c formfeed FF
\ r \ u000d retour chariot CR
\ " \ u0022 double citation "
\ ' \ u0027 simple citation .
\\ \ u005c barre oblique inverse \

Un caractère avec Unicode entre 0 et 255 peut également être représenté par un échappement octal, c'est-à-dire une barre oblique inverse «\» suivie d'une séquence de trois caractères octaux maximum. Voici l'exemple pour montrer quelques caractères de séquence d'échappement -

Exemple

object Test {
   def main(args: Array[String]) {
      println("Hello\tWorld\n\n" );
   }
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Production

Hello   World

Les variables ne sont rien d'autre que des emplacements de mémoire réservés pour stocker des valeurs. Cela signifie que lorsque vous créez une variable, vous réservez de l'espace en mémoire.

En fonction du type de données d'une variable, le compilateur alloue de la mémoire et décide de ce qui peut être stocké dans la mémoire réservée. Par conséquent, en attribuant différents types de données aux variables, vous pouvez stocker des entiers, des décimales ou des caractères dans ces variables.

Déclaration de variable

Scala a une syntaxe différente pour déclarer les variables. Ils peuvent être définis comme une valeur, c'est-à-dire une constante ou une variable. Ici, myVar est déclaré à l'aide du mot-clé var. C'est une variable qui peut changer de valeur et cela s'appellemutable variable. Voici la syntaxe pour définir une variable en utilisantvar mot-clé -

Syntaxe

var myVar : String = "Foo"

Ici, myVal est déclaré à l'aide du mot-clé val. Cela signifie que c'est une variable qui ne peut pas être modifiée et que cela s'appelleimmutable variable. Voici la syntaxe pour définir une variable à l'aide du mot-clé val -

Syntaxe

val myVal : String = "Foo"

Types de données variables

Le type d'une variable est spécifié après le nom de la variable et avant le signe égal. Vous pouvez définir n'importe quel type de variable Scala en mentionnant son type de données comme suit -

Syntaxe

val or val VariableName : DataType = [Initial Value]

Si vous n'attribuez aucune valeur initiale à une variable, elle est valide comme suit -

Syntaxe

var myVar :Int;
val myVal :String;

Inférence de type variable

Lorsque vous affectez une valeur initiale à une variable, le compilateur Scala peut déterminer le type de la variable en fonction de la valeur qui lui est assignée. C'est ce qu'on appelle l'inférence de type variable. Par conséquent, vous pouvez écrire ces déclarations de variables comme ceci -

Syntaxe

var myVar = 10;
val myVal = "Hello, Scala!";

Ici, par défaut, myVar sera de type Int et myVal deviendra une variable de type String.

Affectations multiples

Scala prend en charge plusieurs affectations. Si un bloc de code ou une méthode renvoie un Tuple (Tuple- Contient une collection d'objets de différents types), le Tuple peut être affecté à une variable val. [Note - Nous étudierons les tuples dans les chapitres suivants.]

Syntaxe

val (myVar1: Int, myVar2: String) = Pair(40, "Foo")

Et l'inférence de type fait les choses correctement -

Syntaxe

val (myVar1, myVar2) = Pair(40, "Foo")

Exemple de programme

Voici un exemple de programme qui explique le processus de déclaration de variable dans Scala. Ce programme déclare quatre variables - deux variables sont définies avec une déclaration de type et deux autres sont sans déclaration de type.

Exemple

object Demo {
   def main(args: Array[String]) {
      var myVar :Int = 10;
      val myVal :String = "Hello Scala with datatype declaration.";
      var myVar1 = 20;
      val myVal1 = "Hello Scala new without datatype declaration.";
      
      println(myVar); println(myVal); println(myVar1); 
      println(myVal1);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

10
Hello Scala with datatype declaration.
20
Hello Scala without datatype declaration.

Portée variable

Les variables dans Scala peuvent avoir trois portées différentes selon l'endroit où elles sont utilisées. Ils peuvent exister sous forme de champs, de paramètres de méthode et de variables locales. Vous trouverez ci-dessous les détails de chaque type de portée.

Des champs

Les champs sont des variables appartenant à un objet. Les champs sont accessibles de l'intérieur de chaque méthode de l'objet. Les champs peuvent également être accessibles en dehors de l'objet en fonction des modificateurs d'accès avec lesquels le champ est déclaré. Les champs d'objet peuvent être à la fois des types mutables et immuables et peuvent être définis en utilisant soitvar ou val.

Paramètres de méthode

Les paramètres de méthode sont des variables utilisées pour transmettre la valeur à l'intérieur d'une méthode, lorsque la méthode est appelée. Les paramètres de méthode ne sont accessibles que de l'intérieur de la méthode, mais les objets passés peuvent être accessibles de l'extérieur, si vous avez une référence à l'objet depuis l'extérieur de la méthode. Les paramètres de méthode sont toujours immuables et définis parval mot-clé.

Variables locales

Les variables locales sont des variables déclarées à l'intérieur d'une méthode. Les variables locales ne sont accessibles que depuis l'intérieur de la méthode, mais les objets que vous créez peuvent échapper à la méthode si vous les renvoyez depuis la méthode. Les variables locales peuvent être à la fois des types mutables et immuables et peuvent être définies en utilisant soitvar ou val.

Ce chapitre vous explique comment utiliser les classes et les objets dans la programmation Scala. Une classe est un plan pour les objets. Une fois que vous avez défini une classe, vous pouvez créer des objets à partir du plan de classe avec le mot-clénew. Grâce à l'objet, vous pouvez utiliser toutes les fonctionnalités de la classe définie.

Le diagramme suivant montre la classe et l'objet en prenant un exemple de classe student, qui contient les variables membres (name et roll no) et les méthodes membres (setName () et setRollNo ()). Enfin, tous sont membres de la classe. La classe est un plan et les objets sont réels ici. Dans le diagramme suivant, Student est une classe et Harini, John et Maria sont les objets de la classe Student, ceux-ci ont un nom et un numéro de rôle.

Classe de base

Voici une syntaxe simple pour définir une classe de base dans Scala. Cette classe définit deux variablesx et y et une méthode: move, qui ne renvoie pas de valeur. Les variables de classe sont appelées, les champs de la classe et les méthodes sont appelés méthodes de classe.

Le nom de classe fonctionne comme un constructeur de classe qui peut prendre un certain nombre de paramètres. Le code ci-dessus définit deux arguments de constructeur,xc et yc; ils sont tous deux visibles dans tout le corps de la classe.

Syntaxe

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

Comme mentionné précédemment dans ce chapitre, vous pouvez créer des objets à l'aide d'un mot-clé new puis vous pouvez accéder aux champs de classe et aux méthodes comme indiqué ci-dessous dans l'exemple -

Exemple

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

object Demo {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // Move to a new location
      pt.move(10, 10);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Point x location : 20
Point y location : 30

Extension d'une classe

Vous pouvez étendre une classe Scala de base et concevoir une classe héritée de la même manière que vous le faites en Java (utilisez extends mot clé), mais il y a deux restrictions: la substitution de méthode nécessite le override mot-clé, et seulement le primaryLe constructeur peut transmettre des paramètres au constructeur de base. Étendons notre classe ci-dessus et ajoutons une autre méthode de classe.

Exemple

Prenons un exemple de deux classes La classe Point (comme le même exemple que ci-dessus) et la classe Location est une classe héritée à l'aide du mot-clé extend. Un tel 'extendsLa clause 'a deux effets: elle fait que la classe Location hérite de tous les membres non privés de la classe Point, et elle fait du type Location un sous-type du type Classe Point . Donc ici la classe Point est appeléesuperclasset la classe Location est appeléesubclass. L'extension d'une classe et l'héritage de toutes les fonctionnalités d'une classe parent s'appellentinheritance mais Scala permet l'héritage d'une seule classe seulement.

Note - Méthodes méthode move () dans la classe Point et move() method in Location class ne remplacez pas les définitions de déplacement correspondantes car ce sont des définitions différentes (par exemple, la première prend deux arguments tandis que la seconde prend trois arguments).

Essayez l'exemple de programme suivant pour implémenter l'héritage.

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("Point x location : " + x);
      println ("Point y location : " + y);
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("Point x location : " + x);
      println ("Point y location : " + y);
      println ("Point z location : " + z);
   }
}

object Demo {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // Move to a new location
      loc.move(10, 10, 5);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Point x location : 20
Point y location : 30
Point z location : 20

Classes implicites

Les classes implicites permettent des conversations implicites avec le constructeur principal de la classe lorsque la classe est dans la portée. La classe implicite est une classe marquée par un mot clé «implicite». Cette fonctionnalité est introduite dans Scala 2.10.

Syntax- Voici la syntaxe des classes implicites. Ici, la classe implicite est toujours dans la portée de l'objet où toutes les définitions de méthode sont autorisées car la classe implicite ne peut pas être une classe de niveau supérieur.

Syntaxe

object <object name> {
   implicit class <class name>(<Variable>: Data type) {
      def <method>(): Unit =
   }
}

Exemple

Prenons un exemple d'une classe implicite nommée IntTimesavec la méthode times (). Cela signifie que times () contient une transaction en boucle qui exécutera l'instruction donnée le nombre de fois que nous donnons. Supposons que l'instruction donnée soit «4 fois println (« Hello »)» signifie que l'instruction println («» Hello ») s'exécutera 4 fois.

Voici le programme de l'exemple donné. Dans cet exemple, deux classes d'objets sont utilisées (Exécuter et Démo) afin que nous devions enregistrer ces deux classes dans des fichiers différents avec leurs noms respectifs comme suit.

Run.scala - Enregistrez le programme suivant dans Run.scala.

object Run {
   implicit class IntTimes(x: Int) {
      def times [A](f: =>A): Unit = {
         def loop(current: Int): Unit =
         
         if(current > 0){
            f
            loop(current - 1)
         }
         loop(x)
      }
   }
}

Demo.scala - Enregistrez le programme suivant dans Demo.scala.

import Run._

object Demo {
   def main(args: Array[String]) {
      4 times println("hello")
   }
}

Les commandes suivantes sont utilisées pour compiler et exécuter ces deux programmes.

Commander

\>scalac Run.scala
\>scalac Demo.scala
\>scala Demo

Production

Hello
Hello
Hello
Hello

Note -

  • Les classes implicites doivent être définies dans une autre classe / objet / trait (pas au niveau supérieur).

  • Les classes implicites ne peuvent accepter qu'un seul argument non implicite dans leur constructeur.

  • Les classes implicites ne peuvent pas être une méthode, un membre ou un objet de la portée portant le même nom que la classe implicite.

Objets Singleton

Scala est plus orienté objet que Java car dans Scala, nous ne pouvons pas avoir de membres statiques. Au lieu de cela, Scala asingleton objects. Un singleton est une classe qui ne peut avoir qu'une seule instance, à savoir, Object. Vous créez un singleton à l'aide du mot-cléobjectau lieu du mot-clé de classe. Comme vous ne pouvez pas instancier un objet singleton, vous ne pouvez pas passer de paramètres au constructeur principal. Vous avez déjà vu tous les exemples utilisant des objets singleton où vous avez appelé la méthode principale de Scala.

Voici le même exemple de programme pour implémenter singleton.

Exemple

import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Demo {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("Point x location : " + point.x);
         println ("Point y location : " + point.y);
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Point x location : 10
Point y location : 20

Ce chapitre vous présente les modificateurs d'accès Scala. Les membres des packages, classes ou objets peuvent être étiquetés avec les modificateurs d'accès private et protected, et si nous n'utilisons aucun de ces deux mots-clés, alors l'accès sera considéré comme public. Ces modificateurs limitent les accès des membres à certaines régions de code. Pour utiliser un modificateur d'accès, vous incluez son mot-clé dans la définition des membres du package, de la classe ou de l'objet comme nous le verrons dans la section suivante.

Membres privés

Un membre privé est visible uniquement à l'intérieur de la classe ou de l'objet qui contient la définition de membre.

Voici l'exemple d'extrait de code pour expliquer le membre privé -

Exemple

class Outer {
   class Inner {
      private def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // Error: f is not accessible
}

Dans Scala, l'accès (nouveau Inner). f () est illégal parce que f est déclaré privé dans Inner et que l'accès ne provient pas de la classe Inner. En revanche, le premier accès à f dans la classe Innermost est OK, car cet accès est contenu dans le corps de la classe Inner. Java autoriserait les deux accès car il permet à une classe externe d'accéder aux membres privés de ses classes internes.

Membres protégés

Un membre protégé n'est accessible qu'à partir des sous-classes de la classe dans laquelle le membre est défini.

Voici l'exemple d'extrait de code pour expliquer le membre protégé -

Exemple

package p {
   class Super {
      protected def f() { println("f") }
   }
   
   class Sub extends Super {
      f()
   }
   
   class Other {
      (new Super).f() // Error: f is not accessible
   }
}

L'accès à f dans la classe Sub est OK car f est déclaré protégé dans la classe 'Super' et la classe 'Sub' est une sous-classe de Super. En revanche, l'accès à f dans la classe «Autre» n'est pas autorisé, car la classe «Autre» n'hérite pas de la classe «Super». En Java, ce dernier accès serait toujours autorisé car la classe 'Other' est dans le même package que la classe 'Sub'.

Membres publics

Contrairement aux membres privés et protégés, il n'est pas nécessaire de spécifier le mot clé Public pour les membres Public. Il n'y a pas de modificateur explicite pour les membres publics. Ces membres sont accessibles de n'importe où.

Voici l'exemple d'extrait de code pour expliquer le membre public -

Exemple

class Outer {
   class Inner {
      def f() { println("f") }
      
      class InnerMost {
         f() // OK
      }
   }
   (new Inner).f() // OK because now f() is public
}

Portée de la protection

Les modificateurs d'accès dans Scala peuvent être augmentés avec des qualificatifs. Un modificateur de la forme private [X] ou protected [X] signifie que l'accès est privé ou protégé "jusqu'à" X, où X désigne un package, une classe ou un objet singleton englobant.

Prenons l'exemple suivant -

Exemple

package society {
   package professional {
      class Executive {
         private[professional] var workDetails = null
         private[society] var friends = null
         private[this] var secrets = null

         def help(another : Executive) {
            println(another.workDetails)
            println(another.secrets) //ERROR
         }
      }
   }
}

Note - les points suivants de l'exemple ci-dessus -

  • Les détails de travail variables seront accessibles à toutes les classes du package professionnel.

  • Des amis variables seront accessibles à n'importe quelle classe au sein de la société de paquets englobants.

  • Les secrets de variable ne seront accessibles que sur l'objet implicite dans les méthodes d'instance (this).

Un opérateur est un symbole qui indique au compilateur d'effectuer des manipulations mathématiques ou logiques spécifiques. Scala est riche en opérateurs intégrés et fournit les types d'opérateurs suivants -

  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs logiques
  • Opérateurs au niveau du bit
  • Opérateurs d'affectation

Ce chapitre examinera les opérateurs arithmétique, relationnel, logique, binaire, d'affectation et autres un par un.

Opérateurs arithmétiques

Les opérateurs arithmétiques suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 10 et la variable B vaut 20, alors -

Afficher des exemples

Opérateur La description Exemple
+ Ajoute deux opérandes A + B donnera 30
- Soustrait le deuxième opérande du premier A - B donnera -10
* Multiplie les deux opérandes A * B donnera 200
/ Divise le numérateur par le dénumérateur B / A donnera 2
% L'opérateur de module trouve le reste après la division d'un nombre par un autre B% A donnera 0

Opérateurs relationnels

Les opérateurs relationnels suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 10 et la variable B 20, alors -

Afficher des exemples

Opérateur La description Exemple
== Vérifie si les valeurs de deux opérandes sont égales ou non, si oui, la condition devient vraie. (A == B) n'est pas vrai.
! = Vérifie si les valeurs de deux opérandes sont égales ou non, si les valeurs ne sont pas égales, la condition devient vraie. (A! = B) est vrai.
> Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie. (A> B) n'est pas vrai.
< Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie. (A <B) est vrai.
> = Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. (A> = B) n'est pas vrai.
<= Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie. (A <= B) est vrai.

Opérateurs logiques

Les opérateurs logiques suivants sont pris en charge par le langage Scala. Par exemple, supposons que la variable A vaut 1 et la variable B vaut 0, alors -

Afficher des exemples

Opérateur La description Exemple
&& Il est appelé opérateur ET logique. Si les deux opérandes sont différents de zéro, la condition devient vraie. (A && B) est faux.
|| Il est appelé Opérateur OU logique. Si l'un des deux opérandes est différent de zéro, la condition devient vraie. (A || B) est vrai.
! Il est appelé Opérateur NON logique. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, l'opérateur NOT logique rendra faux. ! (A && B) est vrai.

Opérateurs au niveau du bit

L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit. Les tables de vérité pour &, | et ^ sont les suivantes:

p q p & q p | q p ^ q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

Supposons que A = 60; et B = 13; maintenant au format binaire, ils seront comme suit -

A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011

Les opérateurs Bitwise pris en charge par le langage Scala sont répertoriés dans le tableau suivant. Supposons que la variable A a 60 et la variable B 13, alors -

Afficher des exemples

Opérateur La description Exemple
& L'opérateur binaire AND copie un peu le résultat s'il existe dans les deux opérandes. (A & B) donnera 12, soit 0000 1100
| L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes. (A | B) donnera 61, soit 0011 1101
^ L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux. (A ^ B) donnera 49, soit 0011 0001
~ L'opérateur de complément Binary Ones est unaire et a pour effet de «retourner» les bits. (~ A) donnera -61, soit 1100 0011 sous la forme du complément à 2 en raison d'un nombre binaire signé.
<< Opérateur de décalage binaire gauche. Les positions binaires de la valeur des opérandes de gauche sont déplacées vers la gauche du nombre de bits spécifié par l'opérande de droite. Un << 2 donnera 240, soit 1111 0000
>> Opérateur de décalage binaire vers la droite. Les positions de bits de la valeur d'opérande de gauche sont déplacées vers la droite du nombre de bits spécifié par l'opérande de droite. Un >> 2 donnera 15, soit 1111
>>> Décaler l'opérateur de remplissage zéro vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite et les valeurs décalées sont remplies de zéros. Un >>> 2 donnera 15 qui est 0000 1111

Opérateurs d'affectation

Les opérateurs d'affectation suivants sont pris en charge par le langage Scala -

Afficher des exemples

Opérateur La description Exemple
= Opérateur d'affectation simple, attribue des valeurs d'opérandes de droite à l'opérande de gauche C = A + B attribuera la valeur de A + B à C
+ = Ajouter l'opérateur d'affectation ET, il ajoute l'opérande droit à l'opérande gauche et attribue le résultat à l'opérande gauche C + = A équivaut à C = C + A
- = Soustraire l'opérateur d'affectation ET, il soustrait l'opérande droit de l'opérande gauche et attribuer le résultat à l'opérande gauche C - = A équivaut à C = C - A
* = Multiplier l'opérateur d'affectation ET, il multiplie l'opérande droit par l'opérande gauche et attribue le résultat à l'opérande gauche C * = A équivaut à C = C * A
/ = Opérateur d'affectation de division ET, il divise l'opérande gauche avec l'opérande droit et affecte le résultat à l'opérande gauche C / = A équivaut à C = C / A
% = Opérateur d'assignation de module ET, il prend le module en utilisant deux opérandes et affecte le résultat à l'opérande de gauche C% = A équivaut à C = C% A
<< = Opérateur de décalage ET d'affectation à gauche C << = 2 est identique à C = C << 2
>> = Opérateur de décalage ET d'affectation à droite C >> = 2 est identique à C = C >> 2
& = Opérateur d'affectation AND au niveau du bit C & = 2 est identique à C = C & 2
^ = OU exclusif au niveau du bit et opérateur d'affectation C ^ = 2 est identique à C = C ^ 2
| = OR inclusif au niveau du bit et opérateur d'affectation C | = 2 est identique à C = C | 2

Priorité des opérateurs dans Scala

La priorité des opérateurs détermine le regroupement des termes dans une expression. Cela affecte la manière dont une expression est évaluée. Certains opérateurs ont une priorité plus élevée que d'autres; par exemple, l'opérateur de multiplication a une priorité plus élevée que l'opérateur d'addition -

Par exemple, x = 7 + 3 * 2; ici, x est attribué à 13, et non à 20 car l'opérateur * a une priorité plus élevée que +, il est donc d'abord multiplié par 3 * 2, puis ajouté en 7.

Jetez un œil au tableau suivant. Les opérateurs ayant la priorité la plus élevée apparaissent en haut du tableau et ceux ayant la priorité la plus faible apparaissent en bas. Dans une expression, les opérateurs de priorité supérieure seront évalués en premier.

Catégorie Opérateur Associativité
Postfix () [] De gauche à droite
Unaire ! ~ De droite à gauche
Multiplicatif * /% De gauche à droite
Additif + - De gauche à droite
Décalage >> >>> << De gauche à droite
Relationnel >> = <<= De gauche à droite
Égalité ==! = De gauche à droite
ET au niveau du bit & De gauche à droite
XOR au niveau du bit ^ De gauche à droite
OU au niveau du bit | De gauche à droite
ET logique && De gauche à droite
OU logique || De gauche à droite
Affectation = + = - = * = / =% = >> = << = & = ^ = | = De droite à gauche
Virgule , De gauche à droite

Ce chapitre vous guide à travers les instructions de construction conditionnelle dans la programmation Scala. Voici la forme générale d'une structure de prise de décision typique IF ... ELSE trouvée dans la plupart des langages de programmation.

Organigramme

Ce qui suit est un organigramme pour l'instruction conditionnelle.

if Déclaration

L'instruction 'if' consiste en une expression booléenne suivie d'une ou plusieurs instructions.

Syntaxe

La syntaxe d'une instruction «if» est la suivante.

if(Boolean_expression) {
   // Statements will execute if the Boolean expression is true
}

Si l'expression booléenne a la valeur true, le bloc de code à l'intérieur de l'expression «if» sera exécuté. Sinon, le premier ensemble de code après la fin de l'expression 'if' (après l'accolade fermante) sera exécuté.

Essayez l'exemple de programme suivant pour comprendre les expressions conditionnelles (if expression) dans le langage de programmation Scala.

Exemple

object Demo {
   def main(args: Array[String]) {
      var x = 10;

      if( x < 20 ){
         println("This is if statement");
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

This is if statement

Instruction If-else

Une instruction 'if' peut être suivie d'une instruction else facultative , qui s'exécute lorsque l'expression booléenne est fausse.

Syntaxe

La syntaxe d'un if ... else est -

if(Boolean_expression){
   //Executes when the Boolean expression is true
} else{
   //Executes when the Boolean expression is false
}

Essayez l'exemple de programme suivant pour comprendre les instructions conditionnelles (instruction if- else) dans le langage de programmation Scala.

Exemple

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x < 20 ){
         println("This is if statement");
      } else {
         println("This is else statement");
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

This is else statement

Instruction If-else-if-else

Une instruction 'if' peut être suivie d'une instruction facultative ' else if ... else ', ce qui est très utile pour tester diverses conditions en utilisant une instruction if ... else if unique.

Lors de l'utilisation des instructions if, else if, else, il y a peu de points à garder à l'esprit.

  • Un «si» peut avoir zéro ou un autre et il doit venir après tout autre si.

  • Un «si» peut avoir zéro à beaucoup d'autres if et ils doivent venir avant l'autre.

  • Une fois qu'un else if réussit, aucun des autres ifs ou else ne sera testé.

Syntaxe

Ce qui suit est la syntaxe d'un 'if ... else if ... else' est la suivante -

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
} else if(Boolean_expression 2){
   //Executes when the Boolean expression 2 is true
} else if(Boolean_expression 3){
   //Executes when the Boolean expression 3 is true
} else {
   //Executes when the none of the above condition is true.
}

Essayez l'exemple de programme suivant pour comprendre les instructions conditionnelles (instruction if- else- if- else) dans le langage de programmation Scala.

Exemple

object Demo {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("Value of X is 10");
      } else if( x == 20 ){
         println("Value of X is 20");
      } else if( x == 30 ){
         println("Value of X is 30");
      } else{
         println("This is else statement");
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Value of X is 30

Instruction if-else imbriquée

Il est toujours légal d'imbriquer if-else instructions, ce qui signifie que vous pouvez en utiliser une if ou else-if déclaration dans un autre if ou else-if déclaration.

Syntaxe

La syntaxe pour un if-else imbriqué est la suivante -

if(Boolean_expression 1){
   //Executes when the Boolean expression 1 is true
   
   if(Boolean_expression 2){
      //Executes when the Boolean expression 2 is true
   }
}

Essayez l'exemple de programme suivant pour comprendre les instructions conditionnelles (instruction if imbriquée) dans le langage de programmation Scala.

Exemple

object Demo {
   def main(args: Array[String]) {
      var x = 30;
      var y = 10;
      
      if( x == 30 ){
         if( y == 10 ){
            println("X = 30 and Y = 10");
         }
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

X = 30 and Y = 10

Ce chapitre vous présente les structures de contrôle de boucle dans les langages de programmation Scala.

Il peut arriver que vous deviez exécuter un bloc de code plusieurs fois. En général, les instructions sont exécutées de manière séquentielle: la première instruction d'une fonction est exécutée en premier, suivie de la seconde, et ainsi de suite.

Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins d'exécution plus compliqués.

Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois et voici la forme générale d'une instruction de boucle dans la plupart des langages de programmation -

Organigramme

Le langage de programmation Scala fournit les types de boucles suivants pour gérer les exigences de bouclage. Cliquez sur les liens suivants dans le tableau pour vérifier leurs détails.

Sr.Non Type de boucle et description
1

while loop

Répète une instruction ou un groupe d'instructions tant qu'une condition donnée est vraie. Il teste la condition avant d'exécuter le corps de la boucle.

2

do-while loop

Comme une instruction while, sauf qu'elle teste la condition à la fin du corps de la boucle.

3

for loop

Exécute une séquence d'instructions plusieurs fois et abrége le code qui gère la variable de boucle.

Déclarations de contrôle de boucle

Les instructions de contrôle de boucle modifient l'exécution de sa séquence normale. Lorsque l'exécution quitte une étendue, tous les objets automatiques qui ont été créés dans cette étendue sont détruits. En tant que tel, Scala ne prend pas en chargebreak ou continuecomme Java le fait mais à partir de la version 2.8 de Scala, il existe un moyen de briser les boucles. Cliquez sur les liens suivants pour vérifier les détails.

Sr.Non Déclaration de contrôle et description
1

break statement

Met fin au loop et transfère l'exécution à l'instruction immédiatement après la boucle.

La boucle infinie

Une boucle devient une boucle infinie si une condition ne devient jamais fausse. Si vous utilisez Scala, lewhile loop est le meilleur moyen d'implémenter une boucle infinie.

Le programme suivant implémente une boucle infinie.

Exemple

object Demo {
   def main(args: Array[String]) {
      var a = 10;
      
      // An infinite loop.
      while( true ){
         println( "Value of a: " + a );
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Si vous exécutez le code ci-dessus, il ira en boucle infinie que vous pouvez terminer en appuyant sur les touches Ctrl + C.

Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
…………….

Une fonction est un groupe d'instructions qui exécutent une tâche. Vous pouvez diviser votre code en fonctions distinctes. La façon dont vous divisez votre code entre différentes fonctions dépend de vous, mais logiquement, la division consiste généralement à ce que chaque fonction effectue une tâche spécifique.

Scala a à la fois des fonctions et des méthodes et nous utilisons les termes méthode et fonction de manière interchangeable avec une différence mineure. Une méthode Scala est une partie d'une classe qui a un nom, une signature, éventuellement des annotations, et un bytecode où en tant que fonction dans Scala est un objet complet qui peut être affecté à une variable. En d'autres termes, une fonction, qui est définie comme membre d'un objet, est appelée une méthode.

Une définition de fonction peut apparaître n'importe où dans un fichier source et Scala autorise des définitions de fonction imbriquées, c'est-à-dire des définitions de fonction dans d'autres définitions de fonction. Le point le plus important à noter est que le nom de la fonction Scala peut avoir des caractères tels que +, ++, ~, &, -, -, \, /,:, etc.

Déclarations de fonction

Une déclaration de fonction Scala a la forme suivante -

def functionName ([list of parameters]) : [return type]

Les méthodes sont implicitement déclarées abstraites si vous n'utilisez pas le signe égal et le corps de la méthode.

Définitions des fonctions

Une définition de fonction Scala a la forme suivante -

Syntaxe

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

Ici, return type peut être n'importe quel type de données Scala valide et list of parameterssera une liste de variables séparées par des virgules et la liste des paramètres et le type de retour sont facultatifs. Très similaire à Java, unreturnL'instruction peut être utilisée avec une expression au cas où la fonction renvoie une valeur. Voici la fonction qui ajoutera deux entiers et retournera leur somme -

Syntaxe

object add {
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

Une fonction qui ne renvoie rien peut renvoyer un Unit c'est équivalent à voiden Java et indique que la fonction ne renvoie rien. Les fonctions qui ne retournent rien dans Scala, ce sont des procédures.

Syntaxe

Voici la syntaxe -

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

Fonctions d'appel

Scala fournit un certain nombre de variations syntaxiques pour appeler des méthodes. Voici la manière standard d'appeler une méthode -

functionName( list of parameters )

Si une fonction est appelée en utilisant une instance de l'objet, nous utiliserions la notation par points similaire à Java comme suit -

[instance.]functionName( list of parameters )

Essayez l'exemple de programme suivant pour définir et appeler la même fonction.

Exemple

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " + addInt(5,7) );
   }
   
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Returned Value : 12

Les fonctions Scala sont au cœur de la programmation Scala et c'est pourquoi Scala est considérée comme un langage de programmation fonctionnel. Voici quelques concepts importants liés aux fonctions Scala qui devraient être compris par un programmeur Scala.

Fonctions Appel par nom Fonctions avec des arguments nommés
Fonction avec des arguments variables Fonctions de récursivité
Valeurs des paramètres par défaut Fonctions d'ordre supérieur
Fonctions imbriquées Fonctions anonymes
Fonctions partiellement appliquées Fonctions de curry

UNE closure est une fonction, dont la valeur de retour dépend de la valeur d'une ou plusieurs variables déclarées en dehors de cette fonction.

Le morceau de code suivant avec une fonction anonyme.

val multiplier = (i:Int) => i * 10

Ici, la seule variable utilisée dans le corps de la fonction, i * 10, est i, qui est défini comme un paramètre de la fonction. Essayez le code suivant -

val multiplier = (i:Int) => i * factor

Il y a deux variables libres dans le multiplicateur: i et factor. L'un d'eux, i, est un paramètre formel de la fonction. Par conséquent, il est lié à une nouvelle valeur chaque fois que le multiplicateur est appelé. cependant,factorn'est pas un paramètre formel, alors qu'est-ce que c'est? Ajoutons une autre ligne de code.

var factor = 3
val multiplier = (i:Int) => i * factor

Maintenant factora une référence à une variable en dehors de la fonction mais dans la portée englobante. Les références de fonctionfactoret lit sa valeur actuelle à chaque fois. Si une fonction n'a pas de références externes, alors elle est trivialement fermée sur elle-même. Aucun contexte externe n'est requis.

Essayez l'exemple de programme suivant.

Exemple

object Demo {
   def main(args: Array[String]) {
      println( "multiplier(1) value = " +  multiplier(1) )
      println( "multiplier(2) value = " +  multiplier(2) )
   }
   var factor = 3
   val multiplier = (i:Int) => i * factor
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

multiplier(1) value = 3
multiplier(2) value = 6

Ce chapitre vous présente les chaînes Scala. Dans Scala, comme en Java, une chaîne est un objet immuable, c'est-à-dire un objet qui ne peut pas être modifié. D'autre part, les objets qui peuvent être modifiés, comme les tableaux, sont appelés objets mutables. Les chaînes sont des objets très utiles, dans le reste de cette section, nous présentons des méthodes importantes dejava.lang.String classe.

Créer une chaîne

Le code suivant peut être utilisé pour créer une chaîne -

var greeting = "Hello world!";

or

var greeting:String = "Hello world!";

Chaque fois que le compilateur rencontre une chaîne littérale dans le code, il crée un objet String avec sa valeur, dans ce cas, «Hello world!». Le mot clé String peut également être donné dans une déclaration alternative comme indiqué ci-dessus.

Essayez l'exemple de programme suivant.

Exemple

object Demo {
   val greeting: String = "Hello, world!"

   def main(args: Array[String]) {
      println( greeting )
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Hello, world!

Comme mentionné précédemment, la classe String est immuable. L'objet chaîne une fois créé ne peut pas être modifié. S'il est nécessaire d'apporter beaucoup de modifications aux chaînes de caractères, utilisez la classe String Builder disponible dans Scala !.

Longueur de chaine

Les méthodes utilisées pour obtenir des informations sur un objet sont appelées méthodes d'accès. Une méthode d'accesseur qui peut être utilisée avec des chaînes est la méthode length (), qui renvoie le nombre de caractères contenus dans l'objet chaîne.

Utilisez le segment de code suivant pour trouver la longueur d'une chaîne -

Exemple

object Demo {
   def main(args: Array[String]) {
      var palindrome = "Dot saw I was Tod";
      var len = palindrome.length();
      
      println( "String Length is : " + len );
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

String Length is : 17

Concaténation de chaînes

La classe String comprend une méthode pour concaténer deux chaînes -

string1.concat(string2);

Cela renvoie une nouvelle chaîne qui est string1 avec string2 ajouté à la fin. Vous pouvez également utiliser la méthode concat () avec des chaînes littérales, comme dans -

"My name is ".concat("Zara");

Les chaînes sont plus communément concaténées avec l'opérateur +, comme dans -

"Hello," + " world" + "!"

Ce qui aboutit à -

"Hello, world!"

Les lignes de code suivantes pour trouver la longueur de la chaîne.

Exemple

object Demo {
   def main(args: Array[String]) {
      var str1 = "Dot saw I was ";
      var str2 =  "Tod";
      
      println("Dot " + str1 + str2);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Dot Dot saw I was Tod

Création de chaînes de format

Vous disposez des méthodes printf () et format () pour imprimer la sortie avec des nombres formatés. La classe String a une méthode de classe équivalente, format (), qui retourne un objet String plutôt qu'un objet PrintStream.

Essayez l'exemple de programme suivant, qui utilise la méthode printf () -

Exemple

object Demo {
   def main(args: Array[String]) {
      var floatVar = 12.456
      var intVar = 2000
      var stringVar = "Hello, Scala!"
      
      var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
      
      println(fs)
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

commander

\>scalac Demo.scala
\>scala Demo

Production

The value of the float variable is 12.456000, 
while the value of the integer variable is 2000, 
and the string is Hello, Scala!()

Interpolation de chaîne

L'interpolation de chaînes est la nouvelle façon de créer des chaînes dans le langage de programmation Scala. Cette fonctionnalité prend en charge les versions de Scala-2.10 et supérieures. Interpolation de chaîne: mécanisme permettant d'incorporer des références de variable directement dans le littéral de chaîne de processus.

Il existe trois types (interpolateurs) d'implémentations dans l'interpolation de chaîne.

L'interpolateur de chaînes 's'

Le littéral «s» permet l'utilisation de la variable directement dans le traitement d'une chaîne, lorsque vous y ajoutez «s». Toute variable String avec une portée qui peut être utilisée avec dans une String. Voici les différentes utilisations de l'interpolateur de chaîne 's'.

L'exemple suivant d'extrait de code pour l'implémentation de l'interpolateur 's' lors de l'ajout de la variable String ($ name) à une chaîne normale (Hello) dans l'instruction println.

val name = “James”
println(s “Hello, $name”) //output: Hello, James

L'interpolateur de chaîne peut également traiter des expressions arbitraires. L'extrait de code suivant pour le traitement d'une chaîne (1 + 1) avec une expression arbitraire ($ {1 + 1}) à l'aide de l'interpolateur de chaîne 's'. Toute expression arbitraire peut être intégrée dans '$ {}'.

println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2

Essayez l'exemple de programme suivant d'implémentation de l'interpolateur 's'.

Exemple

object Demo {
   def main(args: Array[String]) {
      val name = "James"
      
      println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}")
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Hello, James
1 + 1 = 2

L'interpolateur 'f'

L'interpolateur littéral 'f' permet de créer une chaîne formatée, similaire à printf en langage C. Lors de l'utilisation de l'interpolateur 'f', toutes les références de variable doivent être suivies deprintf spécificateurs de format de style tels que% d,% i,% f, etc.

Prenons un exemple d'ajout d'une valeur à virgule flottante (hauteur = 1,9d) et d'une variable String (nom = «James») avec une chaîne normale. L'extrait de code suivant de l'implémentation d'Interpolator «f». Ici$name%s to print (String variable) James and $hauteur% 2,2f à imprimer (valeur en virgule flottante) 1,90.

val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall

Il est de type sécurisé (c'est-à-dire) que la référence de la variable et le spécificateur de format suivant doivent correspondre, sinon il affiche une erreur. L'interpolateur 'f' utilise les utilitaires de format String (spécificateurs de format) disponibles en Java. Par défaut, il n'y a pas de caractère% après la référence de variable. Il supposera que% s (chaîne).

Interpolateur `` brut ''

L'interpolateur «brut» est similaire à l'interpolateur «s» sauf qu'il n'effectue aucun échappement de littéraux dans une chaîne. Les extraits de code suivants dans une table diffèrent de l'utilisation des interpolateurs «s» et «bruts». Dans les sorties des effets de 's' usage '\ n' comme nouvelle ligne et dans la sortie de l'utilisation 'brute', le '\ n' n'aura aucun effet. Il imprimera la chaîne complète avec des lettres d'échappement.

utilisation de l'interpolateur 's' utilisation de l'interpolateur `` brut ''

Program -

object Demo {
   def main(args: Array[String]) {
      println(s"Result = \n a \n b")
   }
}

Program -

object Demo {
   def main(args: Array[String]) {
      println(raw"Result = \n a \n b")
   }
}

Output -

Result =
a
b

Output -

Result = \n a \n b

Méthodes de chaîne

Voici la liste des méthodes définies par java.lang.String classe et peut être utilisé directement dans vos programmes Scala -

Sr.Non Méthodes avec description
1

char charAt(int index)

Renvoie le caractère à l'index spécifié.

2

int compareTo(Object o)

Compare cette chaîne à un autre objet.

3

int compareTo(String anotherString)

Compare deux chaînes lexicographiquement.

4

int compareToIgnoreCase(String str)

Compare deux chaînes lexicographiquement, en ignorant les différences de casse.

5

String concat(String str)

Concatène la chaîne spécifiée à la fin de cette chaîne.

6

boolean contentEquals(StringBuffer sb)

Renvoie true si et seulement si cette chaîne représente la même séquence de caractères que le StringBuffer spécifié.

sept

static String copyValueOf(char[] data)

Renvoie une chaîne qui représente la séquence de caractères dans le tableau spécifié.

8

static String copyValueOf(char[] data, int offset, int count)

Renvoie une chaîne qui représente la séquence de caractères dans le tableau spécifié.

9

boolean endsWith(String suffix)

Teste si cette chaîne se termine par le suffixe spécifié.

dix

boolean equals(Object anObject)

Compare cette chaîne à l'objet spécifié.

11

boolean equalsIgnoreCase(String anotherString)

Compare cette chaîne à une autre chaîne, en ignorant les considérations de casse.

12

byte getBytes()

Encode cette chaîne en une séquence d'octets à l'aide du jeu de caractères par défaut de la plateforme, en stockant le résultat dans un nouveau tableau d'octets.

13

byte[] getBytes(String charsetName)

Encode cette chaîne en une séquence d'octets à l'aide du jeu de caractères nommé, en stockant le résultat dans un nouveau tableau d'octets.

14

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

Copie les caractères de cette chaîne dans le tableau de caractères de destination.

15

int hashCode()

Renvoie un code de hachage pour cette chaîne.

16

int indexOf(int ch)

Renvoie l'index dans cette chaîne de la première occurrence du caractère spécifié.

17

int indexOf(int ch, int fromIndex)

Renvoie l'index dans cette chaîne de la première occurrence du caractère spécifié, en commençant la recherche à l'index spécifié.

18

int indexOf(String str)

Renvoie l'index dans cette chaîne de la première occurrence de la sous-chaîne spécifiée.

19

int indexOf(String str, int fromIndex)

Renvoie l'index dans cette chaîne de la première occurrence de la sous-chaîne spécifiée, en commençant à l'index spécifié.

20

String intern()

Renvoie une représentation canonique de l'objet chaîne.

21

int lastIndexOf(int ch)

Renvoie l'index dans cette chaîne de la dernière occurrence du caractère spécifié.

22

int lastIndexOf(int ch, int fromIndex)

Renvoie l'index dans cette chaîne de la dernière occurrence du caractère spécifié, en recherchant en arrière en commençant à l'index spécifié.

23

int lastIndexOf(String str)

Renvoie l'index dans cette chaîne de l'occurrence la plus à droite de la sous-chaîne spécifiée.

24

int lastIndexOf(String str, int fromIndex)

Renvoie l'index dans cette chaîne de la dernière occurrence de la sous-chaîne spécifiée, en effectuant une recherche en arrière en commençant à l'index spécifié.

25

int length()

Renvoie la longueur de cette chaîne.

26

boolean matches(String regex)

Indique si cette chaîne correspond ou non à l'expression régulière donnée.

27

boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len)

Teste si deux régions de chaîne sont égales.

28

boolean regionMatches(int toffset, String other, int offset, int len)

Teste si deux régions de chaîne sont égales.

29

String replace(char oldChar, char newChar)

Renvoie une nouvelle chaîne résultant du remplacement de toutes les occurrences de oldChar dans cette chaîne par newChar.

30

String replaceAll(String regex, String replacement

Remplace chaque sous-chaîne de cette chaîne qui correspond à l'expression régulière donnée par le remplacement donné.

31

String replaceFirst(String regex, String replacement)

Remplace la première sous-chaîne de cette chaîne qui correspond à l'expression régulière donnée par le remplacement donné.

32

String[] split(String regex)

Divise cette chaîne autour des correspondances de l'expression régulière donnée.

33

String[] split(String regex, int limit)

Divise cette chaîne autour des correspondances de l'expression régulière donnée.

34

boolean startsWith(String prefix)

Teste si cette chaîne commence par le préfixe spécifié.

35

boolean startsWith(String prefix, int toffset)

Teste si cette chaîne commence par le préfixe spécifié commençant un index spécifié.

36

CharSequence subSequence(int beginIndex, int endIndex)

Renvoie une nouvelle séquence de caractères qui est une sous-séquence de cette séquence.

37

String substring(int beginIndex)

Renvoie une nouvelle chaîne qui est une sous-chaîne de cette chaîne.

38

String substring(int beginIndex, int endIndex)

Renvoie une nouvelle chaîne qui est une sous-chaîne de cette chaîne.

39

char[] toCharArray()

Convertit cette chaîne en un nouveau tableau de caractères.

40

String toLowerCase()

Convertit tous les caractères de cette chaîne en minuscules en utilisant les règles des paramètres régionaux par défaut.

41

String toLowerCase(Locale locale)

Convertit tous les caractères de cette chaîne en minuscules en utilisant les règles du paramètre régional donné.

42

String toString()

Cet objet (qui est déjà une chaîne!) Est lui-même retourné.

43

String toUpperCase()

Convertit tous les caractères de cette chaîne en majuscules en utilisant les règles des paramètres régionaux par défaut.

44

String toUpperCase(Locale locale)

Convertit tous les caractères de cette chaîne en majuscules en utilisant les règles du paramètre régional donné.

45

String trim()

Renvoie une copie de la chaîne, en omettant les espaces de début et de fin.

46

static String valueOf(primitive data type x)

Renvoie la représentation sous forme de chaîne de l'argument de type de données transmis.

Scala fournit une structure de données, le array, qui stocke une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de variables du même type.

Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99, vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ..., les nombres [99] pour représenter variables individuelles. Ce didacticiel explique comment déclarer des variables de tableau, créer des tableaux et traiter des tableaux à l'aide de variables indexées. L'index du premier élément d'un tableau est le nombre zéro et l'indice du dernier élément est le nombre total d'éléments moins un.

Déclaration des variables de tableau

Pour utiliser un tableau dans un programme, vous devez déclarer une variable pour référencer le tableau et vous devez spécifier le type de tableau auquel la variable peut faire référence.

Voici la syntaxe pour déclarer une variable de tableau.

Syntaxe

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

Ici, z est déclaré comme un tableau de chaînes pouvant contenir jusqu'à trois éléments. Les valeurs peuvent être attribuées à des éléments individuels ou accéder à des éléments individuels, cela peut être fait en utilisant des commandes comme les suivantes -

Commander

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Ici, le dernier exemple montre qu'en général, l'index peut être n'importe quelle expression qui donne un nombre entier. Il existe une autre façon de définir un tableau -

var z = Array("Zara", "Nuha", "Ayan")

L'image suivante représente un tableau myList. Ici,myList contient dix valeurs doubles et les indices vont de 0 à 9.

Traitement des tableaux

Lors du traitement des éléments d'un tableau, nous utilisons souvent des structures de contrôle de boucle car tous les éléments d'un tableau sont du même type et la taille du tableau est connue.

Voici un exemple de programme montrant comment créer, initialiser et traiter des tableaux -

Exemple

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      
      println("Max is " + max);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala ne prend pas directement en charge diverses opérations sur les tableaux et fournit diverses méthodes pour traiter les tableaux dans n'importe quelle dimension. Si vous souhaitez utiliser les différentes méthodes, il est nécessaire d'importerArray._ paquet.

Tableaux multidimensionnels

Il existe de nombreuses situations où vous auriez besoin de définir et d'utiliser des tableaux multidimensionnels (c'est-à-dire des tableaux dont les éléments sont des tableaux). Par exemple, les matrices et les tables sont des exemples de structures qui peuvent être réalisées sous forme de tableaux bidimensionnels.

Voici un exemple de définition d'un tableau à deux dimensions -

var myMatrix = ofDim[Int](3,3)

Il s'agit d'un tableau qui a trois éléments chacun étant un tableau d'entiers qui a trois éléments.

Essayez l'exemple de programme suivant pour traiter un tableau multidimensionnel -

Exemple

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

0 1 2
0 1 2
0 1 2

Concaténer les tableaux

Essayez l'exemple suivant qui utilise la méthode concat () pour concaténer deux tableaux. Vous pouvez passer plus d'un tableau comme arguments à la méthode concat ().

Exemple

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Créer un tableau avec une plage

Utilisation de la méthode range () pour générer un tableau contenant une séquence d'entiers croissants dans une plage donnée. Vous pouvez utiliser l'argument final comme étape pour créer la séquence; si vous n'utilisez pas d'argument final, l'étape sera considérée comme 1.

Prenons un exemple de création d'un tableau de plage (10, 20, 2): cela signifie créer un tableau avec des éléments entre 10 et 20 et une différence de plage 2. Les éléments du tableau sont 10, 12, 14, 16 et 18 .

Un autre exemple: range (10, 20). Ici, la différence de plage n'est pas donnée donc par défaut, elle suppose 1 élément. Il crée un tableau avec les éléments compris entre 10 et 20 avec une différence de plage 1. Les éléments du tableau sont 10, 11, 12, 13,… et 19.

L'exemple de programme suivant montre comment créer un tableau avec des plages.

Exemple

import Array._

object Demo {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Méthodes de tableau Scala

Voici les méthodes importantes que vous pouvez utiliser tout en jouant avec un tableau. Comme indiqué ci-dessus, vous devrez importerArray._package avant d'utiliser l'une des méthodes mentionnées. Pour une liste complète des méthodes disponibles, veuillez consulter la documentation officielle de Scala.

Sr.Non Méthodes avec description
1

def apply( x: T, xs: T* ): Array[T]

Crée un tableau d'objets T, où T peut être Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean.

2

def concat[T]( xss: Array[T]* ): Array[T]

Concatène tous les tableaux en un seul tableau.

3

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit

Copiez un tableau dans un autre. Équivalent à System.arraycopy de Java (src, srcPos, dest, destPos, length).

4

def empty[T]: Array[T]

Renvoie un tableau de longueur 0

5

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]

Renvoie un tableau contenant des applications répétées d'une fonction à une valeur de départ.

6

def fill[T]( n: Int )(elem: => T): Array[T]

Renvoie un tableau qui contient les résultats de certains calculs d'éléments un certain nombre de fois.

sept

def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]

Renvoie un tableau à deux dimensions qui contient les résultats de certains calculs d'éléments un certain nombre de fois.

8

def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T]

Renvoie un tableau contenant des applications répétées d'une fonction à une valeur de départ.

9

def ofDim[T]( n1: Int ): Array[T]

Crée un tableau avec des dimensions données.

dix

def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]]

Crée un tableau à 2 dimensions

11

def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]]

Crée un tableau en 3 dimensions

12

def range( start: Int, end: Int, step: Int ): Array[Int]

Renvoie un tableau contenant des valeurs également espacées dans un intervalle entier.

13

def range( start: Int, end: Int ): Array[Int]

Renvoie un tableau contenant une séquence d'entiers croissants dans une plage.

14

def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]

Renvoie un tableau contenant les valeurs d'une fonction donnée sur une plage de valeurs entières à partir de 0.

15

def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]

Renvoie un tableau à deux dimensions contenant les valeurs d'une fonction donnée sur des plages de valeurs entières à partir de 0.

Scala possède un riche ensemble de bibliothèques de collections. Les collections sont des conteneurs d'objets. Ces conteneurs peuvent être séquencés, des ensembles linéaires d'éléments tels que List, Tuple, Option, Map, etc. Les collections peuvent avoir un nombre arbitraire d'éléments ou être limitées à zéro ou à un élément (par exemple, Option).

Les collections peuvent être strict ou lazy. Les collections paresseuses ont des éléments qui peuvent ne pas consommer de mémoire jusqu'à ce qu'ils soient accédés, commeRanges. De plus, les collections peuvent êtremutable (le contenu de la référence peut changer) ou immutable(la chose à laquelle une référence fait référence n'est jamais modifiée). Notez que les collections immuables peuvent contenir des éléments mutables.

Pour certains problèmes, les collections mutables fonctionnent mieux et pour d'autres, les collections immuables fonctionnent mieux. En cas de doute, il est préférable de commencer avec une collection immuable et de la modifier plus tard si vous en avez besoin.

Ce chapitre met en lumière les types de collections les plus couramment utilisés et les opérations les plus fréquemment utilisées sur ces collections.

Sr.Non Collections avec description
1

Scala Lists

La liste de Scala [T] est une liste chaînée de type T.

2

Scala Sets

Un ensemble est une collection d'éléments différents par paires du même type.

3

Scala Maps

Une carte est une collection de paires clé / valeur. Toute valeur peut être récupérée en fonction de sa clé.

4

Scala Tuples

Contrairement à un tableau ou une liste, un tuple peut contenir des objets de différents types.

5

Scala Options

L'option [T] fournit un conteneur pour zéro ou un élément d'un type donné.

6

Scala Iterators

Un itérateur n'est pas une collection, mais plutôt un moyen d'accéder aux éléments d'une collection un par un.

Un trait encapsule les définitions de méthode et de champ, qui peuvent ensuite être réutilisées en les mélangeant dans des classes. Contrairement à l'héritage de classe, dans lequel chaque classe doit hériter d'une seule superclasse, une classe peut mélanger n'importe quel nombre de traits.

Les traits sont utilisés pour définir les types d'objets en spécifiant la signature des méthodes prises en charge. Scala permet également aux traits d'être partiellement implémentés, mais les traits peuvent ne pas avoir de paramètres de constructeur.

Une définition de trait ressemble à une définition de classe sauf qu'elle utilise le mot-clé trait. Voici l'exemple de syntaxe de base de trait.

Syntaxe

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

Ce trait se compose de deux méthodes isEqual et isNotEqual. Ici, nous n'avons donné aucune implémentation pour isEqual alors qu'une autre méthode a son implémentation. Les classes enfants étendant un trait peuvent donner une implémentation pour les méthodes non implémentées. Donc, un trait est très similaire à ce que nous avonsabstract classes en Java.

Supposons un exemple de trait Equal contiennent deux méthodes isEqual() et isNotEqual(). Le traitEqual contiennent une méthode implémentée qui est isEqual() donc lorsque la classe définie par l'utilisateur Point étend le trait Equal, mise en œuvre à isEqual() méthode dans Point la classe doit être fournie.

Ici, il est nécessaire de connaître deux méthodes importantes de Scala, qui sont utilisées dans l'exemple suivant.

  • obj.isInstanceOf [Point] Pour vérifier le type d'obj et le point ne sont pas identiques.

  • obj.asInstanceOf [Point] signifie une conversion exacte en prenant le type d'obj d'obj et renvoie le même obj que le type de point.

Essayez l'exemple de programme suivant pour implémenter des traits.

Exemple

trait Equal {
   def isEqual(x: Any): Boolean
   def isNotEqual(x: Any): Boolean = !isEqual(x)
}

class Point(xc: Int, yc: Int) extends Equal {
   var x: Int = xc
   var y: Int = yc
   
   def isEqual(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == y
}

object Demo {
   def main(args: Array[String]) {
      val p1 = new Point(2, 3)
      val p2 = new Point(2, 4)
      val p3 = new Point(3, 3)

      println(p1.isNotEqual(p2))
      println(p1.isNotEqual(p3))
      println(p1.isNotEqual(2))
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

true
false
true

Classes de valeur et traits universels

Les classes de valeur sont un nouveau mécanisme dans Scala pour éviter d'allouer des objets d'exécution. Il contient un constructeur principal avec exactement unvalparamètre. Il contient uniquement des méthodes (def) non autorisées var, val, classes imbriquées, traits ou objets. La classe de valeur ne peut pas être étendue par une autre classe. Cela peut être possible en étendant votre classe de valeur avec AnyVal. La sécurité des types de données personnalisées sans la surcharge d'exécution.

Prenons un exemple de classes de valeurs Poids, Taille, Email, Âge, etc. Pour tous ces exemples, il n'est pas nécessaire d'allouer de la mémoire dans l'application.

Une classe de valeur non autorisée à étendre des traits. Pour permettre aux classes de valeurs d'étendre les traits,universal traits sont introduits qui s'étendent pour Any.

Exemple

trait Printable extends Any {
   def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable

object Demo {
   def main(args: Array[String]) {
      val w = new Wrapper(3)
      w.print() // actually requires instantiating a Wrapper instance
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Il vous donnera le code de hachage de la classe Wrapper.

Wrapper@13

Quand utiliser les traits?

Il n'y a pas de règle ferme, mais voici quelques lignes directrices à prendre en compte -

  • Si le comportement ne sera pas réutilisé, faites-en une classe concrète. Ce n'est pas un comportement réutilisable après tout.

  • S'il peut être réutilisé dans plusieurs classes non liées, faites-en un trait. Seuls les traits peuvent être mélangés dans différentes parties de la hiérarchie des classes.

  • Si tu veux inherit à partir de celui-ci en code Java, utilisez une classe abstraite.

  • Si vous prévoyez de le distribuer sous forme compilée et que vous vous attendez à ce que des groupes extérieurs écrivent des classes en héritant, vous pourriez vous pencher vers l'utilisation d'une classe abstraite.

  • Si l'efficacité est très importante, privilégiez l'utilisation d'une classe.

La correspondance de modèles est la deuxième fonctionnalité la plus utilisée de Scala, après les valeurs de fonction et les fermetures. Scala fournit un excellent support pour la correspondance de modèles, dans le traitement des messages.

Une correspondance de modèle comprend une séquence d'alternatives, chacune commençant par le mot-clé case. Chaque alternative comprend unpattern et un ou plusieurs expressions, qui sera évalué si le modèle correspond. Un symbole de flèche => sépare le motif des expressions.

Essayez l'exemple de programme suivant, qui montre comment faire correspondre une valeur entière.

Exemple

object Demo {
   def main(args: Array[String]) {
      println(matchTest(3))
   }
   
   def matchTest(x: Int): String = x match {
      case 1 => "one"
      case 2 => "two"
      case _ => "many"
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

many

Le bloc avec les instructions case définit une fonction, qui mappe les entiers aux chaînes. Le mot-clé match fournit un moyen pratique d'appliquer une fonction (comme la fonction de correspondance de modèle ci-dessus) à un objet.

Essayez l'exemple de programme suivant, qui compare une valeur à des modèles de types différents.

Exemple

object Demo {
   def main(args: Array[String]) {
      println(matchTest("two"))
      println(matchTest("test"))
      println(matchTest(1))
   }
   
   def matchTest(x: Any): Any = x match {
      case 1 => "one"
      case "two" => 2
      case y: Int => "scala.Int"
      case _ => "many"
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

2
many
one

Correspondance à l'aide de classes de cas

le case classessont des classes spéciales utilisées dans la mise en correspondance de modèles avec des expressions de casse. Syntaxiquement, ce sont des classes standard avec un modificateur spécial:case.

Essayez ce qui suit, il s'agit d'un simple exemple de correspondance de modèle utilisant la classe de cas.

Exemple

object Demo {
   def main(args: Array[String]) {
      val alice = new Person("Alice", 25)
      val bob = new Person("Bob", 32)
      val charlie = new Person("Charlie", 32)
   
      for (person <- List(alice, bob, charlie)) {
         person match {
            case Person("Alice", 25) => println("Hi Alice!")
            case Person("Bob", 32) => println("Hi Bob!")
            case Person(name, age) => println(
               "Age: " + age + " year, name: " + name + "?")
         }
      }
   }
   case class Person(name: String, age: Int)
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Hi Alice!
Hi Bob!
Age: 32 year, name: Charlie?

L'ajout du mot-clé case oblige le compilateur à ajouter automatiquement un certain nombre de fonctionnalités utiles. Le mot-clé suggère une association avec des expressions de cas dans la correspondance de modèles.

Tout d'abord, le compilateur convertit automatiquement les arguments du constructeur en champs immuables (vals). Le mot clé val est facultatif. Si vous voulez des champs mutables, utilisez le mot-clé var. Ainsi, nos listes d'arguments de constructeur sont désormais plus courtes.

Deuxièmement, le compilateur implémente automatiquement equals, hashCode, et toStringméthodes à la classe, qui utilisent les champs spécifiés comme arguments du constructeur. Ainsi, nous n'avons plus besoin de nos propres méthodes toString ().

Enfin, aussi, le corps de Person La classe devient vide car il n'y a pas de méthodes que nous devons définir!

Ce chapitre explique comment Scala prend en charge les expressions régulières via Regex classe disponible dans le package scala.util.matching.

Essayez l'exemple de programme suivant dans lequel nous allons essayer de trouver le mot Scala à partir d'une déclaration.

Exemple

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = "Scala".r
      val str = "Scala is Scalable and cool"
      
      println(pattern findFirstIn str)
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Some(Scala)

Nous créons une chaîne et appelons le r( )méthode là-dessus. Scala convertit implicitement le String en RichString et appelle cette méthode pour obtenir une instance de Regex. Pour trouver une première correspondance de l'expression régulière, appelez simplement lefindFirstIn()méthode. Si au lieu de ne trouver que la première occurrence, nous souhaitons trouver toutes les occurrences du mot correspondant, nous pouvons utiliser lefindAllIn( ) et si plusieurs mots Scala sont disponibles dans la chaîne cible, cela renverra une collection de tous les mots correspondants.

Vous pouvez utiliser la méthode mkString () pour concaténer la liste résultante et vous pouvez utiliser un tube (|) pour rechercher des minuscules et des majuscules de Scala et vous pouvez utiliser Regex constructeur à la place ou r() méthode pour créer un motif.

Essayez l'exemple de programme suivant.

Exemple

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("(S|s)cala")
      val str = "Scala is scalable and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Scala,scala

Si vous souhaitez remplacer le texte correspondant, nous pouvons utiliser replaceFirstIn( ) pour remplacer la première correspondance ou replaceAllIn( ) pour remplacer toutes les occurrences.

Exemple

object Demo {
   def main(args: Array[String]) {
      val pattern = "(S|s)cala".r
      val str = "Scala is scalable and cool"
      
      println(pattern replaceFirstIn(str, "Java"))
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Java is scalable and cool

Former des expressions régulières

Scala hérite de sa syntaxe d'expression régulière de Java, qui à son tour hérite de la plupart des fonctionnalités de Perl. Voici quelques exemples qui devraient suffire à rafraîchir -

Le tableau suivant répertorie toutes les syntaxes de caractères méta d'expression régulière disponibles en Java.

Sous-expression Allumettes
^ Correspond au début de la ligne.
$ Correspond à la fin de la ligne.
. Correspond à n'importe quel caractère unique sauf le saut de ligne. L'utilisation de l'option m lui permet également de correspondre à la nouvelle ligne.
[...] Correspond à n'importe quel caractère unique entre crochets.
[^ ...] Correspond à n'importe quel caractère unique non entre crochets
\\UNE Début de la chaîne entière
\\ z Fin de toute la chaîne
\\ Z Fin de la chaîne entière sauf terminateur de ligne final autorisé.
ré* Correspond à 0 occurrences ou plus de l'expression précédente.
re + Correspond à 1 ou plusieurs éléments précédents
ré? Correspond à 0 ou 1 occurrence de l'expression précédente.
re {n} Correspond exactement au nombre n d'occurrences de l'expression précédente.
re {n,} Correspond à n occurrences ou plus de l'expression précédente.
re {n, m} Correspond à au moins n et au plus m occurrences de l'expression précédente.
a | b Correspond à a ou b.
(ré) Regroupe les expressions régulières et mémorise le texte correspondant.
(?: re) Regroupe les expressions régulières sans se souvenir du texte correspondant.
(?> re) Correspond à un motif indépendant sans retour en arrière.
\\ w Correspond aux caractères des mots.
\\ W Correspond aux caractères non-mots.
\\ s Correspond aux espaces. Équivaut à [\ t \ n \ r \ f].
\\ S Correspond à un espace non blanc.
\\ré Correspond aux chiffres. Équivalent à [0-9].
\\RÉ Correspond aux non-chiffres.
\\UNE Correspond au début de la chaîne.
\\ Z Correspond à la fin de la chaîne. Si une nouvelle ligne existe, elle correspond juste avant la nouvelle ligne.
\\ z Correspond à la fin de la chaîne.
\\G Correspond au point où le dernier match s'est terminé.
\\ n Référence arrière pour capturer le numéro de groupe "n"
\\ b Correspond aux limites des mots en dehors des crochets. Correspond à l'espace arrière (0x08) lorsqu'il est entre crochets.
\\ B Correspond aux limites non-mot.
\\ n, \\ t, etc. Correspond aux retours à la ligne, aux retours chariot, aux tabulations, etc.
\\ Q Échapper (guillemet) tous les caractères jusqu'à \\ E
\\ E Fin des citations commencées par \\ Q

Exemples d'expressions régulières

Exemple La description
. Correspond à n'importe quel caractère sauf le saut de ligne
[Rr] uby Correspondre à "Ruby" ou "ruby"
frotter [vous] Correspondre à "ruby" ou "rube"
[aeiou] Correspond à n'importe quelle voyelle minuscule
[0-9] Correspond à n'importe quel chiffre; identique à [0123456789]
[az] Correspond à n'importe quelle lettre ASCII minuscule
[AZ] Correspond à n'importe quelle lettre ASCII majuscule
[a-zA-Z0-9] Correspond à l'un des éléments ci-dessus
[^ aeiou] Correspond à tout autre chose qu'une voyelle minuscule
[^ 0-9] Correspond à autre chose qu'un chiffre
\\ré Faire correspondre un chiffre: [0-9]
\\RÉ Faire correspondre un non-chiffre: [^ 0-9]
\\ s Faire correspondre un caractère d'espacement: [\ t \ r \ n \ f]
\\ S Correspondre à un espace non blanc: [^ \ t \ r \ n \ f]
\\ w Faire correspondre un seul caractère de mot: [A-Za-z0-9_]
\\ W Correspond à un caractère non-mot: [^ A-Za-z0-9_]
rubis? Match "rub" ou "ruby": le y est facultatif
rubis* Correspond à "frotter" plus 0 ou plus de y
rubis + Correspond à "frotter" plus 1 ou plus de y
\\ d {3} Correspond exactement à 3 chiffres
\\ d {3,} Correspond à 3 chiffres ou plus
\\ d {3,5} Correspond à 3, 4 ou 5 chiffres
\\ D \\ d + Aucun groupe: + répète \\ d
(\\ D \\ d) + / Groupé: + répète \\ D \ d paire
([Rr] uby (,)?) + Correspond à "Ruby", "Ruby, ruby, ruby", etc.

Note- que chaque barre oblique inverse apparaît deux fois dans la chaîne ci-dessus. En effet, en Java et Scala, une seule barre oblique inverse est un caractère d'échappement dans une chaîne littérale, et non un caractère régulier qui apparaît dans la chaîne. Donc, au lieu de «\», vous devez écrire «\\» pour obtenir une seule barre oblique inverse dans la chaîne.

Essayez l'exemple de programme suivant.

Exemple

import scala.util.matching.Regex

object Demo {
   def main(args: Array[String]) {
      val pattern = new Regex("abl[ae]\\d+")
      val str = "ablaw is able1 and cool"
      
      println((pattern findAllIn str).mkString(","))
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

able1

Les exceptions de Scala fonctionnent comme des exceptions dans de nombreux autres langages comme Java. Au lieu de renvoyer une valeur de la manière normale, une méthode peut se terminer en lançant une exception. Cependant, Scala n'a pas réellement vérifié les exceptions.

Lorsque vous voulez gérer des exceptions, vous utilisez un bloc try {...} catch {...} comme vous le feriez en Java, sauf que le bloc catch utilise la correspondance pour identifier et gérer les exceptions.

Lancer des exceptions

Lancer une exception ressemble à celui de Java. Vous créez un objet d'exception, puis vous le lancez avec lethrow mot-clé comme suit.

throw new IllegalArgumentException

Attraper les exceptions

Scala vous permet de try/catch toute exception dans un seul bloc, puis effectuez une correspondance de modèle avec caseblocs. Essayez l'exemple de programme suivant pour gérer l'exception.

Exemple

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException =>{
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Missing file exception

Le comportement de ce try-catchexpression est la même que dans les autres langues à quelques exceptions près. Le corps est exécuté, et s'il lève une exception, chaquecatch la clause est essayée à son tour.

La clause enfin

Vous pouvez envelopper une expression avec un finallysi vous souhaitez que du code s'exécute quelle que soit la façon dont l'expression se termine. Essayez le programme suivant.

Exemple

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOException

object Demo {
   def main(args: Array[String]) {
      try {
         val f = new FileReader("input.txt")
      } catch {
         case ex: FileNotFoundException => {
            println("Missing file exception")
         }
         
         case ex: IOException => {
            println("IO Exception")
         }
      } finally {
         println("Exiting finally...")
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Missing file exception
Exiting finally...

Un extracteur dans Scala est un objet qui a une méthode appelée unapplycomme l'un de ses membres. Le but de cette méthode unapply est de faire correspondre une valeur et de la démonter. Souvent, l'objet extracteur définit également une méthode doubleapply pour les valeurs de construction, mais ce n'est pas obligatoire.

Exemple

Prenons un exemple d'objet définit les deux apply et unapplyméthodes. La méthode apply a la même signification que toujours: elle transforme Test en un objet qui peut être appliqué aux arguments entre parenthèses de la même manière qu'une méthode est appliquée. Vous pouvez donc écrire Test ("Zara", "gmail.com") pour construire la chaîne "[email protected]".

le unapply est ce qui transforme la classe Test en une extractor et il renverse le processus de construction de apply. Où apply prend deux chaînes et en forme une chaîne d'adresse e-mail, unapply prend une adresse e-mail et renvoie potentiellement deux chaînes: leuser et le domain de l'adresse.

le unapplydoit également gérer le cas où la chaîne donnée n'est pas une adresse e-mail. C'est pourquoi unapply renvoie un type Option sur des paires de chaînes. Son résultat est soitSome (user, domain)si la chaîne str est une adresse e-mail avec les parties utilisateur et domaine données, ou None, si str n'est pas une adresse e-mail. Voici quelques exemples comme suit.

Syntaxe

unapply("[email protected]") equals Some("Zara", "gmail.com")
unapply("Zara Ali") equals None

L'exemple de programme suivant montre un objet extracteur pour les adresses e-mail.

Exemple

object Demo {
   def main(args: Array[String]) {
      println ("Apply method : " + apply("Zara", "gmail.com"));
      println ("Unapply method : " + unapply("[email protected]"));
      println ("Unapply method : " + unapply("Zara Ali"));
   }
   
   // The injection method (optional)
   def apply(user: String, domain: String) = {
      user +"@"+ domain
   }

   // The extraction method (mandatory)
   def unapply(str: String): Option[(String, String)] = {
      val parts = str split "@"
      
      if (parts.length == 2){
         Some(parts(0), parts(1)) 
      } else {
         None
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Apply method : [email protected]
Unapply method : Some((Zara,gmail.com))
Unapply method : None

Correspondance de motifs avec des extracteurs

Lorsqu'une instance d'une classe est suivie de parenthèses avec une liste de zéro ou plusieurs paramètres, le compilateur appelle le applyméthode sur cette instance. Nous pouvons définir appliquer à la fois dans les objets et dans les classes.

Comme mentionné ci-dessus, le but de la unapplyméthode consiste à extraire une valeur spécifique que nous recherchons. Il fait l'opération inverseapplyEst-ce que. Lors de la comparaison d'un objet extracteur à l'aide dematch déclaration le unapply La méthode sera automatiquement exécutée.

Essayez l'exemple de programme suivant.

Exemple

object Demo {
   def main(args: Array[String]) {
      val x = Demo(5)
      println(x)

      x match {
         case Demo(num) => println(x+" is bigger two times than "+num)
         
         //unapply is invoked
         case _ => println("i cannot calculate")
      }
   }
   def apply(x: Int) = x*2
   def unapply(z: Int): Option[Int] = if (z%2==0) Some(z/2) else None
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

10
10 is bigger two times than 5

Scala est ouvert pour utiliser tous les objets Java et java.io.File est l'un des objets qui peuvent être utilisés dans la programmation Scala pour lire et écrire des fichiers.

Voici un exemple de programme pour écrire dans un fichier.

Exemple

import java.io._

object Demo {
   def main(args: Array[String]) {
      val writer = new PrintWriter(new File("test.txt" ))

      writer.write("Hello Scala")
      writer.close()
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Cela créera un fichier nommé Demo.txtdans le répertoire courant, où le programme est placé. Voici le contenu de ce fichier.

Production

Hello Scala

Lire une ligne à partir de la ligne de commande

Parfois, vous devez lire l'entrée utilisateur à partir de l'écran, puis procéder à un traitement supplémentaire. L'exemple de programme suivant vous montre comment lire l'entrée à partir de la ligne de commande.

Exemple

object Demo {
   def main(args: Array[String]) {
      print("Please enter your input : " )
      val line = Console.readLine
      
      println("Thanks, you just typed: " + line)
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Please enter your input : Scala is great
Thanks, you just typed: Scala is great

Lecture du contenu du fichier

La lecture à partir de fichiers est vraiment simple. Vous pouvez utiliser ScalaSourceclass et son objet compagnon pour lire les fichiers. Voici l'exemple qui vous montre comment lire à partir de"Demo.txt" fichier que nous avons créé précédemment.

Exemple

import scala.io.Source

object Demo {
   def main(args: Array[String]) {
      println("Following is the content read:" )

      Source.fromFile("Demo.txt" ).foreach { 
         print 
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

Following is the content read:
Hello Scala