Littéraux Scala

En Scala, les littéraux sont des expressions qui représentent directement des valeurs fixes.

Scala prend en charge divers types de littéraux, notamment numériques, caractères, chaînes, booléens, etc.

Littéraux entiers

Les littéraux entiers sont utilisés pour le type Int. Pour représenter Long, vous pouvez ajouter L ou l minuscule comme suffixe après le nombre.

Les littéraux entiers peuvent être décimaux, hexadécimaux et octaux.

  • Décimal :42, 0, -99
  • Hexadécimal : en utilisant0xou0Xcomme préfixe, tel que0x2A, 0x0, 0XFF
  • Octal : Avant Scala 2.10, les littéraux octaux étaient pris en charge, en utilisant0comme préfixe, mais les littéraux octaux ont été supprimés dans Scala 2.10 et les versions ultérieures.
val decimal = 42
val hex = 0x2A

Littéraux à virgule flottante

Si un nombre à virgule flottante est suivi d'un suffixe f ou F, il représente un type Float ; sinon, il s'agit d'un type Double.

  • Double précision :3.14, -0.001, 1.0e-10
  • Simple précision :3.14f, -0.001F
val doubleValue = 3.14
val floatValue = 3.14f

Littéraux booléens

Les littéraux booléens ont true et false.

val isScalaFun = true
val isSkyGreen = false

Littéraux de symboles

Les littéraux de symboles s'écrivent comme suit :'<identifier>, ici<identifier>peut être n'importe quel identifiant alphanumérique (remarque : il ne peut pas commencer par un chiffre). Ce littéral est mis en correspondance avec une instance de la classe prédéfinie scala.Symbol.

Par exemple : le littéral de symbole'xest un raccourci pour l'expressionscala.Symbol("x")les littéraux de symbole sont définis comme suit :

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

Littéraux de caractères

En Scala, les variables de caractère utilisent des guillemets simples'pour les définir, comme suit :

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

Où\représente un caractère d'échappement, qui peut être suivi deu0041chiffres ou\r\net d'autres caractères d'échappement fixes.

Littéraux de chaîne

En Scala, les littéraux de chaîne utilisent des guillemets doubles"pour les définir, comme suit :

"Hello,\nWorld!"
"Example官网:www.example.com"
  • Chaîne normale :"Hello, World!"
  • Chaîne multiligne : utiliser des guillemets triples"""pour l'encadrer, peut contenir des sauts de ligne et des guillemets.

Représentation des chaînes multilignes

Les chaînes multilignes utilisent trois guillemets doubles comme délimiteurs, le format est :""" ... """。

L'exemple est le suivant :

val foo = """Example
www.example.com
www.runnoob.com
以上三个地址都能访问"""

Valeur Null

Null est un littéral spécial qui représente la valeur null de tous les types référence.

La valeur null est de type scala.Null.

Scala.Null et scala.Nothing sont des types spéciaux qui gèrent de manière unifiée certains « cas limites » du système de types orienté objet de Scala.

La classe Null est le type de l'objet de référence null ; elle est une sous-classe de chaque classe de référence (les classes héritant de AnyRef). Null n'est pas compatible avec les types valeur.

val nullValue: String = null

Unit

Le type Unit n'a qu'une seule valeur d'instance, en utilisant le littéral()pour le représenter, similaire à void en Java.

val unitValue: Unit = ()

Exemple

Voici un exemple de code utilisant différents types de littéraux :

Exemple

object LiteralsExample {
  def main(args: Array[String]): Unit = {
    // littéraux numériques
    val decimal = 42
    val hex = 0x2A
    val doubleValue = 3.14
    val floatValue = 3.14f
   
    // littéraux de caractères
    val charA = 'A'
    val charNewLine = '\n'
   
    // littéraux de chaînes
    val greeting = "Bonjour, monde !"
    val multilineString = """Ceci est
                            |une chaîne
                            |multi-ligne"
"".stripMargin
   
    // littéraux booléens
    val isScalaFun = true
    val isSkyGreen = false
   
    // littéraux spéciaux
    val nullValue: String = null
    val unitValue: Unit = ()
   
    // exemple de sortie
    println(s"Décimal: $decimal, Hex: $hex")
    println(s"Double: $doubleValue, Float: $floatValue")
    println(s"Caractère: $charA, Nouvelle ligne: $charNewLine")
    println(s"Salutation : $greeting")
    println(s"Chaîne multiligne : $multilineString")
    println(s"Scala est-il amusant : $isScalaFun, Le ciel est-il vert : $isSkyGreen")
    println(s"Valeur nulle : $nullValue, Valeur Unit : $unitValue")
  }
}

Le résultat de la compilation et de l'exécution du code ci-dessus est :

Decimal: 42, Hex: 42
Double: 3.14, Float: 3.14
Char: A, New Line: 

Greeting: Hello, World!
Multiline String: This is
a multi-line
string
Is Scala Fun: true, Is Sky Green: false
Null Value: null, Unit Value: ()
Autres extensions