Identificadores de Scala

En los lenguajes de programación, los identificadores se utilizan con fines de identificación. En Scala, un identificador puede ser un nombre de clase, un nombre de método, un nombre de variable o un nombre de objeto. 
Por ejemplo :  

class GFG{
    var a: Int = 20
}
object Main {
    def main(args: Array[String]) {
        var ob = new GFG();
    }
}

En el programa anterior tenemos 6 identificadores: 

• GFG: Nombre de clase
• a: nombre de la variable
• Principal: nombre del objeto
• principal: nombre del método
• argumentos: nombre de la variable
• ob: nombre del objeto 

Reglas para definir Java Scala

Hay ciertas reglas para definir un identificador de Scala válido. Estas reglas deben seguirse, de lo contrario obtenemos un error de tiempo de compilación .  

• Los identificadores de Scala distinguen entre mayúsculas y minúsculas.
• Scala no le permite usar palabras clave como identificador.
• Las palabras reservadas no se pueden usar como un identificador como $, etc.
• Scala solo permitió aquellos identificadores que se crean utilizando los siguientes cuatro tipos de identificadores.
• No hay límite en la longitud del identificador, pero se recomienda utilizar una longitud óptima de 4 a 15 letras únicamente.
• Los identificadores no deben comenzar con dígitos ([0-9]) . Por ejemplo, «123geeks» no es un identificador de Scala válido.

Ejemplo: 

// Scala program to demonstrate
// Identifiers
 
object Main
{
     
    // Main method
    def main(args: Array[String])
    {
         
    // Valid Identifiers
    var `name` = "Siya";
    var _age = 20;
    var Branch = "Computer Science";
    println("Name:" +`name`);
    println("Age:" +_age);
    println("Branch:" +Branch);
    }
}

Producción:  

Name:Siya
Age:20
Branch:Computer Science

En el ejemplo anterior, los identificadores válidos son:  

Main, main, args, `name`, _age, Branch, +

y las palabras clave son: 

Object, def, var, println

Tipos de identificadores de Scala

Scala admite cuatro tipos de identificadores: 

• Identificadores alfanuméricos: estos identificadores son aquellos identificadores que comienzan con una letra (mayúscula o minúscula) o un guión bajo y siguen letras, dígitos o guiones bajos.
  Ejemplo de identificadores alfanuméricos válidos: 

 _GFG, geeks123, _1_Gee_23, Geeks

Ejemplo de identificadores alfanuméricos no válidos: 

123G, $Geeks, -geeks

Ejemplo: 

// Scala program to demonstrate
// Alphanumeric Identifiers
 
object Main
{
     
    // Main method
    def main(args: Array[String])
    {
         
    // main, _name1, and Tuto_rial are
    // valid alphanumeric identifiers
    var _name1: String = "GeeksforGeeks"
    var Tuto_rial: String = "Scala"
     
    println(_name1);
    println(Tuto_rial);
    }
}

Producción: 

GeeksforGeeks
Scala

• Identificadores de operadores: estos son aquellos identificadores que contienen uno o más caracteres de operadores como +, :, ?, ~ o #, etc. 
  Ejemplo de identificadores de operadores válidos: 

 +, ++ 

Ejemplo: 

// Scala program to demonstrate
// Operator Identifiers
 
object Main
{
     
    // Main method
    def main(args: Array[String])
    {
         
    // main, x, y, and sum are valid
    // alphanumeric identifiers
    var x:Int = 20;
    var y:Int = 10;
     
    // Here, + is a operator identifier
    // which is used to add two values
    var sum = x + y;
    println("Display the result of + identifier:");
    println(sum);
    }
}

Producción: 

Display the result of + identifier:
30

• Identificadores Mixtos: Son aquellos identificadores que contienen identificadores alfanuméricos seguidos de un soceo y un identificador de operador. 
  Ejemplo de identificadores mixtos válidos: 

 unary_+, sum_= 

Ejemplo: 

// Scala program to demonstrate
// Mixed Identifiers
 
object Main
{
     
    // Main method
    def main(args: Array[String])
    {
         
    // num_+ is a valid mixed identifier
    var num_+ = 20;
    println("Display the result of mixed identifier:");
    println(num_+);
    }
}

Producción: 

Display the result of mixed identifier:
20

• Identificadores literales: estos son aquellos identificadores en los que se incluye una string arbitraria con tildes invertidas (`….`). 
  Ejemplo de identificadores mixtos válidos: 

`Geeks`, `name` 

Ejemplo: 

// Scala program to demonstrate
// Literal Identifiers
 
object Main
{
     
    // Main method
    def main(args: Array[String])
    {
         
    // `name` and `age` are valid literal identifiers
    var `name` = "Siya"
    var `age` = 20
    println("Name:" +`name`);
    println("Age:" +`age`);
    }
}

Producción: 

Name:Siya
Age:20