Types de données Scala

Scala a les mêmes types de données que Java. Le tableau suivant répertorie les types de données pris en charge par Scala :

数据类型	描述
Byte	8位有符号补码整数。数值区间为 -128 到 127
Short	16位有符号补码整数。数值区间为 -32768 到 32767
Int	32位有符号补码整数。数值区间为 -2147483648 到 2147483647
Long	64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807
Float	32位IEEE754单精度浮点数
Double	64位IEEE754单精度浮点数
Char	16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF
String	字符序列
Boolean	true或false
Unit	表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。
Null	null 或空引用
Nothing	Nothing类型在Scala的类层级的最低端；它是任何其他类型的子类型。
Any	Any是所有其他类的超类
AnyRef	AnyRef类是Scala里所有引用类(reference class)的基类

Les types de données répertoriés dans le tableau ci-dessus sont tous des objets, ce qui signifie que scala n'a pas de types natifs en Java. Dans Scala, vous pouvez appeler des méthodes sur des types de base tels que des nombres.

---

Les littéraux de base de Scala

Scala est très simple et intuitif. Nous présenterons ensuite en détail les littéraux Scala.

Littéral entier

Le littéral entier est utilisé pour le type Int S'il représente Long, vous pouvez ajouter L ou l minuscule comme suffixe après le nombre. :

0
035
21 
0xFFFFFFFF 
0777L

Litéral à virgule flottante

S'il y a un suffixe f ou F après le nombre à virgule flottante, cela signifie qu'il s'agit d'un type Float, sinon c'est un type Double. Les exemples sont les suivants :

0.0 
1e30f 
3.14159f 
1.0e100
.1

littéral booléen

Les littéraux booléens incluent vrai et faux.

Littéral de symbole

Le littéral de symbole s'écrit comme : '<identifier>, où <identifier> peut être n'importe quel identifiant alphanumérique (remarque : ne peut pas commencer par un chiffre). Ce littéral est mappé à une instance de la classe prédéfinie scala.Symbol.

Par exemple : Le symbole littéral 'x est l'abréviation de l'expression scala.Symbol("x") Le symbole littéral est défini comme suit :

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

<. 🎜> Le caractère littéral

en scala est exprimé sous forme de caractère entre guillemets simples demi-chasse ('), comme suit :

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

où

représente un caractère de transfert, qui peuvent être suivis de u0041 chiffres ou de caractères d'échappement fixes tels que rn.

Chaîne littérale

La méthode de représentation de chaîne consiste à inclure une série de caractères entre guillemets doubles ("), tels que :

"Hello,\nWorld!"
"php中文网官网：www.php.cn"

La méthode de représentation de chaîne multiligne

Les chaînes multilignes utilisent trois guillemets doubles pour représenter le délimiteur, et le format est :

""" ... """ L'exemple de

est le suivant suit :

val foo = """php中文网
www.php.cn
www.w3cschool.cc
www.runnoob.com
以上三个地址都能访问"""

Valeur nulle

La valeur nulle est de type scala.Null

Scala.Null et scala.Nothing sont utilisés pour gérer certains "cas extrêmes" de l'objet de Scala. -système de types orienté de manière unifiée. " est un type spécial.

La classe Null est le type d'objet de référence nul, qui est une sous-classe de chaque classe de référence (la classe qui hérite d'AnyRef). Null n'est pas un type de valeur compatible

Caractères d'échappement Scala

Le tableau suivant répertorie les caractères d'échappement courants :

Les caractères Unicode entre 0 et 255 peuvent être représentés par une séquence d'échappement octale, c'est-à-dire une barre oblique inverse suivie de Jusqu'à trois octaux.

Dans un caractère ou une chaîne, la barre oblique inverse et la séquence de caractères suivante ne peuvent pas former une séquence d'échappement légale, ce qui entraînera Erreur de compilation.

L'exemple suivant montre l'utilisation de certains caractères d'échappement :

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

Exécutez l'exemple »

Exécutez le code ci-dessus et le résultat de sortie est le suivant :

$ scalac Test.scala
$ scala Test
Hello	World


$