Scala - Syntaxe de base

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!");

Il 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 par $ deux points $ moins $ supérieur.

Identifiants mixtes

Un identifiant mixte se compose d'un identifiant alphanumérique, 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 saisir un si vous le souhaitez, mais vous n'êtes pas obligé de le faire 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 de 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 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 l'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)