Cualquier valor constante que se pueda asignar a la variable se denomina literal/constante. Los literales son una serie de símbolos utilizados para describir un valor constante en el código. Hay muchos tipos de literales en Scala, a saber, literales de caracteres, literales de string, literales de string de varias líneas, literales booleanos, literales enteros y literales de punto flotante.
Tipos de literales
- Literales enteros:
Los literales enteros son generalmente de tipo Int o de tipo Long cuando se agrega un sufijo L o l al final de los enteros. Tanto el tipo Int como el tipo Long son números enteros.
Nota:- El rango del tipo Int es de (-231 a 230).
- El rango del tipo Long es de (-263 a 262).
- Cuando un literal Integer tiene un número que cae fuera de este rango, surge un error de tiempo de compilación.
- Literales decimales:
Aquí, los dígitos permitidos son del 0 al 9.val x = 37
- Literales hexadecimales:
aquí, los dígitos permitidos son del 0 al 9 y los caracteres utilizados son de la a a la f. Podemos utilizar mayúsculas y minúsculas.// The hexa-decimal number should be prefix // with 0X or 0x. val x = 0xFFF
Los literales enteros se especifican de dos maneras:Ejemplo:
// Scala program of integer
// literals
// Creating object
object
integer
{
// Main method
def
main(args
:
Array[String])
{
// decimal-form literal
val
a
=
46
// Hexa-decimal form literal
val
b
=
0xfF
// Displays results in
// integer form
println(a)
println(b)
}
}
Producción:46 255
Nota: La forma octal del literal está obsoleta.
- Literales de Punto Flotante:
Este tipo de literales son de tipo Double así como de tipo Float cuando se agrega un sufijo F o f al final e incluso podemos especificar el tipo Double con el sufijo d o D.val x = 3.14159
Ejemplo:
// Scala program of floating
// point literals
// Creating object
object
double
{
// Main method
def
main(args
:
Array[String])
{
// decimal-form literal
val
a
=
3.156
// It is also a decimal
// form of the literal
val
b
=
0123.34
// Displays results
println(a)
println(b)
}
}
Producción:3.156 123.34
Aquí, no podemos especificar literales en forma octal o hexadecimal.
- Literales
de caracteres: los literales de caracteres son caracteres uni-code que se pueden imprimir o se representan mediante secuencias de escape.val x = 'b' //character literal in a single quote.
val x = '\u0051' //uni-code representation of character literal, //This uni-code represents Q.
val x = '\n' //Escape sequence in character literals
Ejemplo:
// Scala program of character
// literal
// Creating object
object
literal
{
// Main method
def
main(args
:
Array[String])
{
// Creating a character literal
// in single quote
val
x
=
'b'
// uni-code representation of
// character literal
val
y
=
'\u0051'
// Escape sequence in character
// literals
val
z
=
'\n'
// Displays results
println(x)
println(y)
println(z)
}
}
Producción:b Q
Los caracteres literales se encierran entre comillas simples .
- Literales de string:
Los literales de string son series de caracteres, que están disponibles entre comillas dobles. Los literales de string se pueden manejar sin problemas utilizando la interpolación de strings.val x = "GfG"
Ejemplo:
// Scala program of literals
// Creating object
object
literal
{
// Main method
def
main(args
:
Array[String])
{
// Creating a string
// literal
val
x
=
"GeeksforGeeks"
// Displays string
// literals
println(x)
}
}
Producción:GeeksforGeeks
Los literales de string de una sola línea están encerrados entre comillas .
- Literales de string
de varias líneas: los literales de string de varias líneas también son series de caracteres, pero tienen varias líneas.val x = """GfG"""
Ejemplo:
// Scala program of multi-line
// string literals
// Creating object
object
literal
{
// Main method
def
main(args
:
Array[String])
{
// Creating a multiple
// line string literal
val
x
=
""
"GeeksforGeeks
is a
computer science
portal"
""
// Displays multiple
// lines
println(x)
}
}
Producción:GeeksforGeeks is a computer science portal
Los literales de string de varias líneas están encerrados entre comillas triples .
- Literales booleanos:
los literales booleanos permiten solo dos valores, es decir, verdadero y falso , que son miembros del tipo booleano.val x = true
Ejemplo:
// Scala program of Boolean
// literals
// Creating object
object
GfG
{
// Main method
def
main(args
:
Array[String])
{
// Assigning true
val
a
=
true
// Assigning false
val
b
=
false
// Displays results
println(a)
println(b)
}
}
Producción:true false
Publicación traducida automáticamente
Artículo escrito por nidhi1352singh y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA