Scala para la comprensión
¿Qué es la comprensión en Scala en Ubuntu 20?.04
El formato para (enumeradores) proporciona "E" en comprensiones donde los enumeradores son una lista de enumeradores separados por semicolones. Un generador que agrega nuevas variables es un enumerador, mientras que un filtro es un enumerador. Cada unión creada por los enumeradores se evalúa mediante una comprensión, que luego genera una secuencia de valores para cada valor.
Sintaxis de comprensión en Scala
Estamos dirigidos por estas definiciones a los conceptos de definiciones, filtros y generadores para la comprensión. Una Scala para Comprefrensión incluye las siguientes tres expresiones:
mi <- elements // generator
N = D.Nombre // Definición
if (expresión) // filtrar
producir
Generadores
Los generadores son como iteradores que iteran sobre todos los elementos. Aquí hay otros dos hechos relacionados con los generadores: (1) Un generador es el primer paso en cada comprensión, (2) se utilizan múltiples generadores para la comprensión.
Filtros
Los filtros toman la forma de condiciones booleanas dentro de una comprendimiento. Un filtro sirve como guardia, evitando que todos los valores se usen que violen la condición booleana. Cada variable a la que se puede acceder dentro del alcance de la comprensión para construir una condición booleana personalizada dentro de un filtro.
Definiciones
La definición es algo que usamos para explicar precisamente qué es lo que deseamos lograr o hacer. Por ejemplo, podemos incluir todas las operaciones que deseamos llevar a cabo en la parte definitoria.
Ejemplo 1: Uso de la competencia con rendimientos
Para construir una nueva colección a partir de una colección existente, combine el bucle for, su algoritmo y una declaración de rendimiento. Una comprensión es la aplicación de un bucle for con una declaración de rendimiento. Ponga el trabajo en un bloque después de la palabra clave de rendimiento si su enfoque requiere numerosas líneas de código:
Creamos el objeto como "demo1" donde tenemos una definición de la función principal. Dentro de eso, construimos la clase de caso "Asunto". La clase tiene dos atributos: el "nombre" establecido en el tipo de cadena y el "artículo" asignado al tipo "int". Después de esto, declaramos una variable "SujetBase" que tiene la representación de la lista. La lista se inicializa con el nombre de los tres sujetos y números de artículo, respectivamente.
A continuación, definimos el generador, la definición y el filtro dentro de la comprensión de foración que se establece en la variable "Morethanten". Dentro de la competencia, el "sujeto" se extendió por cada elemento dentro de la "Sujetbase". Entonces, tenemos una declaración "si" que indica el filtro aquí. La declaración "si" que tiene el "sujeto.artículo> = 10 && sujeto.artículo< 20 ” condition means that the article that doesn't seem to be between 10 and 20 is filtered away.
Debajo de la competencia, utilizamos la palabra clave "rendimiento" que agrega el tema.nombre. Desde el sujeto.El nombre es una cadena, el operador de rendimiento recopila el resultado como una lista [cadena].
En la salida, puede visualizar la lista de nombres de sujetos generados como mayores que el artículo número 10 y menos que el número de artículo 20.
Ejemplo 2: Uso de la comprensión sin rendimientos en Scala
Podemos dejar de lado el rendimiento en comprensión. Cuando eso sucede, la comprensión devuelve una unidad. Si queremos realizar los efectos secundarios, esto puede ser útil. Aquí hay un programa similar que no usa el rendimiento:
Comenzamos el objeto del programa como "demo2". En eso, tenemos la definición del método principal. Dentro del método principal, tenemos otra definición de función. La función se define como "verificar" que toma la variable "x" como una entrada y la establece con el tipo de int. Asignamos la competencia para esta función. La comprensión de la comprensión tiene el generador y el filtro. El generador tiene la iteración de I y J.
Luego, la condición "i*j> = x" se lleva a cabo aquí si la condición se protege como un filtro. A medida que asignamos el valor de la variable "x" como "5". En la iteración inicial, I y J son cero. Por lo tanto, i * j no es mayor que x, y nada se produce así. Antes de ser elevado a 1, J aumenta tres veces más. Tanto los valores de I y J en cada iteración hasta que la condición esté satisfecha y se impriman mediante el método Println.
El compilador de Scala al compilar produce los siguientes resultados:
Ejemplo 3: Uso de la competencia con dos generadores en Scala
Aquí hay otra instancia en la que empleamos dos generadores en la "por comprensión" pero con la palabra clave de rendimiento.
En este ejemplo, tenemos una definición de función "producto" que se desarrolla para calcular todos los pares de números que varían entre 0 y X-1 cuyo producto coincide con un valor específico y. Tenemos dos generadores, I y J, que aumentan en 1 hasta que x como se indica en la comprensión de. Luego usamos el filtro según sea necesario. Iteramos a través de la lista con el para cada bucle y destruyimos cada miembro como (i, j). Luego, salga los emparejamientos.
También creamos la lista que el método devolvió sin filtros para mostrar las etapas que los generadores yo y J toman. Los resultados demuestran que si bien uno de los generadores aumenta en N-1, el otro permanece fijo. El segundo generador aumenta en 1 cuando el primero llega a N-1.
Puede ver la salida de la lista generada con y sin el filtro en la competencia de la siguiente manera:
Conclusión
Las diferentes capacidades y la funcionalidad de las comprensiones de Scala se hicieron conscientes a través del artículo antes mencionado. Con la ayuda de múltiples ejemplos, demostramos las diversas ventajas de usar la comprensión de Scala en el modelo de programación Scala. Después de eso, aprendimos sobre las muchas capacidades y cómo funciona el rendimiento. Como resultado, ahora podremos crear el código mientras utilizamos la comprensión de Scala.