Escala | literales

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.

1. 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.
    
   Los literales enteros se especifican de dos maneras:
   • 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

   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.

2. 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.

3. 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 .

4. 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 .

5. 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 .

6. 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