Maison >développement back-end >tutoriel php >[VISITE DE SCALA] 2-Bases - VISITE DE SCALA
Dans cette page, nous présenterons les bases de Scala.
Vous pouvez exécuter Scala dans ScalaFiddle dans le navigateur.
Ouvrez https://scalafiddle.io
Collez println("Hello, world!")
Cliquez sur le bouton "Exécuter". La sortie est affichée dans le volet de droite.
Il s'agit d'un moyen simple et sans configuration de tester des extraits de code Scala.
Les expressions sont des déclarations calculables.
1 + 1
Vous pouvez utiliser println
pour afficher le résultat d'une expression.
println(1) // 1 println(1 + 1) // 2 println("Hello!") // Hello! println("Hello," + " world!") // Hello, world!
Vous pouvez utiliser le mot-clé val
pour nommer le résultat d'une expression. Le résultat d'un nom
val x = 1 + 1println(x) // 2
, comme x
ici, s'appelle une valeur. Faire référence à une valeur ne la recalcule pas.
Les valeurs ne peuvent pas être réaffectées.
val x = 1 + 1x = 3 // This does not compile.
Le compilateur peut déduire le type de la valeur, mais vous pouvez également déclarer le type explicitement, comme suit :
val x: Int = 1 + 1
Notez que la déclaration de type Int
est dans identifiant x
, et un :
doit être ajouté entre eux.
Les variables sont comme des valeurs, mais vous pouvez les réaffecter. Vous pouvez définir une variable à l'aide du mot-clé var
.
var x = 1 + 1x = 3 // This compiles because "x" is declared with the "var" keyword. println(x * x) // 9
Comme pour les valeurs, vous pouvez déclarer explicitement des types :
var x: Int = 1 + 1
Vous pouvez combiner des expressions environnantes. Nous appelons ce bloc de code. Le résultat de la dernière expression du bloc
est également le résultat du bloc entier.
println({ val x = 1 + 1 x + 1 }) // 3
Une fonction est une expression avec des paramètres.
Vous pouvez définir une fonction anonyme (c'est-à-dire sans nom) qui renvoie un entier donné + 1 :
(x: Int) => x + 1
Sur le côté gauche du symbole de lancement =>
se trouve une liste de paramètres . À droite se trouve une expression contenant des paramètres.
Vous pouvez également nommer des fonctions.
val addOne = (x: Int) => x + 1 println(addOne(1)) // 2
La fonction peut prendre plusieurs paramètres.
val add = (x: Int, y: Int) => x + y println(add(1, 2)) // 3
Ou alors, cela ne prend aucun paramètre.
val getTheAnswer = () => 42 println(getTheAnswer()) // 42
Les méthodes ressemblent beaucoup aux fonctions, mais il existe quelques différences clés entre elles. La méthode
est définie à l'aide du mot-clé def
. def
est suivi du nom de la méthode, de la liste des paramètres, d'un type de retour et d'un corps.
def add(x: Int, y: Int): Int = x + y println(add(1, 2)) // 3
Notez que le type de retour est déclaré après la liste des paramètres et les deux points : Int
.
Les méthodes peuvent prendre plusieurs listes de paramètres.
def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier println(addThenMultiply(1, 2)(3)) // 9
Ou pas de liste de paramètres du tout.
def name: String = System.getProperty("name") println("Hello, " + name + "!")
Il existe d'autres différences, mais pour l'instant, vous pouvez les considérer comme quelque chose de similaire aux fonctions.
Les méthodes peuvent également avoir des expressions multilignes. La dernière expression de
def getSquareString(input: Double): String = { val square = input * input square.toString }
body
est la valeur de retour de la méthode. (Scala a un mot-clé de retour return
, mais il est rarement utilisé.)
Vous pouvez définir une classe en utilisant le mot-clé de classe class
puis utiliser son nom et sa fonction constructeur paramètres. Le type de retour de la méthode
class Greeter(prefix: String, suffix: String) { def greet(name: String): Unit = println(prefix + name + suffix) }
greet
est Unit
, ce qui signifie que le retour n'a aucune signification. Il est similaire au mot-clé void
en Java et C (la différence est que, comme chaque expression Scala doit avoir une certaine valeur, il existe en fait une valeur singleton de type Unit
, écrite sous la forme ()
. Elle ne contient aucune information. )
Vous pouvez utiliser le mot-clé new
pour créer une instance d'une classe.
val greeter = new Greeter("Hello, ", "!") greeter.greet("Scala developer") // Hello, Scala developer!
Nous présenterons les cours en détail plus tard.
Scala a un type spécial de classe appelé classe "exemple". Par défaut, les exemples de classes sont immuables et se comparent par valeur.
Vous pouvez définir des exemples de classes à l'aide du mot-clé case class
.
case class Point(x: Int, y: Int)
Vous pouvez instancier des exemples de classes sans utiliser le mot-clé new
.
val point = Point(1, 2) val anotherPoint = Point(1, 2) val yetAnotherPoint = Point(2, 2)
Ils sont comparés par valeur.
if (point == anotherPoint) { println(point + " and " + anotherPoint + " are the same.") } else { println(point + " and " + anotherPoint + " are different.") } // Point(1,2) and Point(1,2) are the same. if (point == yetAnotherPoint) { println(point + " and " + yetAnotherPoint + " are the same.") } else { println(point + " and " + yetAnotherPoint + " are different.") } // Point(1,2) and Point(2,2) are different.
Il y a de nombreux autres exemples de cours que nous souhaitons vous présenter, nous pensons que vous en tomberez amoureux ! Nous les présenterons en détail ultérieurement.
Les objets sont des instances uniques de leur propre définition. Vous pouvez les considérer comme des célibataires de leur propre classe.
Vous pouvez définir des objets en utilisant le mot-clé object
.
object IdFactory { private var counter = 0 def create(): Int = { counter += 1 counter } }
Vous pouvez accéder à un objet en référençant son nom.
val newId: Int = IdFactory.create() println(newId) // 1 val newerId: Int = IdFactory.create() println(newerId) // 2
Nous aborderons les objets en détail plus tard.
Les traits sont des types qui contiennent certains champs et méthodes. Plusieurs fonctionnalités peuvent être combinées ensemble.
Vous pouvez définir des traits en utilisant le mot-clé trait
.
trait Greeter { def greet(name: String): Unit }
Les fonctionnalités peuvent également avoir des implémentations par défaut.
trait Greeter { def greet(name: String): Unit = println("Hello, " + name + "!") }
Vous pouvez étendre les fonctionnalités à l'aide du mot-clé extends
et remplacer les implémentations à l'aide du mot-clé override
.
class DefaultGreeter extends Greeter class CustomizableGreeter(prefix: String, postfix: String) extends Greeter { override def greet(name: String): Unit = { println(prefix + name + postfix) } } val greeter = new DefaultGreeter() greeter.greet("Scala developer") // Hello, Scala developer! val customGreeter = new CustomizableGreeter("How are you, ", "?") customGreeter.greet("Scala developer") // How are you, Scala developer?
Ici, DefaultGreeter
n'étend qu'un seul trait, mais il peut étendre plusieurs traits.
Nous présenterons les traits en détail plus tard.
La méthode principale est le point d'entrée d'un programme. La machine virtuelle Java nécessite une méthode principale nommée main
et accepte un paramètre, un tableau de chaînes.
À l'aide d'objets, vous pouvez définir une méthode principale comme suit :
object Main { def main(args: Array[String]): Unit = println("Hello, Scala developer!") }
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!