Extractores de escala

En Scala Extractor se define como un objeto que tiene un método llamado desaplicar como una de sus partes. Este método extrae un objeto y devuelve los atributos. Este método también se utiliza en la coincidencia de patrones y las funciones parciales. Extractors también explica el método apply , que toma los argumentos y construye un objeto, por lo que es útil para construir valores. El método de no aplicar invierte el procedimiento de construcción del método de aplicación . 
  
El tipo de devolución del método no aplicado se puede seleccionar como se indica a continuación: 

• Si es un procedimiento de verificación, devuelva un tipo booleano .
• Si el procedimiento devuelve solo un subvalor de tipo T, devuelva una Opción[T].
• Si el procedimiento devuelve varios subvalores de tipo T1, T2,…, Tn, devuelve una tupla opcional, es decir, Opción[(T1, T2,…, Tn)].
• Si el procedimiento devuelve un número impredecible de valores, entonces los extractores se pueden definir con unapplySeq que devuelve Option[Seq[T]].

Ejemplo : 

// Scala program of extractors
 
// Creating object
object Name
{
 
    // Main method
    def main(args: Array[String])
    {
     
        // Defining apply method
        def apply(firstname: String, lastname: String) =
        {
            firstname +"kumari"+ lastname
     
        }
 
        // Defining unapply method
        def unapply(x: String): Option[(String, String)] =
        {
     
            // Applying a method split
            val y = x.split("kumari")
     
            if (y.length == 2)
            {
                 
                Some(y(0), y(1))
             
            }
            else
                    None
     
        }
     
        // Displays output
        println ("The Apply method returns : " +
                        apply("Nidhi", "Singh"))
        println ("The Unapply method returns : " +
                        unapply("NidhikumariSingh"))
    }
}

The Apply method returns : NidhikumariSingh
The Unapply method returns : Some((Nidhi, Singh))

Aquí, este ejemplo muestra un objeto extractor para Name. El objeto Name define dos métodos apply y unapply . El método de aplicación acepta los argumentos especificados entre paréntesis y también crea un valor como se especifica en el método. Se devuelve el nombre y el apellido combinados con kumari (segundo nombre) en el medio. El método de no aplicar rompe los argumentos como se especifica y devuelve el objeto firstname a un extractor. Devuelve un par de strings si como argumento se pasan el nombre y el apellido; de lo contrario, no devuelve ninguno. 

Ejemplo :  

// Scala program of extractors
 
// Creating object
object GfG
{
 
    // Main method
    def main(args: Array[String])
    {
     
        // Defining apply method
        def apply(q: Double): Double = q * 10
 
        // Defining unapply method
        def unapply(r: Int): Option[Int] = {
     
            if (r % 5 == 0)
            {
                Some(r * 5)
            }
            else
                None
     
        }
     
        // Displays output
        println ("The Apply method returns : " + apply(20))
        println ("The Unapply method returns : " + unapply(35))
    }
}

The Apply method returns : 200.0
The Unapply method returns : Some(175)

Aquí, este ejemplo muestra un objeto extractor para GFG. El objeto GFG define dos métodos apply y unapply . El método apply acepta los argumentos de tipo doble. Cuando llamamos al método apply , el argumento pasado se multiplica por 10 y devuelve el número multiplicado. El método de no aplicar rompe los argumentos si el valor pasado es divisible por 5 que el valor pasado se multiplica por 5 y devuelve eso (r * 5) de lo contrario no devuelve ninguno. 

• Uso de extractores con la coincidencia de patrones: 
  los extractores se pueden utilizar en la coincidencia de patrones. Al comparar el objeto de un extractor en la coincidencia de patrones, el método de no aplicar se ejecutará espontáneamente. 
  Ejemplo: 

// Scala program of extractors
// with pattern matching
 
// Creating object
object GfG
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Assigning value to the
        // object
        val x = GfG(25)
 
        // Displays output of the
        // Apply method
        println(x)
 
        // Applying pattern matching
        x match
        {
 
            // unapply method is called
            case GfG(y) => println("The value is: "+y)
            case _ => println("Can't be evaluated")
     
        }
    }
     
    // Defining apply method
    def apply(x: Double) = x / 5
 
    // Defining unapply method
    def unapply(z: Double): Option[Double] =
 
        if (z % 5 == 0)
        {
            Some(z/5)
        }
     
        else None
}

5.0
The value is: 1.0

• Nota: una clase de caso ya tiene un extractor, por lo que se puede utilizar espontáneamente con la coincidencia de patrones. 
   
• Uso de extractores para pruebas: 
  para usar un extractor para pruebas, se devuelve un tipo booleano. 
  Ejemplo: 

// Scala program of extractors
// to return a Boolean type
 
// Creating object
object GfG
{
 
    // Main method
    def main(args: Array[String])
    {
 
        // Defining unapply method
        def unapply(x:Int): Boolean = {
     
            if (x % 3 == 0)
            {
                true
            }
            else
                    false
        }
         
        // Displays output in Boolean type
        println ("The Unapply method returns : " + unapply(12))
        println ("The Unapply method returns : " + unapply(35))
 
    }
}

true
false

Aquí, el objeto GFG define un método no aplicable. durante la llamada del método de no aplicar , se pasa un parámetro si el valor se divide por 3 que devuelve verdadero ; de lo contrario, devuelve falso .